一，单路快排
1.测试用例：

  1.  #ifndef INC_06_QUICK_SORT_DEAL_WITH_NEARLY_ORDERED_ARRAY_SORTTESTHELPER_H
  2.  #define INC_06_QUICK_SORT_DEAL_WITH_NEARLY_ORDERED_ARRAY_SORTTESTHELPER_H
  3.  #include <iostream>
  4.  #include <algorithm>
  5.  #include <string>
  6.  #include <ctime>
  7.  #include <cassert>
  8.  using namespace std;
  9.  namespace SortTestHelper {
  10.      // 生成有n个元素的随机数组,每个元素的随机范围为[rangeL, rangeR]
  11.      int *generateRandomArray(int n, int range_l, int range_r) {
  12.          int *arr = new int[n];
  13.          srand(time(NULL));
  14.          for (int i = ; i < n; i++)
  15.              arr[i] = rand() % (range_r - range_l + ) + range_l;
  16.          return arr;
  17.      }
  18.      // 生成一个近乎有序的数组
  19.      // 首先生成一个含有[0...n-1]的完全有序数组, 之后随机交换swapTimes对数据
  20.      // swapTimes定义了数组的无序程度
  21.      int *generateNearlyOrderedArray(int n, int swapTimes){
  22.          int *arr = new int[n];
  23.          for(int i =  ; i < n ; i ++ )
  24.              arr[i] = i;
  25.          srand(time(NULL));
  26.          for( int i =  ; i < swapTimes ; i ++ ){
  27.              int posx = rand()%n;
  28.              int posy = rand()%n;
  29.              swap( arr[posx] , arr[posy] );
  30.          }
  31.          return arr;
  32.      }
  33.      // 拷贝整型数组a中的所有元素到一个新的数组, 并返回新的数组
  34.      int *copyIntArray(int a[], int n){
  35.          int *arr = new int[n];
  36.          copy(a, a+n, arr);
  37.          return arr;
  38.      }
  39.      // 打印arr数组的所有内容
  40.      template<typename T>
  41.      void printArray(T arr[], int n) {
  42.          for (int i = ; i < n; i++)
  43.              cout << arr[i] << " ";
  44.          cout << endl;
  45.  
  46.          return;
  47.      }
  48.      // 判断arr数组是否有序
  49.      template<typename T>
  50.      bool isSorted(T arr[], int n) {
  51.          for (int i = ; i < n - ; i++)
  52.              if (arr[i] > arr[i + ])
  53.                  return false;
  54.          return true;
  55.      }
  56.      // 测试sort排序算法排序arr数组所得到结果的正确性和算法运行时间
  57.      template<typename T>
  58.      void testSort(const string &sortName, void (*sort)(T[], int), T arr[], int n) {
  59.          clock_t startTime = clock();
  60.          sort(arr, n);
  61.          clock_t endTime = clock();
  62.          cout << sortName << " : " << double(endTime - startTime) / CLOCKS_PER_SEC << " s"<<endl;
  63.          assert(isSorted(arr, n));
  64.          return;
  65.      }
  66.  };
  67.  #endif

