开发者社区> angel_kitty> 正文

【Java学习笔记之十一】Java中常用的8大排序算法详解总结

简介: 分类: 1)插入排序(直接插入排序、希尔排序) 2)交换排序(冒泡排序、快速排序) 3)选择排序(直接选择排序、堆排序) 4)归并排序 5)分配排序(基数排序) 所需辅助空间最多:归并排序 所需辅助空间最少:堆排序 平均速度最快:快速排序 不稳定:快速排序,希尔排序,堆排序。
+关注继续查看

分类:

1)插入排序(直接插入排序、希尔排序)
2)交换排序(冒泡排序、快速排序)
3)选择排序(直接选择排序、堆排序)
4)归并排序
5)分配排序(基数排序)
所需辅助空间最多:归并排序
所需辅助空间最少:堆排序
平均速度最快:快速排序

不稳定:快速排序,希尔排序,堆排序。

 

// 排序原始数据
private static final int[] NUMBERS =
{49, 38, 65, 97, 76, 13, 27, 78, 34, 12, 64, 5, 4, 62, 99, 98, 54, 56, 17, 18, 23, 34, 15, 35, 25, 53, 51};

1. 直接插入排序

基本思想:在要排序的一组数中,假设前面(n-1)[n>=2] 个数已经是排

好顺序的,现在要把第n个数插到前面的有序数中,使得这n个数

也是排好顺序的。如此反复循环,直到全部排好顺序。



 1 public static void insertSort(int[] array) {
 2      for (int i = 1; i < array.length; i++) {
 3          int temp = array[i];
 4          int j = i - 1;
 5          for (; j >= 0 && array[j] > temp; j--) {
 6              //将大于temp的值整体后移一个单位
 7              array[j + 1] = array[j];
 8          }
 9          array[j + 1] = temp;
10      }
11      System.out.println(Arrays.toString(array) + " insertSort");
12  }

2希尔排序

希尔排序,也称递减增量排序算法,是插入排序的一种更高效的改进版本。希尔排序是非稳定排序算法。
希尔排序是基于插入排序的以下两点性质而提出改进方法的:
插入排序在对几乎已经排好序的数据操作时,效率高,即可以达到线性排序的效率;
但插入排序一般来说是低效的,因为插入排序每次只能将数据移动一位。
先取一个正整数d1 < n, 把所有相隔d1的记录放一组,每个组内进行直接插入排序;然后d2 < d1,重复上述分组和排序操作;直至di = 1,即所有记录放进一个组中排序为止。




 1 public static void shellSort(int[] array) {
 2     int i;
 3     int j;
 4     int temp;
 5     int gap = 1;
 6     int len = array.length;
 7     while (gap < len / 3) { gap = gap * 3 + 1; }
 8     for (; gap > 0; gap /= 3) {
 9         for (i = gap; i < len; i++) {
10             temp = array[i];
11             for (j = i - gap; j >= 0 && array[j] > temp; j -= gap) {
12                 array[j + gap] = array[j];
13             }
14             array[j + gap] = temp;
15         }
16     }
17     System.out.println(Arrays.toString(array) + " shellSort");
18 }

3简单选择排序

基本思想:在要排序的一组数中,选出最小的一个数与第一个位置的数交换;

然后在剩下的数当中再找最小的与第二个位置的数交换,如此循环到倒数第二个数和最后一个数比较为止。



 1 public static void selectSort(int[] array) {
 2     int position = 0;
 3     for (int i = 0; i < array.length; i++) {
 4         int j = i + 1;
 5         position = i;
 6         int temp = array[i];
 7         for (; j < array.length; j++) {
 8             if (array[j] < temp) {
 9                 temp = array[j];
10                 position = j;
11             }
12         }
13         array[position] = array[i];
14         array[i] = temp;
15     }
16     System.out.println(Arrays.toString(array) + " selectSort");
17 }

4堆排序

基本思想:堆排序是一种树形选择排序,是对直接选择排序的有效改进。

