java常用排序算法

一、冒泡排序

　　1、基本介绍

　　冒泡排序（Bubble Sorting）的基本思想是：通过对待排序序列从前向后（从下标较小的元素开始）,依次比较相邻元素的值，若发现逆序则交换，使值较大的元素逐渐从前移向后部，就象水底下的气泡一样逐渐向上冒。

因为排序的过程中，各元素不断接近自己的位置，如果一趟比较下来没有进行过交换，就说明序列有序，因此要在排序过程中设置
一个标志flag判断元素是否进行过交换。从而减少不必要的比较。(这里说的优化，可以在冒泡排序写好后，在进行)
　　例如：

　　

　　

　　

　　2、代码实现

　　

 1     //基础版
 2     public static void bubbleSort_v1(int[] arr) {
 3         int tmp=0;
 4         for (int i = 0; i < arr.length - 1; i++) {
 5             for (int j = 0; j < arr.length - 1 - i; j++) {
 6                 if (arr[j] > arr[j + 1]) {
 7                     tmp = arr[j];
 8                     arr[j] = arr[j + 1];
 9                     arr[j + 1] = tmp;
10                 }
11             }
12         }
13     }

　

 1  //加强版
 2     public static void bubbleSort_v2(int[] arr) {
 3         boolean flag = false;
 4         int tmp=0;
 5         for (int i = 0; i < arr.length - 1; i++) {
 6             for (int j = 0; j < arr.length - 1 - i; j++) {
 7                 if (arr[j] > arr[j + 1]) {
 8                     flag=true;
 9                     tmp = arr[j];
10                     arr[j] = arr[j + 1];
11                     arr[j + 1] = tmp;
12                 }
13             }
14             //如果没进入比较，则表示已经是有序数组，中断排序即可
15             if(!flag){
16                 break;
17             }else {
18                 flag=false;
19             }
20         }
21     }

 

 

二、快速排序

　　

　　1、基本介绍　

　　快速排序（Quicksort）是对冒泡排序的一种改进。基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列

　　

　　

　　2、代码实现

 

三、直接插入排序

　　　

　　1、基本介绍　

　　插入排序（Insertion Sorting）的基本思想是：把n个待排序的元素看成为一个有序表和一个无序表，开始时有序表中只包含一个元素，无序表中包含有n-1个元素，排序过程中每次从无序表中取出第一个元素，把它的排序码依次与有序表元素的排序码进行比较，将它插入到有序表中的适当位置，使之成为新的有序表

　　

　　

　　2、代码实现

　　　

 1  public  static void insertSort_v1(int[] arr){
 2         //从第二个元素开始，因为如果从第一个元素向前插入，第一个元素之前是没有数据的
 3         for (int i = 1; i < arr.length; i++) {
 4             //从第i个元素开始向前查找正确的插入位置
 5             //下标j>0并且当前元素值arr[j]小于arr[j-1]时，进入循环，即从小到大
 6             for (int j = i; j > 0 && arr[j] < arr[j - 1]; j--) {
 7                 if (arr[j] < arr[j - 1]) {
 8                     int tmp = arr[j];
 9                     arr[j] = arr[j - 1];
10                     arr[j - 1] = tmp;
11                 }
12             }
13 
14         }
15     }

 

　　

 1  public  static void insertSort_v2(int[] arr){
 2         for (int i = 1; i < arr.length; i++) {
 3             // 寻找元素arr[i]合适的插入位置
 4             int e = arr[i];
 5             int j = 0;
 6             // j保存元素e应该插入的位置，一次赋值，交换一次需要三次赋值
 7             for (j = i; j > 0 && arr[j - 1] > e; j--) {
 8                 //此时arr[j],arr[j-1]是同一个数
 9                 arr[j] = arr[j - 1];
10             }
11             //j是arr[i]应该插入的位置
12             arr[j] = e;
13         }
14     }

 

3.1、折半插入排序

　　

　　1、基本介绍　

　　2、代码实现

 

四、希尔排序

　　

　　1、基本介绍　

 

　　

　　

　　