2.归并排序：

  1.  #ifndef INC_06_QUICK_SORT_DEAL_WITH_NEARLY_ORDERED_ARRAY_MERGESORT_H
  2.  #define INC_06_QUICK_SORT_DEAL_WITH_NEARLY_ORDERED_ARRAY_MERGESORT_H
  3.  #include <iostream>
  4.  #include <algorithm>
  5.  #include "InsertionSort.h"
  6.  using namespace std;
  7.  // 将arr[l...mid]和arr[mid+1...r]两部分进行归并
  8.  template<typename  T>
  9.  void __merge(T arr[], int l, int mid, int r){
  10.      T aux[r-l+];
  11.      //T *aux = new T[r-l+1];
  12.      for( int i = l ; i <= r; i ++ )
  13.          aux[i-l] = arr[i];
  14.      // 初始化，i指向左半部分的起始索引位置l；j指向右半部分起始索引位置mid+1
  15.      int i = l, j = mid+;
  16.      for( int k = l ; k <= r; k ++ ){
  17.          if( i > mid ){  // 如果左半部分元素已经全部处理完毕
  18.              arr[k] = aux[j-l]; j ++;
  19.          }
  20.          else if( j > r ){  // 如果右半部分元素已经全部处理完毕
  21.              arr[k] = aux[i-l]; i ++;
  22.          }
  23.          else if( aux[i-l] < aux[j-l] ) {  // 左半部分所指元素 < 右半部分所指元素
  24.              arr[k] = aux[i-l]; i ++;
  25.          }
  26.          else{  // 左半部分所指元素 >= 右半部分所指元素
  27.              arr[k] = aux[j-l]; j ++;
  28.          }
  29.      }
  30.      //delete[] aux;
  31.  }
  32.  // 使用优化的归并排序算法, 对arr[l...r]的范围进行排序
  33.  template<typename T>
  34.  void __mergeSort(T arr[], int l, int r){
  35.      // 对于小规模数组, 使用插入排序
  36.      if( r - l <=  ){
  37.          insertionSort(arr, l, r);
  38.          return;
  39.      }
  40.      int mid = (l+r)/;
  41.      __mergeSort(arr, l, mid);
  42.      __mergeSort(arr, mid+, r);
  43.      // 对于arr[mid] <= arr[mid+1]的情况,不进行merge
  44.      // 对于近乎有序的数组非常有效,但是对于一般情况,有一定的性能损失
  45.      if( arr[mid] > arr[mid+] )
  46.          __merge(arr, l, mid, r);
  47.  }
  48.  template<typename T>
  49.  void mergeSort(T arr[], int n){
  50.      __mergeSort( arr ,  , n- );
  51.  }
  52.  #endif

3.优化时要用的插入排序：

  1.  #ifndef INC_06_QUICK_SORT_DEAL_WITH_NEARLY_ORDERED_ARRAY_INSERTIONSORT_H
  2.  #define INC_06_QUICK_SORT_DEAL_WITH_NEARLY_ORDERED_ARRAY_INSERTIONSORT_H
  3.  #include <iostream>
  4.  #include <algorithm>
  5.  using namespace std;
  6.  template<typename T>
  7.  void insertionSort(T arr[], int n){
  8.      for( int i =  ; i < n ; i ++ ) {
  9.          T e = arr[i];
  10.          int j;
  11.          for (j = i; j >  && arr[j-] > e; j--)
  12.              arr[j] = arr[j-];
  13.          arr[j] = e;
  14.      }
  15.      return;
  16.  }
  17.  // 对arr[l...r]范围的数组进行插入排序
  18.  template<typename T>
  19.  void insertionSort(T arr[], int l, int r){
  20.      for( int i = l+ ; i <= r ; i ++ ) {
  21.          T e = arr[i];
  22.          int j;
  23.          for (j = i; j > l && arr[j-] > e; j--)
  24.              arr[j] = arr[j-];
  25.          arr[j] = e;
  26.      }
  27.      return;
  28.  }
  29.  #endif