堆的定义如下:具有n个元素的序列(h1,h2,...,hn),当且仅当满足(hi>=h2i,hi>=2i+1)或(hi<=h2i,hi<=2i+1)(i=1,2,...,n/2)时称之为堆。在这里只讨论满足前者条件的堆。由堆的定义可以看出,堆顶元素(即第一个元素)必为最大项(大顶堆)。完全二叉树可以很直观地表示堆的结构。堆顶为根,其它为左子树、右子树。初始时把要排序的数的序列看作是一棵顺序存储的二叉树,调整它们的存储序,使之成为一个堆,这时堆的根节点的数最大。然后将根节点与堆的最后一个节点交换。然后对前面(n-1)个数重新调整使之成为堆。依此类推,直到只有两个节点的堆,并对它们作交换,最后得到有n个节点的有序序列。从算法描述来看,堆排序需要两个过程,一是建立堆,二是堆顶与堆的最后一个元素交换位置。所以堆排序有两个函数组成。一是建堆的渗透函数,二是反复调用渗透函数实现排序的函数。


建堆:


交换,从堆中踢出最大数


剩余结点再建堆,再交换踢出最大数


依次类推:最后堆中剩余的最后两个结点交换,踢出一个,排序完成。

 1 public static void heapSort(int[] array) {
 2     /*
 3      *  第一步:将数组堆化
 4      *  beginIndex = 第一个非叶子节点。
 5      *  从第一个非叶子节点开始即可。无需从最后一个叶子节点开始。
 6      *  叶子节点可以看作已符合堆要求的节点,根节点就是它自己且自己以下值为最大。
 7      */
 8     int len = array.length - 1;
 9     int beginIndex = (len - 1) >> 1;
10     for (int i = beginIndex; i >= 0; i--) {
11         maxHeapify(i, len, array);
12     }
13     /*
14      * 第二步:对堆化数据排序
15      * 每次都是移出最顶层的根节点A[0],与最尾部节点位置调换,同时遍历长度 - 1。
16      * 然后从新整理被换到根节点的末尾元素,使其符合堆的特性。
17      * 直至未排序的堆长度为 0。
18      */
19     for (int i = len; i > 0; i--) {
20         swap(0, i, array);
21         maxHeapify(0, i - 1, array);
22     }
23     System.out.println(Arrays.toString(array) + " heapSort");
24 }
25 private static void swap(int i, int j, int[] arr) {
26     int temp = arr[i];
27     arr[i] = arr[j];
28     arr[j] = temp;
29 }
30 /**
31  * 调整索引为 index 处的数据,使其符合堆的特性。
32  *
33  * @param index 需要堆化处理的数据的索引
34  * @param len   未排序的堆(数组)的长度
35  */
36 private static void maxHeapify(int index, int len, int[] arr) {
37     int li = (index << 1) + 1; // 左子节点索引
38     int ri = li + 1;           // 右子节点索引
39     int cMax = li;             // 子节点值最大索引,默认左子节点。
40     if (li > len) {
41         return;       // 左子节点索引超出计算范围,直接返回。
42     }
43     if (ri <= len && arr[ri] > arr[li]) // 先判断左右子节点,哪个较大。
44     { cMax = ri; }
45     if (arr[cMax] > arr[index]) {
46         swap(cMax, index, arr);      // 如果父节点被子节点调换,
47         maxHeapify(cMax, len, arr);  // 则需要继续判断换下后的父节点是否符合堆的特性。
48     }
49 }

5冒泡排序

基本思想:在要排序的一组数中,对当前还未排好序的范围内的全部数,自上而下对相邻的两个数依次进行比较和调整,让较大的数往下沉,较小的往上冒。即:每当两相邻的数比较后发现它们的排序与排序要求相反时,就将它们互换。


 1 public static void bubbleSort(int[] array) {
 2     int temp = 0;
 3     for (int i = 0; i < array.length - 1; i++) {
 4         for (int j = 0; j < array.length - 1 - i; j++) {
 5             if (array[j] > array[j + 1]) {
 6                 temp = array[j];
 7                 array[j] = array[j + 1];
 8                 array[j + 1] = temp;
 9             }
10         }
11     }
12     System.out.println(Arrays.toString(array) + " bubbleSort");
13 }

6. 快速排序

