写算法的时候顺便把八大排序整理了一下,跟大家分享一下,写的不好,希望大神批评指正。(参考数据结构)
这里是同学推荐的视频(http://www.cnbeta.com/articles/tech/202221.htm),感觉很不错,对于刚学的人来说,看完视频再看代码应该很好理解了,不过就是一下看好几个再加上里面···的音乐,估计有点儿喘不过气,总之还是很清晰的,自己感受吧。
评价算法的指标是:时间、空间和稳定性。
算法特点:
算法名称 时间复杂度 空间复杂度 稳定性
直接插入 O(n2) O(1) √
希尔排序 n→∞ O(n(log2n2)) O(1) ×
冒泡排序 O(n2) O(1) √
快速排序 O(nlog2n)
好:O(log2n)
坏:O(n)
×
选择排序 O(n2) O(1)
算法本身是稳定的
采用“交换记录”策略会造成不稳定现象的产生
堆排序 O(nlog2n) O(1) ×
归并排序 O(nlog2n) O(n) √
基数排序 O(d(n+rd)) O(n+rd) √
直接插入排序,是当待排序的记录个数比较少并且排序序列的关键字基本有序时,效率较高。
通过构建有序序列,对于未排序的数据,在已排序序列中从后向前扫描,找到相应的位置并插入。(在具体实现的时候,可以将list[i]从前向后插入比较,也可以从后向前插入比较。这里采用的是从后向前插入比较)
1 public class Main {
2
3 /*插入排序*/
4 public static int[] insert_sort(int[] list){
5 int j,temp;
6 for (int i = 0; i < list.length; i++) {
7 j = i - 1;
8 temp = list[i];
9 while (j >= 0) {
10 if (temp < list[j]) {
11 list[j+1] = list[j];
12 list[j] = temp;
13 }
14 j = j-1;
15 }
16 }
17 return list;
18 }
19
20 public static void main(String[] args) {
21 int[] list = new int[]{49,38,65,97,76,13,27,49,55,04};
22 int[] result = new int[list.length];
23 result = insert_sort(list);
24 System.out.println("插入排序:");
25 for (int i = 0; i < result.length; i++) {
26 System.out.print(result[i] + ",");
27 }
28 }
29 }
注:main函数的调用就写上面的一个,下面就不再写了,毕竟这个大家都可以。
希尔排序又称“缩小增量排序”,也是插入排序的一种。希尔排序实质上是采用分组插入的方法。先将待排序记录序列分割成几组,对每组进行直接插入,然后增加每组的数据量重新分组。就这样经过几次分组排序之后,整个序列基本有序,最后再进行一次直接插入排序。
1 /*希尔排序*/
2 public static int[] shell_sort(int[] list){
3 int j,temp,k;
4 int group = list.length/2;
5
6 while (group>0) {
7 for (int i = 0; i < group; i++) {
8 j = i + group;
9 while (j <list.length) {
10 temp = list[j];
11 k = j-group;
12 while (k >= 0) {
13 if (list[k] > temp) {
14 list[k+group] = list[k]; //记录后移,直到找到插入位置
15 list[k] = temp;
16 }
17 k = k - group;
18 }
19 j = j + group;
20 }
21 }
22 group = group / 2;
23 }
24 return list;
25 }
简单选择排序
1 /*简单选择排序*/
2 public static int[] select_sort(int[] list){
3
4 int min = list[0],temp;
5
6 for (int i = 0; i < list.length; i++) {
7 if (list[i] < min) {
8 min = list[i];
9 }
10 }
11
12 return list;
13 }
冒泡排序是一种最简单的交换排序方法,是通过两两比较相邻记录的关键词,如果发生逆序,就交换。从而使关键字小的记录就行气泡一样逐渐往上“漂浮”或者是较大的像石块一样“坠落”。当n较大时(数据长度较大)不宜采用此算法。
1 /*冒泡排序*/
2 public static int[] bubble_sort(int[] list){
3 int temp;
4 for (int i = 0; i < list.length; i++) {
5 for (int j = i+1; j < list.length; j++) {
6 if (list[i] > list[j]) {
7 temp = list[i];
8 list[i] = list[j];
9 list[j] = temp;
10 }
11 }
12 }
13 return list;
14 }
```
1 /*快速排序*/
2 public static int[] quick_sort(int[] list,int left,int right) {
3 int temp,low,high;
4 if (left >= right) {
5 return list;
6 }
7 temp = list[left];
8 low = left;
9 high = right;
10
11 while (left < right) {
12 while (left < right && list[right] >= temp) {
13 right -= 1;
14 }
15 list[left] = list[right];
16 while (left < right && list[left] <= temp) {
17 left += 1;
18 }
19 list[right] = temp;
20 quick_sort(list, low, left - 1);
21 quick_sort(list, left + 1, high);
22 }
23 return list;
24 }
1 /*归并排序*/
2 public static int[] merge(int[] left,int[] right) {
3
4 int i=0,j=0;
5 int[] result;
6 while (i < left.length && j < right.length) {
7 if (left[i] <= right[j]) {
8 result.append(left[i]);
9 i += 1;
10 }else{
11 result.append(right[j]);
12 j += 1
13 }
14
15 }
16
17 return result;
18
19 }