4.单路快排实现：

  1.  #include <iostream>
  2.  #include <algorithm>
  3.  #include <ctime>
  4.  #include "SortTestHelper.h"
  5.  #include "MergeSort.h"
  6.  #include "InsertionSort.h"
  7.  using namespace std;
  8.  // 对arr[l...r]部分进行partition操作
  9.  // 返回p, 使得arr[l...p-1] < arr[p] ; arr[p+1...r] > arr[p]
  10.  template <typename T>
  11.  int _partition(T arr[], int l, int r){
  12.      // 随机在arr[l...r]的范围中, 选择一个数值作为标定点pivot
  13.      swap( arr[l] , arr[rand()%(r-l+)+l] );
  14.      T v = arr[l];
  15.      int j = l;
  16.      for( int i = l +  ; i <= r ; i ++ )
  17.          if( arr[i] < v ){
  18.              j ++;
  19.              swap( arr[j] , arr[i] );
  20.          }
  21.      swap( arr[l] , arr[j]);
  22.      return j;
  23.  }
  24.  // 对arr[l...r]部分进行快速排序
  25.  template <typename T>
  26.  void _quickSort(T arr[], int l, int r){
  27.      // 对于小规模数组, 使用插入排序进行优化
  28.      if( r - l <=  ){
  29.          insertionSort(arr,l,r);
  30.          return;
  31.      }
  32.      int p = _partition(arr, l, r);
  33.      _quickSort(arr, l, p- );
  34.      _quickSort(arr, p+, r);
  35.  }
  36.  template <typename T>
  37.  void quickSort(T arr[], int n){
  38.      srand(time(NULL));
  39.      _quickSort(arr, , n-);
  40.  }
  41.  // 比较Merge Sort和Quick Sort两种排序算法的性能效率
  42.  int main() {
  43.      int n = ;
  44.      // 测试1 一般性测试（随机数）
  45.      cout<<"Test for random array, size = "<<n<<", random range [0, "<<n<<"]"<<endl;
  46.      int* arr1 = SortTestHelper::generateRandomArray(n,,n);
  47.      int* arr2 = SortTestHelper::copyIntArray(arr1,n);
  48.      SortTestHelper::testSort("Merge Sort", mergeSort, arr1, n);
  49.      SortTestHelper::testSort("Quick Sort", quickSort, arr2, n);
  50.      delete[] arr1;
  51.      delete[] arr2;
  52.      cout<<endl;
  53.      // 测试2 测试近乎有序的数组
  54.      // 加入了随机选择标定点的步骤后, 我们的快速排序可以轻松处理近乎有序的数组
  55.      // 但是对于近乎有序的数组, 其效率比优化后的归并排序要低, 但完全再容忍范围里
  56.      int swapTimes = ;
  57.      cout<<"Test for nearly ordered array, size = "<<n<<", swap time = "<<swapTimes<<endl;
  58.      arr1 = SortTestHelper::generateNearlyOrderedArray(n,swapTimes);
  59.      arr2 = SortTestHelper::copyIntArray(arr1, n);
  60.      SortTestHelper::testSort("Merge Sort", mergeSort, arr1, n);
  61.      SortTestHelper::testSort("Quick Sort", quickSort, arr2, n);
  62.      delete[] arr1;
  63.      delete[] arr2;
  64.      cout<<endl;
  65.      // 测试3 测试存在包含大量相同元素的数组
  66.      // 但此时, 对于含有大量相同元素的数组, 我们的快速排序算法再次退化成了O(n^2)级别的算法
  67.      cout<<"Test for random array, size = "<<n<<", random range [0,10]"<<endl;
  68.      arr1 = SortTestHelper::generateRandomArray(n,,);
  69.      arr2 = SortTestHelper::copyIntArray(arr1, n);
  70.      SortTestHelper::testSort("Merge Sort", mergeSort, arr1, n);
  71.      SortTestHelper::testSort("Quick Sort", quickSort, arr2, n);
  72.      delete[] arr1;
  73.      delete[] arr2;
  74.      return ;
  75.  }

图解单路快排：

5.单路快排的测试结果：