基本思想:选择一个基准元素,通常选择第一个元素或者最后一个元素,通过一趟扫描,将待排序列分成两部分,一部分比基准元素小,一部分大于等于基准元素,此时基准元素在其排好序后的正确位置,然后再用同样的方法递归地排序划分的两部分。


 1 public static void quickSort(int[] array) {
 2     _quickSort(array, 0, array.length - 1);
 3     System.out.println(Arrays.toString(array) + " quickSort");
 4 }
 5 
 6 
 7 private static int getMiddle(int[] list, int low, int high) {
 8     int tmp = list[low];    //数组的第一个作为中轴
 9     while (low < high) {
10         while (low < high && list[high] >= tmp) {
11             high--;
12         }
13 
14 
15         list[low] = list[high];   //比中轴小的记录移到低端
16         while (low < high && list[low] <= tmp) {
17             low++;
18         }
19 
20 
21         list[high] = list[low];   //比中轴大的记录移到高端
22     }
23     list[low] = tmp;              //中轴记录到尾
24     return low;                  //返回中轴的位置
25 }
26 
27 
28 private static void _quickSort(int[] list, int low, int high) {
29     if (low < high) {
30         int middle = getMiddle(list, low, high);  //将list数组进行一分为二
31         _quickSort(list, low, middle - 1);      //对低字表进行递归排序
32         _quickSort(list, middle + 1, high);      //对高字表进行递归排序
33     }
34 }

7、归并排序

基本排序:归并(Merge)排序法是将两个(或两个以上)有序表合并成一个新的有序表,即把待排序序列分为若干个子序列,每个子序列是有序的。然后再把有序子序列合并为整体有序序列。


 1 public static void mergingSort(int[] array) {
 2     sort(array, 0, array.length - 1);
 3     System.out.println(Arrays.toString(array) + " mergingSort");
 4 }
 5 
 6 private static void sort(int[] data, int left, int right) {
 7     if (left < right) {
 8         //找出中间索引
 9         int center = (left + right) / 2;
10         //对左边数组进行递归
11         sort(data, left, center);
12         //对右边数组进行递归
13         sort(data, center + 1, right);
14         //合并
15         merge(data, left, center, right);
16     }
17 }
18 
19 private static void merge(int[] data, int left, int center, int right) {
20     int[] tmpArr = new int[data.length];
21     int mid = center + 1;
22     //third记录中间数组的索引
23     int third = left;
24     int tmp = left;
25     while (left <= center && mid <= right) {
26         //从两个数组中取出最小的放入中间数组
27         if (data[left] <= data[mid]) {
28             tmpArr[third++] = data[left++];
29         } else {
30             tmpArr[third++] = data[mid++];
31         }
32     }
33 
34     //剩余部分依次放入中间数组
35     while (mid <= right) {
36         tmpArr[third++] = data[mid++];
37     }
38 
39     while (left <= center) {
40         tmpArr[third++] = data[left++];
41     }
42 
43     //将中间数组中的内容复制回原数组
44     while (tmp <= right) {
45         data[tmp] = tmpArr[tmp++];
46     }
47 }

 

8、基数排序

 

基本思想:将所有待比较数值(正整数)统一为同样的数位长度,数位较短的数前面补零。然后,从最低位开始,依次进行一次排序。这样从最低位排序一直到最高位排序完成以后,数列就变成一个有序序列。


 1 public static void radixSort(int[] array) {
 2     //首先确定排序的趟数;
 3     int max = array[0];
 4     for (int i = 1; i < array.length; i++) {
 5         if (array[i] > max) {
 6             max = array[i];
 7         }
 8     }
 9     int time = 0;
10     //判断位数;
11     while (max > 0) {
12         max /= 10;
13         time++;
14     }
15 
16 
17     //建立10个队列;
18     ArrayList<ArrayList<Integer>> queue = new ArrayList<>();
19     for (int i = 0; i < 10; i++) {
20         ArrayList<Integer> queue1 = new ArrayList<>();
21         queue.add(queue1);
22     }
23 
24 
25     //进行time次分配和收集;
26     for (int i = 0; i < time; i++) {
27         //分配数组元素;
28         for (int anArray : array) {
29             //得到数字的第time+1位数;
30             int x = anArray % (int)Math.pow(10, i + 1) / (int)Math.pow(10, i);
31             ArrayList<Integer> queue2 = queue.get(x);
32             queue2.add(anArray);
33             queue.set(x, queue2);
34         }
35         int count = 0;//元素计数器;
36         //收集队列元素;
37         for (int k = 0; k < 10; k++) {
38             while (queue.get(k).size() > 0) {
39                 ArrayList<Integer> queue3 = queue.get(k);
40                 array[count] = queue3.get(0);
41                 queue3.remove(0);
42                 count++;
43             }
44         }
45     }
46     System.out.println(Arrays.toString(array) + " radixSort");
47 }

