常见排序算法（java）

1.冒泡排序(BubbleSort):

冒泡排序算法的流程如下： 
  （1）比较相邻的元素。 
  （2）对每一对相邻元素作同样的行为，从开始第一对到结尾的最后一对。 
  （3）针对所有的元素重复以上的步骤，每一趟排好一个数。

复杂度：O(n^2)

代码实现：

1. public class Code_00_BubbleSort {
2.       public static void bubbleSort(int[] arr) {
3.              if(arr == null || arr.length<2) {
4.                    return;
5.         }
6.       for(int e = arr.length-1;e>0;e--) {
7.               for(int i = 0;i<e;i++){
8.                    if(arr[i]>arr[i+1])
9.                    swap(arr,i,i+1);
10.             }
11.         }
12.     }
13.     public static void swap(int[] arr, int i, int j) {
14.            int temp = arr[i];
15.            arr[i] = arr[j];
16.            arr[j] = temp;
17. }

2.选择排序(SelectionSort):

(1)算法思想: 每次取一个最小值。

(2)复杂度:O(n^2)。

代码实现：

1. public class Code_02_SelectionSort {
2.     public static void selectionSort(int[] arr) {
3.         if (arr == null || arr.length < 2) {
4.             return;
5.         }
6.         for(int i = 0;i<arr.length-1;i++) {
7.             int midIndex = i;
8.             for(int j =i+1;j<arr.length;j++) {
9.                 midIndex = arr[j] < arr[midIndex] ? j : midIndex;
10.             }
11.             swap(arr,i,midIndex);
12.         }
13.     }
14.     public static void swap(int[] arr, int i, int j) {
15.         int tmp = arr[i];
16.         arr[i] = arr[j];
17.         arr[j] = tmp; 

}

3.插入排序（InsertionSort）：

代码实现：

1. ​​​​​​​Code_01_InsertionSort {
2.    public static void inserttionSort(int[] arr) {
3.         if(arr == null || arr.length<2 ) {
4.              return ;
5.       }
6.       for(int i = 1;i<arr.length;i++) {
7.            for(int j = i-1;j>=0 && arr[j]>arr[j+1];j--) {
8.               swap(arr,j,j+1);
9.           }
10.       }
11.  }
12.  public static void swap(int[] arr,int i,int j) {
13.      int temp = arr[i];
14.      arr[i] = arr[j];
15.      arr[j] = temp;
16.  }

复杂度：

1.最佳情况：T(n) = O(n) ;
2.最坏情况：T(n) = O(n^2);
3.平均情况：T(n) = O(n^2);

4.归并排序（MergeSort）：

  归并排序:

  思想：运用分治法思想解决排序问题。
（1）设定两个指针，分别指向待排序列的最初位置和末尾位置。
（2）比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一个位置。 
（3）重复步骤(3)直到某一指针达到尾部。 
（4）将另一序列剩下的所有元素直接复制到尾部。

代码如下：

1. public class Code_03_MergeSort {
2.     public static void mergeSort(int[] arr) {
3.         if(arr == null || arr.length<2) {
4.             return;
5.         }
6.         mergeSort(arr,0,arr.length-1);
7.     }
8.     public static void mergeSort(int[] arr, int l, int r) {
9.         if (l == r) {
10.             return;
11.         }
12.         int mid = l + ((r - l) >> 1);
13.         mergeSort(arr,l,mid);
14.         mergeSort(arr,mid+1,r);
15.         merge(arr,l,mid,r);
16.         //T(N) =2(N/2)+O(N) 
17.     }
18.     public static void merge(int[] arr, int l, int m, int r) {
19.         int[] help = new int[r-l+1];
20.         int i = 0;
21.         int p1 = l;
22.         int p2 = m+1;
23.         while (p1<=m && p2<=r ) {
24.             help[i++] = arr[p1] < arr[p2] ? arr[p1++] : arr[p2++];
25.         }
26.         while (p1 <= m) {
27.             help[i++] = arr[p1++];
28.         }
29.         while (p2 <= r) {
30.             help[i++] = arr[p2++];
31.         }
32.         for (i = 0; i < help.length; i++) {
33.             arr[l+i] = help[i];
34.         }
35. }

复杂度: O(nlgn) 

6 快速排序（QuickSort）：

快速排序：

算法思想：分治法+递归

算法步骤描述： 
（1）从数列中挑出一个元素，称为 “基准” 
（2）重新排序数列，所有元素比基准值小的摆放在基准左边，所有元素比基准值大的摆在基准的右边（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作。 
（3）递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。

代码实现：

1. public class Code_05_QuickSort {
2.    public static void quickSort(int [] arr) {
3.        if(arr == null || arr.length<2) {
4.            return;
5.      }
6.      quickSort(arr,0,arr.length-1);
7.  }
8.  public static void quickSort(int [] arr,int l,int r) {
9.      if(l<r) {
10.          int[] p = partition(arr,l,r);
11.          quickSort(arr, l, p[0] - 1);
12.          quickSort(arr, p[1] + 1, r);
13.      }
14.  }
15. private static int[] partition(int[] arr, int l, int r) {
16.     int less = l-1;
17.     int more = r;
18.     while(l<more) {
19.         if(arr[l]<arr[r]) {
20.             swap(arr,++less,l++);
21.         }else if(arr[l]>arr[r]) {
22.             swap(arr,--more,l);
23.         }else {
24.             l++;
25.         }
26.     }
27.     swap(arr,more,r);
28.     return new int[] {less+1,more};
29. }
30. private static void swap(int[] arr, int i, int j) {
31.     int temp = arr[i];
32.     arr[i] = arr[j];
33.     arr[j] = temp;
34. }

复杂度：

最坏运行时间：O(n^2) 
最佳运行时间：O(nlgn)

堆排：

堆排序：

步骤： 
堆排序利用了大根堆，堆顶记录的关键字最大这一特征，使得在当前无序区中选取最大关键字的记录变得简单。

代码实现：

 

1. public class Code_07_HeapSort {
2.     public static void heapSort(int[] arr) {
3.         if (arr == null || arr.length < 2) {
4.             return;
5.         }
6.         for (int i = 0; i < arr.length; i++) {
7.             heapInsert(arr, i);
8.         }
9.         int size = arr.length;
10.         swap(arr, 0, --size);
11.         while (size > 0) {
12.             heapify(arr, 0, size);
13.             swap(arr, 0, --size);
14.         }
15.     }
16.     public static void heapInsert(int[] arr, int index) {
17.         while (arr[index] > arr[(index - 1) / 2]) {
18.             swap(arr, index, (index - 1) / 2);
19.             index = (index - 1) / 2;
20.         }
21.     }
22.     public static void heapify(int[] arr, int index, int size) {
23.         int left = index * 2 + 1;
24.         while (left < size) {
25.             int largest = left + 1 < size && arr[left + 1] > arr[left] ? left + 1 : left;
26.             largest = arr[largest] > arr[index] ? largest : index;
27.             if (largest == index) {
28.                 break;
29.             }
30.             swap(arr, largest, index);
31.             index = largest;
32.             left = index * 2 + 1;
33.         }
34.     }
35.     public static void swap(int[] arr, int i, int j) {
36.         int tmp = arr[i];
37.         arr[i] = arr[j];
38.         arr[j] = tmp;
39.     }

​​​​​​​复杂度：

O(nlgn) 

说明:用小根堆排序与利用大根堆类似，只不过其排序结果是递减有序的。

复杂度估算公式(master)：

T(N) = aT(n/b)+O(n^d)

①当d<logb a时，时间复杂度为O(n^(logb a))
②当d=logb a时，时间复杂度为O((n^d)*logn)
③当d>logb a时，时间复杂度为O(n^d)