可见单路快排在随机测试和近乎有序的情况下效率是完全可以接受的，但是在存在大量重复的元素中表现不是太好，下面我们进行一步一步的优化：
二，双路快排：
只需改一下主函数：

  1.  #include <iostream>
  2.  #include <algorithm>
  3.  #include <ctime>
  4.  #include "SortTestHelper.h"
  5.  #include "MergeSort.h"
  6.  #include "InsertionSort.h"
  7.  using namespace std;
  8.  // 对arr[l...r]部分进行partition操作
  9.  // 返回p, 使得arr[l...p-1] < arr[p] ; arr[p+1...r] > arr[p]
  10.  template <typename T>
  11.  int _partition(T arr[], int l, int r){
  12.      // 随机在arr[l...r]的范围中, 选择一个数值作为标定点pivot
  13.      swap( arr[l] , arr[rand()%(r-l+)+l] );
  14.      T v = arr[l];
  15.      int j = l;
  16.      for( int i = l +  ; i <= r ; i ++ )
  17.          if( arr[i] < v ){
  18.              j ++;
  19.              swap( arr[j] , arr[i] );
  20.          }
  21.      swap( arr[l] , arr[j]);
  22.      return j;
  23.  }
  24.  // 双路快速排序的partition
  25.  // 返回p, 使得arr[l...p-1] < arr[p] ; arr[p+1...r] > arr[p]
  26.  template <typename T>
  27.  int _partition2(T arr[], int l, int r){
  28.      // 随机在arr[l...r]的范围中, 选择一个数值作为标定点pivot
  29.      swap( arr[l] , arr[rand()%(r-l+)+l] );
  30.      T v = arr[l];
  31.      // arr[l+1...i) <= v; arr(j...r] >= v
  32.      int i = l+, j = r;
  33.      while( true ){
  34.          // 注意这里的边界, arr[i] < v, 不能是arr[i] <= v
  35.          while( i <= r && arr[i] < v )
  36.              i ++;
  37.          // 注意这里的边界, arr[j] > v, 不能是arr[j] >= v
  38.                while( j >= l+ && arr[j] > v )
  39.              j --;
  40.          if( i > j )
  41.              break;
  42.          swap( arr[i] , arr[j] );
  43.          i ++;
  44.          j --;
  45.      }
  46.      swap( arr[l] , arr[j]);
  47.      return j;
  48.  }
  49.  // 对arr[l...r]部分进行快速排序
  50.  template <typename T>
  51.  void _quickSort(T arr[], int l, int r){
  52.      // 对于小规模数组, 使用插入排序进行优化
  53.      if( r - l <=  ){
  54.          insertionSort(arr,l,r);
  55.          return;
  56.      }
  57.      // 调用双路快速排序的partition
  58.      int p = _partition2(arr, l, r);
  59.      _quickSort(arr, l, p- );
  60.      _quickSort(arr, p+, r);
  61.  }
  62.  template <typename T>
  63.  void quickSort(T arr[], int n){
  64.      srand(time(NULL));
  65.      _quickSort(arr, , n-);
  66.  }
  67.  // 比较Merge Sort和双路快速排序两种排序算法的性能效率
  68.  int main() {
  69.      int n = ;
  70.      // 测试1 一般性测试
  71.      cout<<"Test for random array, size = "<<n<<", random range [0, "<<n<<"]"<<endl;
  72.      int* arr1 = SortTestHelper::generateRandomArray(n,,n);
  73.      int* arr2 = SortTestHelper::copyIntArray(arr1,n);
  74.      SortTestHelper::testSort("Merge Sort", mergeSort, arr1, n);
  75.      SortTestHelper::testSort("Quick Sort", quickSort, arr2, n);
  76.      delete[] arr1;
  77.      delete[] arr2;
  78.      cout<<endl;
  79.      // 测试2 测试近乎有序的数组
  80.      // 双路快速排序算法也可以轻松处理近乎有序的数组
  81.      int swapTimes = ;
  82.      cout<<"Test for nearly ordered array, size = "<<n<<", swap time = "<<swapTimes<<endl;
  83.      arr1 = SortTestHelper::generateNearlyOrderedArray(n,swapTimes);
  84.      arr2 = SortTestHelper::copyIntArray(arr1, n);
  85.      SortTestHelper::testSort("Merge Sort", mergeSort, arr1, n);
  86.      SortTestHelper::testSort("Quick Sort", quickSort, arr2, n);
  87.      delete[] arr1;
  88.      delete[] arr2;
  89.      cout<<endl;
  90.      // 测试3 测试存在包含大量相同元素的数组
  91.      // 使用双快速排序后, 我们的快速排序算法可以轻松的处理包含大量元素的数组
  92.      cout<<"Test for random array, size = "<<n<<", random range [0,10]"<<endl;
  93.      arr1 = SortTestHelper::generateRandomArray(n,,);
  94.      arr2 = SortTestHelper::copyIntArray(arr1, n);
  95.      SortTestHelper::testSort("Merge Sort", mergeSort, arr1, n);
  96.      SortTestHelper::testSort("Quick Sort", quickSort, arr2, n);
  97.      delete[] arr1;
  98.      delete[] arr2;
  99.      return ;
  100.  }

图解双路快排：

 

双路快排测试结果：