结果


附上以上所有排序整理结果:

 

  1 package com.test.sort;
  2 
  3 import java.util.ArrayList;
  4 import java.util.Arrays;
  5 
  6 @SuppressWarnings("WeakerAccess")
  7 public final class SortDemo {
  8 
  9     // 排序原始数据
 10     private static final int[] NUMBERS =
 11             {49, 38, 65, 97, 76, 13, 27, 78, 34, 12, 64, 5, 4, 62, 99, 98, 54, 56, 17, 18, 23, 34, 15, 35, 25, 53, 51};
 12 
 13 
 14     public static void main(String[] args) {
 15         insertSort(NUMBERS);
 16         shellSort(NUMBERS);
 17         selectSort(NUMBERS);
 18         bubbleSort(NUMBERS);
 19         heapSort(NUMBERS);
 20         quickSort(NUMBERS);
 21         mergingSort(NUMBERS);
 22         radixSort(NUMBERS);
 23     }
 24 
 25 
 26     public static void insertSort(int[] array) {
 27         for (int i = 1; i < array.length; i++) {
 28             int temp = array[i];
 29             int j = i - 1;
 30             for (; j >= 0 && array[j] > temp; j--) {
 31                 //将大于temp的值整体后移一个单位
 32                 array[j + 1] = array[j];
 33             }
 34             array[j + 1] = temp;
 35         }
 36         System.out.println(Arrays.toString(array) + " insertSort");
 37     }
 38 
 39 
 40     public static void shellSort(int[] array) {
 41         int i;
 42         int j;
 43         int temp;
 44         int gap = 1;
 45         int len = array.length;
 46         while (gap < len / 3) {
 47             gap = gap * 3 + 1;
 48         }
 49         for (; gap > 0; gap /= 3) {
 50             for (i = gap; i < len; i++) {
 51                 temp = array[i];
 52                 for (j = i - gap; j >= 0 && array[j] > temp; j -= gap) {
 53                     array[j + gap] = array[j];
 54                 }
 55                 array[j + gap] = temp;
 56             }
 57         }
 58         System.out.println(Arrays.toString(array) + " shellSort");
 59     }
 60 
 61     public static void selectSort(int[] array) {
 62         int position = 0;
 63         for (int i = 0; i < array.length; i++) {
 64             int j = i + 1;
 65             position = i;
 66             int temp = array[i];
 67             for (; j < array.length; j++) {
 68                 if (array[j] < temp) {
 69                     temp = array[j];
 70                     position = j;
 71                 }
 72             }
 73             array[position] = array[i];
 74             array[i] = temp;
 75         }
 76         System.out.println(Arrays.toString(array) + " selectSort");
 77     }
 78 
 79 
 80     public static void bubbleSort(int[] array) {
 81         int temp = 0;
 82         for (int i = 0; i < array.length - 1; i++) {
 83             for (int j = 0; j < array.length - 1 - i; j++) {
 84                 if (array[j] > array[j + 1]) {
 85                     temp = array[j];
 86                     array[j] = array[j + 1];
 87                     array[j + 1] = temp;
 88                 }
 89             }
 90         }
 91         System.out.println(Arrays.toString(array) + " bubbleSort");
 92     }
 93 
 94 
 95     public static void heapSort(int[] array) {
 96         /*
 97          *  第一步:将数组堆化
 98          *  beginIndex = 第一个非叶子节点。
 99          *  从第一个非叶子节点开始即可。无需从最后一个叶子节点开始。
100          *  叶子节点可以看作已符合堆要求的节点,根节点就是它自己且自己以下值为最大。
101          */
102         int len = array.length - 1;
103         int beginIndex = (len - 1) >> 1;
104         for (int i = beginIndex; i >= 0; i--) {
105             maxHeapify(i, len, array);
106         }
107         /*
108          * 第二步:对堆化数据排序
109          * 每次都是移出最顶层的根节点A[0],与最尾部节点位置调换,同时遍历长度 - 1。
110          * 然后从新整理被换到根节点的末尾元素,使其符合堆的特性。
111          * 直至未排序的堆长度为 0。
112          */
113         for (int i = len; i > 0; i--) {
114             swap(0, i, array);
115             maxHeapify(0, i - 1, array);
116         }
117         System.out.println(Arrays.toString(array) + " heapSort");
118     }
119 
120     private static void swap(int i, int j, int[] arr) {
121         int temp = arr[i];
122         arr[i] = arr[j];
123         arr[j] = temp;
124     }
125 
126     /**
127      * 调整索引为 index 处的数据,使其符合堆的特性。
128      *
129      * @param index 需要堆化处理的数据的索引
130      * @param len   未排序的堆(数组)的长度
131      */
132     private static void maxHeapify(int index, int len, int[] arr) {
133         int li = (index << 1) + 1; // 左子节点索引
134         int ri = li + 1;           // 右子节点索引
135         int cMax = li;             // 子节点值最大索引,默认左子节点。
136         if (li > len) {
137             return;       // 左子节点索引超出计算范围,直接返回。
138         }
139         if (ri <= len && arr[ri] > arr[li]) // 先判断左右子节点,哪个较大。
140         {
141             cMax = ri;
142         }
143         if (arr[cMax] > arr[index]) {
144             swap(cMax, index, arr);      // 如果父节点被子节点调换,
145             maxHeapify(cMax, len, arr);  // 则需要继续判断换下后的父节点是否符合堆的特性。
146         }
147     }
148 
149 
150     public static void quickSort(int[] array) {
151         _quickSort(array, 0, array.length - 1);
152         System.out.println(Arrays.toString(array) + " quickSort");
153     }
154 
155 
156     private static int getMiddle(int[] list, int low, int high) {
157         int tmp = list[low];    //数组的第一个作为中轴
158         while (low < high) {
159             while (low < high && list[high] >= tmp) {
160                 high--;
161             }
162 
163 
164             list[low] = list[high];   //比中轴小的记录移到低端
165             while (low < high && list[low] <= tmp) {
166                 low++;
167             }
168 
169 
170             list[high] = list[low];   //比中轴大的记录移到高端
171         }
172         list[low] = tmp;              //中轴记录到尾
173         return low;                  //返回中轴的位置
174     }
175 
176 
177     private static void _quickSort(int[] list, int low, int high) {
178         if (low < high) {
179             int middle = getMiddle(list, low, high);  //将list数组进行一分为二
180             _quickSort(list, low, middle - 1);  //对低字表进行递归排序
181             _quickSort(list, middle + 1, high);  //对高字表进行递归排序
182         }
183     }
184 
185 
186     public static void mergingSort(int[] array) {
187         sort(array, 0, array.length - 1);
188         System.out.println(Arrays.toString(array) + " mergingSort");
189     }
190 
191     private static void sort(int[] data, int left, int right) {
192         if (left < right) {
193             //找出中间索引
194             int center = (left + right) / 2;
195             //对左边数组进行递归
196             sort(data, left, center);
197             //对右边数组进行递归
198             sort(data, center + 1, right);
199             //合并
200             merge(data, left, center, right);
201         }
202     }
203 
204     private static void merge(int[] data, int left, int center, int right) {
205         int[] tmpArr = new int[data.length];
206         int mid = center + 1;
207         //third记录中间数组的索引
208         int third = left;
209         int tmp = left;
210         while (left <= center && mid <= right) {
211             //从两个数组中取出最小的放入中间数组
212             if (data[left] <= data[mid]) {
213                 tmpArr[third++] = data[left++];
214             } else {
215                 tmpArr[third++] = data[mid++];
216             }
217         }
218 
219         //剩余部分依次放入中间数组
220         while (mid <= right) {
221             tmpArr[third++] = data[mid++];
222         }
223 
224         while (left <= center) {
225             tmpArr[third++] = data[left++];
226         }
227 
228         //将中间数组中的内容复制回原数组
229         while (tmp <= right) {
230             data[tmp] = tmpArr[tmp++];
231         }
232     }
233 
234 
235     public static void radixSort(int[] array) {
236         //首先确定排序的趟数;
237         int max = array[0];
238         for (int i = 1; i < array.length; i++) {
239             if (array[i] > max) {
240                 max = array[i];
241             }
242         }
243         int time = 0;
244         //判断位数;
245         while (max > 0) {
246             max /= 10;
247             time++;
248         }
249 
250 
251         //建立10个队列;
252         ArrayList<ArrayList<Integer>> queue = new ArrayList<>();
253         for (int i = 0; i < 10; i++) {
254             ArrayList<Integer> queue1 = new ArrayList<>();
255             queue.add(queue1);
256         }
257 
258 
259         //进行time次分配和收集;
260         for (int i = 0; i < time; i++) {
261             //分配数组元素;
262             for (int anArray : array) {
263                 //得到数字的第time+1位数;
264                 int x = anArray % (int) Math.pow(10, i + 1) / (int) Math.pow(10, i);
265                 ArrayList<Integer> queue2 = queue.get(x);
266                 queue2.add(anArray);
267                 queue.set(x, queue2);
268             }
269             int count = 0;//元素计数器;
270             //收集队列元素;
271             for (int k = 0; k < 10; k++) {
272                 while (queue.get(k).size() > 0) {
273                     ArrayList<Integer> queue3 = queue.get(k);
274                     array[count] = queue3.get(0);
275                     queue3.remove(0);
276                     count++;
277                 }
278             }
279         }
280         System.out.println(Arrays.toString(array) + " radixSort");
281     }
282 }

 

 

 