　　2、演化

　　

 1  //演化
 2     private void evolution(){
 3         int[] arr = { 8, 9, 1, 7, 2, 3, 5, 4, 6, 0 };
 4         int temp = 0;
 5         // 希尔排序的第1轮排序
 6         // 因为第1轮排序，是将10个数据分成了 5组
 7         for (int i = 5; i < arr.length; i++) {
 8             // 遍历各组中所有的元素(共5组，每组有2个元素), 步长5
 9             for (int j = i - 5; j >= 0; j -= 5) {
10                 // 如果当前元素大于加上步长后的那个元素，说明交换
11                 if (arr[j] > arr[j + 5]) {
12                     temp = arr[j];
13                     arr[j] = arr[j + 5];
14                     arr[j + 5] = temp;
15                 }
16             }
17         }
18 
19         System.out.println("希尔排序1轮后=" + Arrays.toString(arr));//
20 
21 
22         // 希尔排序的第2轮排序
23         // 因为第2轮排序，是将10个数据分成了 5/2 = 2组
24         for (int i = 2; i < arr.length; i++) {
25             // 遍历各组中所有的元素(共5组，每组有2个元素), 步长5
26             for (int j = i - 2; j >= 0; j -= 2) {
27                 // 如果当前元素大于加上步长后的那个元素，说明交换
28                 if (arr[j] > arr[j + 2]) {
29                     temp = arr[j];
30                     arr[j] = arr[j + 2];
31                     arr[j + 2] = temp;
32                 }
33             }
34         }
35 
36         System.out.println("希尔排序2轮后=" + Arrays.toString(arr));//
37 
38         // 希尔排序的第3轮排序
39         // 因为第3轮排序，是将10个数据分成了 2/2 = 1组
40         for (int i = 1; i < arr.length; i++) {
41             // 遍历各组中所有的元素(共5组，每组有2个元素), 步长5
42             for (int j = i - 1; j >= 0; j -= 1) {
43                 // 如果当前元素大于加上步长后的那个元素，说明交换
44                 if (arr[j] > arr[j + 1]) {
45                     temp = arr[j];
46                     arr[j] = arr[j + 1];
47                     arr[j + 1] = temp;
48                 }
49             }
50         }
51 
52         System.out.println("希尔排序3轮后=" + Arrays.toString(arr));//
53     }

 

　　3、代码实现

　　

 1  // 希尔排序时， 对有序序列在插入时采用->交换法
 2     public static void sellSort_v1(int [] arr){
 3         int tmp = 0;
 4         for (int gap =arr.length/2 ; gap >0 ; gap/=2) {
 5             for (int i = gap; i <arr.length ; i++) {
 6                 // 遍历各组中所有的元素(共gap组，每组有个元素), 步长gap
 7                 for (int j = i-gap; j >=0; j-=gap) {
 8                     // 如果当前元素大于加上步长后的那个元素，说明交换
 9                     if(arr[j]<arr[j+gap]){
10                         tmp= arr[j];
11                         arr[j]=arr[j+gap];
12                         arr[j+gap]=tmp;
13                     }
14                 }
15             }
16         }
17     }

 

 　　

 1  //对交换式的希尔排序进行优化->移位法
 2     public static void sellSort_v2(int [] arr){
 3         for (int gap =arr.length/2 ; gap >0 ; gap/=2) {
 4             // 从第gap个元素，逐个对其所在的组进行直接插入排序
 5             for (int i = gap; i < arr.length; i++) {
 6                 int j = i;
 7                 int tmp = arr[j];
 8                 if(arr[j]<arr[j-gap]){
 9                     while (j - gap >= 0 && tmp < arr[j - gap]) {
10                         //移动
11                         arr[j] = arr[j-gap];
12                         j -= gap;
13                     }
14                     //当退出for后，就给temp找到插入的位置
15                     arr[j]=tmp;
16                 }
17             }
18         }
19     }

 

五、直接选择排序

　　1、基本介绍

　　选择排序（select sorting）也是一种简单的排序方法。它的基本思想是：第一次从arr[0]~arr[n-1]中选取最小值，与arr[0]交换，第二次从arr[1]~arr[n-1]中选取最小值，与arr[1]交换，第三次从arr[2]~arr[n-1]中选取最小值，与arr[2]交换，…，第i次从arr[i-1]~arr[n-1]中选取最小值，与arr[i-1]交换，…, 第n-1次从arr[n-2]~arr[n-1]中选取最小值，与arr[n-2]交换，总共通过n-1次，得到一个按排序码从小到大排列的有序序列。

　　

　　

　　2、代码实现

　　

 1  //O(n2)
 2     public static void selectSort(int[] arr){
 3         for (int i = 0; i < arr.length-1; i++) {
 4             //假定最小值为i
 5             int minIndex = i;
 6             //j从i+1开始
 7             for (int j = i+1; j <arr.length ; j++) {
 8                 //如果假定的最小值大于后面一个元素即arr[j],则吧minIndex指向arr[j]
 9                 //否则不进入if判断
10                 if(arr[minIndex]>arr[j]){
11                     minIndex = j;
12                 }
13             }
14             //如果minIndex没有变化，即，minIndex就是arr[i]，不需交换
15             if(minIndex!=i) {
16                 int tmp = arr[i];
17                 arr[i] = arr[minIndex];
18                 arr[minIndex] = tmp;
19             }
20         }
21     }

 

 

六、堆排序

　　

　　1、基本介绍　

　　

　　

　　2、代码实现

 

七、归并排序

　　1、基本介绍　

　　

　　

　　2、代码实现

 

八、基数排序

　　1、基本介绍　

　　　　

　　　　

　　2、代码实现

九、桶排序

　　1、基本介绍　

　　

　　2、代码实现

十、基数排序

　　1、基本介绍

　　

　　2、代码实现