可见优化后的双路快排在大量重复元素的数组测试中速度提升了近乎200倍，接下来让我们在来看看最棒的三路快排：
三，三路快排：
1.我们将刚才的双路快排写到一个头文件中以便等下测试：

#ifndef INC_07_QUICK_SORT_THREE_WAYS_QUICKSORT_H
#define INC_07_QUICK_SORT_THREE_WAYS_QUICKSORT_H
#include <iostream>
#include <ctime>
#include <algorithm>
#include "InsertionSort.h"
using namespace std;
// 对arr[l...r]部分进行partition操作
// 返回p, 使得arr[l...p-1] < arr[p] ; arr[p+1...r] > arr[p]
template <typename T>
int _partition(T arr[], int l, int r){
// 随机在arr[l...r]的范围中, 选择一个数值作为标定点pivot
swap( arr[l] , arr[rand()%(r-l+1)+l] );
T v = arr[l];
int j = l;
for( int i = l + 1 ; i <= r ; i ++ )
if( arr[i] < v ){
j ++;
swap( arr[j] , arr[i] );
}
swap( arr[l] , arr[j]);
return j;
}
// 双路快速排序的partition
// 返回p, 使得arr[l...p-1] < arr[p] ; arr[p+1...r] > arr[p]
template <typename T>
int _partition2(T arr[], int l, int r){
// 随机在arr[l...r]的范围中, 选择一个数值作为标定点pivot
swap( arr[l] , arr[rand()%(r-l+1)+l] );
T v = arr[l];
int i = l+1, j = r;
while( true ){
// 注意这里的边界, arr[i] < v, 不能是arr[i] <= v
while( i <= r && arr[i] < v )
i ++;
// 注意这里的边界, arr[j] > v, 不能是arr[j] >= v
while( j >= l+1 && arr[j] > v )
j --;
if( i > j )
break;
swap( arr[i] , arr[j] );
i ++;
j --;
}
swap( arr[l] , arr[j]);
return j;
}
// 对arr[l...r]部分进行快速排序
template <typename T>
void _quickSort(T arr[], int l, int r){
// 对于小规模数组, 使用插入排序进行优化
if( r - l <= 15 ){
insertionSort(arr,l,r);
return;
}
// 调用双路快速排序的partition
int p = _partition2(arr, l, r);
_quickSort(arr, l, p-1 );
_quickSort(arr, p+1, r);
}
template <typename T>
void quickSort(T arr[], int n){
srand(time(NULL));
_quickSort(arr, 0, n-1);
}
#endif