版权声明:本文内容由阿里云实名注册用户自发贡献,版权归原作者所有,阿里云开发者社区不拥有其著作权,亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容,填写侵权投诉表单进行举报,一经查实,本社区将立刻删除涉嫌侵权内容。

相关文章
看深度学习框架排名第一的TensorFlow如何进行时序预测!
2017年深度学习框架关注度排名tensorflow以绝对的优势占领榜首,本文通过一个小例子介绍了TensorFlow在时序预测上的应用。
1581 0
云数据库 Mysql 版的常用设置|学习笔记
快速学习云数据库 Mysql 版的常用设置
43 0
SAS学习笔记之《SAS编程与数据挖掘商业案例》(4)DATA步循环与控制、常用全程语句、输出控制
SAS学习笔记之《SAS编程与数据挖掘商业案例》(4)DATA步循环与控制、常用全程语句、输出控制 1. 各种循环与控制 DO组 创建一个执行语句块 DO循环 根据下标变量重复执行DO和END之间的语句 DO WHILE 重复执行直到条件为假则退出循环 DO UNTIL 重复执行直到条件为真则退出循环 DO OVER 对隐含下标
1314 0
怎么设置阿里云服务器安全组?阿里云安全组规则详细解说
阿里云服务器安全组设置规则分享,阿里云服务器安全组如何放行端口设置教程
10183 0
【第 1 9 个代码模型】Set 集合接口(Set 接口常用子类)|学习笔记
快速学习 【第 19 个代码模型】Set 集合接口(Set 接口常用子类)
15 0
阶段性总结_学习笔记
从11月6日到12月6日,一个月从入门到放弃目前为止,学习了 FHS,linux文件架构标准/ /boot /dev /opt /mnt /media /proc /tmp /usr /etc /lib 等等文件的查找locatefind。
819 0
网络属性配置及常用工具_学习笔记
时间:2017.12.09作者:李强参考:man,info,magedu讲义,万能的internet实验环境:CentOS 6.9与CentOS7.4声明:以下英文纯属个人翻译,英文B级,欢迎纠正,以下内容纯属个人理解,并没有对错,只是参考,盗版不纠,才能有限,希望不误人子弟为好。
919 0
+关注
angel_kitty
我叫Angel_Kitty,当然你也可以叫我笔名,Sakura,喜欢交友,乐于助人,喜欢音乐,热爱ACM竞赛,CTF竞赛,喜欢算法、Web、网络安全、黑科技、机器学习、数学建模,C/C++、C#、Java、Python、HTML5、JavaScript,E都略懂,现在主攻逆向工程
707
文章
1
问答
文章排行榜
最热
最新
相关电子书
更多
JS零基础入门教程(上册)
立即下载
性能优化方法论
立即下载
手把手学习日志服务SLS,云启实验室实战指南
立即下载