七种排序算法

 

方法	时间复杂度	空间复杂度	Stable
冒泡排序（Bubble Sort）	O(n) — O(n^2)	O(1)	yes
选择排序（Selection Sort）	O(n^2) — O(n^2)	O(1)	no
插入排序（Insertion Sort）	O(n) — O(n^2)	O(1)	yes
希尔排序（Shell Sort）	O(n) — O(n log^2 n)	O(1)	no
快速排序（Quick Sort）	O(n log n) — O(n log n) — O(n^2)	O(log n) — O(n)	no, but the stable exist
归并排序（Merge Sort）	O(n log n)	O(n)	yes
堆排序（Heap Sort）	O(n log n)	1	no

 

// 1. 冒泡排序

public void bubbleSort(int[] A) {
     for(int i=A.length; i>0; i--) {
          boolean flag = true;
          for(int j=1; j<i; j++) {
               if(A[j]<A[j-1]) {
                    int tmp = A[j-1];
                    A[j-1] = A[j];
                    A[j] = tmp;
                    flag = false;
               }
          }
          if(flag) {
               break;
          }
     }
}

 

// 2. 选择排序

public void selectionSort(int[] A) {
     for(int i=A.length; i>1; i--) {
          int maxIdx = 0;
          for(int j=1; j<i; j++) {
               if(A[j]>A[maxIdx]) {
                    maxIdx = j;
               }
          }
          if(maxIdx!=i-1) {
               int tmp = A[maxIdx];
               A[maxIdx] = A[i-1];
               A[i-1] = tmp;
          }
     }
}

// 3. 插入排序

public void insertionSort(int[] A) {
     for(int i=1; i<A.length; i++) {
          int tmp = A[i];
          int j = i-1;
          while(j>=0) {
               if(A[j]>=A[i])
                    j--;
               else break;
          }
          int tmp = A[i];
          j++;
          for(int k=i; k>j; k--) {
               A[k] = A[k-1];
          }
          A[j] = tmp;
     }
}

 

// 4. 希尔排序  —  插入排序的一种更高效的改进版本

public void shellSort(int[] A) {
     int step = A.length;
     while(step>1) {
          step = step>>1;
          for(int i=0; i<A.length; i++) {
               int pos = i+step;
               int tmp = A[pos];
               while((pos-step>=0) && tmp<A[pos-step]) {
                    A[pos] = A[pos-step];
                    pos -= step;
               }
               A[pos] = tmp;
          }
     }    
}

 

// 5. 快速排序

public void quickSort(int[] A, int start, int end) {
     if (start >= end) return;
     int i = start;
     int j = end;
     int tmp = A[i];
     while(i<j) {
          while(i<j && A[j]>=tmp)
               j--;
          A[i] = A[j];
          while(i<j && A[i]<tmp)
               i++;
          A[j] = A[i];
      }
      A[i] = tmp;
      quickSort(A, start, i-1);
      quickSort(A, i+1, end);
}

// 6. 归并排序

public void mergeSort(int A[], int start, int end) {
      if(start<end) {
           int dis=(end-start)/2;
            mergeSort(A,start,start+dis);
            mergeSort(A,start+dis+1,end);
           merge(A,start,start+dis,start+dis+1,end);
      }
}
public void merge(int[] A,int start1,int end1,int start2,int end2) {
     int[] temp=new int[end1-start1+end2-start2+2];
     int k=0;
     int i1=start1;
     int i2=start2;
     while(i1<=end1&&i2<=end2) {
          if(A[i1]<A[i2])
               temp[k++]=A[i1++];
          else
               temp[k++]=A[i2++];
     }
     while(i1<=end1)
          temp[k++]=A[i1++];
     while(i2<=end2)
          temp[k++]=A[i2++];
     for(int i=start1,mark=0;mark<k;i++)
          A[i]=temp[mark++];
}

 

// 7. 堆排序  —  选择排序的一种更高效的改进版本

/* 父节点i的左子节点在位置 (2*i+1);
 * 父节点i的右子节点在位置 (2*i+2);
 * 子节点i的父节点在位置 floor((i-1)/2);
 */
public void heapSort(int[] A) {
     for(int i=A.length/2;i>=0;i--) {
          heapAdjust(A,i,A.length);
     } // O(n)
 
     for(int i=A.length-1;i>0;i--) {
          swap(A[0],A[i]);
          heapAdjust(A,0,i);
     } // O(nlgn)
}
 
public void heapAdjust(int[] A,int i,int length) { // siftDown
     while(2*i+1<length) {
          int left=2*i+1;
          if((left+1)<length && A[left]<A[left+1])
               left++;
          if(A[i]<A[left]) {
               swap(A[i],A[left]);
               i=left;
          } else
               break;
     }
}