2.三路快排实现：

  1.  #include <iostream>
  2.  #include <algorithm>
  3.  #include <ctime>
  4.  #include "SortTestHelper.h"
  5.  #include "MergeSort.h"
  6.  #include "InsertionSort.h"
  7.  #include "QuickSort.h"
  8.  using namespace std;
  9.  // 递归的三路快速排序算法
  10.  template <typename T>
  11.  void __quickSort3Ways(T arr[], int l, int r){
  12.      // 对于小规模数组, 使用插入排序进行优化
  13.      if( r - l <=  ){
  14.          insertionSort(arr,l,r);
  15.          return;
  16.      }
  17.      // 随机在arr[l...r]的范围中, 选择一个数值作为标定点pivot
  18.      swap( arr[l], arr[rand()%(r-l+)+l ] );
  19.      T v = arr[l];
  20.      int lt = l;     // arr[l+1...lt] < v
  21.      int gt = r + ; // arr[gt...r] > v
  22.      int i = l+;    // arr[lt+1...i) == v
  23.      while( i < gt ){
  24.          if( arr[i] < v ){
  25.              swap( arr[i], arr[lt+]);
  26.              i ++;
  27.              lt ++;
  28.          }
  29.          else if( arr[i] > v ){
  30.              swap( arr[i], arr[gt-]);
  31.              gt --;
  32.          }
  33.          else{ // arr[i] == v
  34.              i ++;
  35.          }
  36.      }
  37.      swap( arr[l] , arr[lt] );
  38.      __quickSort3Ways(arr, l, lt-);
  39.      __quickSort3Ways(arr, gt, r);
  40.  }
  41.  template <typename T>
  42.  void quickSort3Ways(T arr[], int n){
  43.      srand(time(NULL));
  44.      __quickSort3Ways( arr, , n-);
  45.  }
  46.  int main() {
  47.      int n = ;
  48.      // 测试1 一般性测试
  49.      cout<<"一般随机测试："<<endl;
  50.      cout<<"Test for random array, size = "<<n<<", random range [0, "<<n<<"]"<<endl;
  51.      int* arr1 = SortTestHelper::generateRandomArray(n,,n);
  52.      int* arr2 = SortTestHelper::copyIntArray(arr1,n);
  53.      int* arr3 = SortTestHelper::copyIntArray(arr1,n);
  54.      SortTestHelper::testSort("Merge Sort", mergeSort, arr1, n);
  55.      SortTestHelper::testSort("Quick Sort", quickSort, arr2, n);
  56.      SortTestHelper::testSort("Quick Sort 3 Ways", quickSort3Ways, arr3, n);
  57.      delete[] arr1;
  58.      delete[] arr2;
  59.      delete[] arr3;
  60.      cout<<endl;
  61.      // 测试2 测试近乎有序的数组
  62.      cout<<"测试近乎有序的数组"<<endl;
  63.      int swapTimes = ;
  64.      cout<<"Test for nearly ordered array, size = "<<n<<", swap time = "<<swapTimes<<endl;
  65.      arr1 = SortTestHelper::generateNearlyOrderedArray(n,swapTimes);
  66.      arr2 = SortTestHelper::copyIntArray(arr1, n);
  67.      arr3 = SortTestHelper::copyIntArray(arr1, n);
  68.      SortTestHelper::testSort("Merge Sort", mergeSort, arr1, n);
  69.      SortTestHelper::testSort("Quick Sort", quickSort, arr2, n);
  70.      SortTestHelper::testSort("Quick Sort 3 Ways", quickSort3Ways, arr3, n);
  71.      delete[] arr1;
  72.      delete[] arr2;
  73.      delete[] arr3;
  74.      cout<<endl;
  75.      // 测试3 测试存在包含大量相同元素的数组
  76.      cout<<"测试存在包含大量相同元素的数组"<<endl;
  77.      cout<<"Test for random array, size = "<<n<<", random range [0,10]"<<endl;
  78.      arr1 = SortTestHelper::generateRandomArray(n,,);
  79.      arr2 = SortTestHelper::copyIntArray(arr1, n);
  80.      arr3 = SortTestHelper::copyIntArray(arr1, n);
  81.      SortTestHelper::testSort("Merge Sort", mergeSort, arr1, n);
  82.      SortTestHelper::testSort("Quick Sort", quickSort, arr2, n);
  83.      SortTestHelper::testSort("Quick Sort 3 Ways", quickSort3Ways, arr3, n);
  84.      delete[] arr1;
  85.      delete[] arr2;
  86.      delete[] arr3;
  87.      return ;
  88.  }

图解三路快排：

三路快排运行结果：

可见性能又进一步提升了：
比较Merge Sort和双路快速排序和三路快排三种排序算法的性能效率
对于包含有大量重复数据的数组, 三路快排有巨大的优势
对于一般性的随机数组和近乎有序的数组, 三路快排的效率虽然不是最优的, 但是在可以接受的范围里
因此, 在一些语言中, 三路快排是默认的语言库函数中使用的排序算法。比如Java:)

O(n*logn)级别的算法之二（快速排序）的三种实现方法详解及其与归并排序的对比的更多相关文章

  1. “全栈2019”Java多线程第十二章：后台线程setDaemon()方法详解

    难度 初级 学习时间 10分钟 适合人群 零基础 开发语言 Java 开发环境 JDK v11 IntelliJ IDEA v2018.3 文章原文链接 "全栈2019"Java多 ...

  2. （二）线程Thread中的方法详解

    1.start() start()方法的作用讲得直白点就是通知"线程规划器",此线程可以运行了,正在等待CPU调用线程对象得run()方法,产生一个异步执行的效果.通过start( ...

  3. Java构造和解析Json数据的两种方法详解二

    在www.json.org上公布了很多JAVA下的json构造和解析工具,其中org.json和json-lib比较简单,两者使用上差不多但还是有些区别.下面接着介绍用org.json构造和解析Jso ...

  4. 《Android群英传》读书笔记 (5) 第十一章 搭建云端服务器 + 第十二章 Android 5.X新特性详解 + 第十三章 Android实例提高

    第十一章 搭建云端服务器 该章主要介绍了移动后端服务的概念以及Bmob的使用,比较简单,所以略过不总结. 第十三章 Android实例提高 该章主要介绍了拼图游戏和2048的小项目实例,主要是代码,所 ...

  5. Android群英传笔记——第十二章：Android5.X 新特性详解，Material Design UI的新体验

    Android群英传笔记--第十二章:Android5.X 新特性详解,Material Design UI的新体验 第十一章为什么不写,因为我很早之前就已经写过了,有需要的可以去看 Android高 ...

  6. qml学习笔记(二)：可视化元素基类Item详解（上半场anchors等等）

    原博主博客地址:http://blog.csdn.net/qq21497936本文章博客地址:http://blog.csdn.net/qq21497936/article/details/78516 ...

  7. “全栈2019”Java第三十一章：二维数组和多维数组详解

    难度 初级 学习时间 10分钟 适合人群 零基础 开发语言 Java 开发环境 JDK v11 IntelliJ IDEA v2018.3 文章原文链接 "全栈2019"Java第 ...

  8. Java构造和解析Json数据的两种方法详解二——org.json

    转自:http://www.cnblogs.com/lanxuezaipiao/archive/2013/05/24/3096437.html 在www.json.org上公布了很多JAVA下的jso ...

  9. java多线程并发（二）--线程的生命周期及方法详解

    上篇随笔介绍了线程的相关基础知识以及新启线程的几种方法,本片将继续介绍线程的生命周期及方法详解. 一.线程的生命周期 在Thread代码中,线程的状态被分为6种 public enum State { ...

随机推荐

  1. CFUpdate高速模式下出现Error #2038提示的解决方案

    使用CFUpdate上传文件,在IE模式下是正常的,切换到高速模式下出现提示Error #2038错误,文件无法上传. 向作者了解到需要设置challs_flash_update函数中的a.url为绝 ...

  2. Samba部署共享服务

    在本地PC文件共享 Samba服务程序是一款基于SMB协议并由服务端和客户端组成的开源文件共享资源软件,实现了Windows和Linux系统间的文件共享 1.安装Samba服务程序    yum in ...

  3. VSCode调试Flutter的问题解决

    错误:Target of URI doesn't exist: package:fultter/material.dart 原因:flutter版本不匹配.flutter升级到了最新版本,而项目引用的 ...

  4. travis-ci 中运行 puppeteer

    通过 travis-ci 可以构建基于 puppeteer 的自动化任务,基于此构建的一个 计划任务 puppeteer中调用需要禁用沙箱环境 https://github.com/GoogleChr ...

  5. [Swift]LeetCode384. 打乱数组 | Shuffle an Array

    Shuffle a set of numbers without duplicates. Example: // Init an array with set 1, 2, and 3. int[] n ...

  6. [Swift]LeetCode678. 有效的括号字符串 | Valid Parenthesis String

    Given a string containing only three types of characters: '(', ')' and '*', write a function to chec ...

  7. [Swift]LeetCode844. 比较含退格的字符串 | Backspace String Compare

    Given two strings S and T, return if they are equal when both are typed into empty text editors. # m ...

  8. ALL_SOURCE

    类型:View Owner: SYS 内容: 记录了该用户可访问的所有数据库对象的脚本信息(DDL) 字段:  OWNER: 对象的Owner NAME: 对象名称 TYPE: 对象类型,如FUNCT ...

  9. Python必备库

    Python必备库 --default-timeout=100避免网络延迟错误:-U给管理员权限. Python基础库 pip --default-timeout=100 install -U pyg ...

  10. BBS论坛（十四）

    14.1注册完成跳到上一个页面 (1)front/form.py # front/forms.py __author__ = 'derek' from ..forms import BaseForm ...