数据结构-排序算法

一、插入排序

1.直接插入排序

 1     /**
 2      * 插入排序
 3      * 直接插入排序
 4      *
 5      * @Author:
 6      * @Date: 2020/10/15
 7      * @Return: void
 8      * @param arr 待排序数组
 9      * @param sortAsc true:正序;false:逆序
10      **/
11     public void inserSort(int[] arr,boolean sortAsc){
12         //默认0号元素已排序,依次遍历后续元素
13         for (int i = 1; i < arr.length; i++) {
14             //当前元素暂存变量
15             int temp = arr[i];
16             for (int j=i-1; j >= 0;j--) {
17 
18                 //用暂存变量与已排序数组的当前元素比较，不满足需要的大小关系则将当前元素后移一位
19                 if ((sortAsc && temp < arr[j]) || (!sortAsc && temp > arr[j])) {
20                     arr[j + 1] = arr[j];
21                 }
22 
23                 //用暂存变量与已排序数组的当前元素比较，满足需要的大小关系则将后一位元素替换为暂存变量
24                 if ((sortAsc && temp >= arr[j]) || (!sortAsc && temp <= arr[j])) {
25                     arr[j+1] = temp;
26                     break;
27                 }
28 
29                 //边界判断，如果当前元素已经是首号元素并且仍然不满足需要的大小关系，则将当前元素替换为暂存变量
30                 if(j-1<0 && (sortAsc && temp < arr[j]) || (!sortAsc && temp > arr[j])){
31                     arr[j] = temp;
32                 }
33             }
34         }
35     }

View Code

2.希尔排序

 1     /**
 2      * 插入排序
 3      * 希尔排序=直接插入排序+增量因子
 4      *
 5      * @Author:
 6      * @Date: 2020/10/15
 7      * @Return: void
 8      * @param arr 待排序数组
 9      * @param sortAsc true:正序;false:逆序
10      **/
11     public void shellSort(int[] arr,boolean sortAsc){
12         //增量因子
13         for (int gap = arr.length/2; gap > 0; gap/=2) {
14             //默认各个数组首号元素已排序,依次遍历后续元素
15             for (int i = gap; i < arr.length; i++) {
16                 //当前元素暂存变量
17                 int temp = arr[i];
18                 for (int j=i-gap; j >= 0;j-=gap) {
19 
20                     //用暂存变量与已排序数组的当前元素比较，不满足需要的大小关系则将当前元素后移一位
21                     if ((sortAsc && temp < arr[j]) || (!sortAsc && temp > arr[j])) {
22                         arr[j + gap] = arr[j];
23                     }
24 
25                     //用暂存变量与已排序数组的当前元素比较，满足需要的大小关系则将后一位元素替换为暂存变量
26                     if ((sortAsc && temp >= arr[j]) || (!sortAsc && temp <= arr[j])) {
27                         arr[j+gap] = temp;
28                         break;
29                     }
30 
31                     //边界判断，如果当前元素已经是当前数组的首元素并且仍然不满足需要的大小关系，则将当前元素替换为暂存变量
32                     if(j-gap<0 && (sortAsc && temp < arr[j]) || (!sortAsc && temp > arr[j])){
33                         arr[j] = temp;
34                     }
35                 }
36             }
37         }
38     }

View Code

二、选择排序

1.简单选择排序

 1     /**
 2      * 选择排序
 3      * 简单选择排序
 4      *
 5      * @Author:
 6      * @Date: 2020/10/15
 7      * @Return: void
 8      * @param arr
 9      * @param sortAsc
10      **/
11     public void selectionSort(int[] arr,boolean sortAsc){
12         //遍历0~n-1个坑位
13         for (int i = 0; i < arr.length-1; i++) {
14             //从剩余元素数组中取最值填坑(交换位置)
15             for (int j = i+1; j < arr.length; j++) {
16                 //剩余数组的当前元素比坑位中的元素更小(顺序)或更大(逆序)，则交换
17                 if((sortAsc && arr[i] > arr[j]) || (!sortAsc && arr[i] < arr[j])){
18                     int temp = arr[i];
19                     arr[i] = arr[j];
20                     arr[j] = temp;
21                 }
22             }
23         }
24     }

View Code

2.堆排序

 1     /**
 2      * 选择排序
 3      * 堆排序
 4      *
 5      * @Author:
 6      * @Date: 2020/10/15
 7      * @Return: void
 8      * @param arr
 9      * @param sortAsc
10      **/
11     public void heapSort(int[] arr,boolean sortAsc){
12         //从最后一个非叶子节点开始调整父子节点大小顺序
13         for (int i = arr.length/2; i >= 0; i--) {
14             headAdjust(arr,i,arr.length-1,sortAsc);
15         }
16 
17         //将堆根依次从数组最后开始向前填，每次填完一个坑位(交换堆根与n-i号元素的值)，进行一次堆调整
18         for (int i = arr.length-1; i >=0 ; i--) {
19             //堆根值取出填坑
20             int temp = arr[i];
21             arr[i] = arr[0];
22             arr[0] = temp;
23             //堆调整
24             headAdjust(arr,0,i,sortAsc);
25         }
26     }
27 
28 
29     /**
30      * 选择排序
31      * 堆排序-堆调整
32      *
33      * @Author:
34      * @Date: 2020/10/15
35      * @Return: void
36      * @param arr
37      * @param parent 当前父节点下标
38      * @param length 需要调整的数组长度
39      **/
40     public void headAdjust(int[] arr,int parent,int length,boolean sortAsc){
41         int temp = arr[parent];
42         //左孩子节点
43         int child = 2*parent+1;
44 
45         //在指定数组长度内进行调整
46         while(child<length){
47             int rchild = child+1;
48             //如果右孩子节点在指定数组长度内存在并且左孩子节点与右孩子节点满足正序或者逆序关系
49             if(rchild<length && ((sortAsc && arr[child] < arr[rchild]) || (!sortAsc && arr[child] > arr[rchild]))){
50                 child = rchild;
51             }
52 
53             //如果父节点与最值子节点之间已经满足正序或逆序关系,否则就将孩子节点的值赋值给父节点
54             if((sortAsc && temp >= arr[child]) || (!sortAsc && temp <= arr[child])){
55                 break;
56             }
57 
58             arr[parent] = arr[child];
59             //将当前最值子节点作为父节点继续调整
60             parent = child;
61             child = child*2+1;
62         }
63         //将temp放入最后一个最值子节点的位置
64         arr[parent] = temp;
65     }

View Code

三、交换排序

1.冒泡排序

 1     /**
 2      * 交换排序
 3      * 冒泡排序
 4      *
 5      * @Author: 
 6      * @Date: 2020/10/15
 7      * @Return: void
 8      * @param arr
 9      * @param sortAsc
10      **/
11     public void bubbleSort(int[] arr,boolean sortAsc){
12         //数组大小为n,则需要进行n-1次最值沉底
13         for (int i = 0; i < arr.length-1; i++) {
14             for (int j = 0; j < arr.length-1-i; j++) {
15                 if((sortAsc && arr[j] > arr[j+1]) || (!sortAsc && arr[j] < arr[j+1])){
16                     int temp = arr[j];
17                     arr[j] = arr[j+1];
18                     arr[j+1] = temp;
19                 }
20             }
21         }
22     }

View Code

2.快速排序

 1     /**
 2      * 交换排序
 3      * 快速排序
 4      *
 5      * @Author: 
 6      * @Date: 2020/10/15
 7      * @Return: void
 8      * @param arr
 9      * @param left
10      * @param right
11      * @param sortAsc
12      **/
13     public void quickSort(int[] arr,int left,int right,boolean sortAsc){
14         if(left>right){
15             return;
16         }
17 
18         //left为取的基准数据的下标
19         int l = left;
20         int r = right;
21         int temp = arr[left];
22         while(l!=r){
23             while(((sortAsc && arr[r] >= temp) || !sortAsc && arr[r] <= temp) && l<r){
24                 r--;
25             }
26             while(((sortAsc && arr[l] <= temp) || !sortAsc && arr[l] >= temp) && l<r){
27                 l++;
28             }
29             if(l<r){
30                 int t = arr[l];
31                 arr[l] = arr[r];
32                 arr[r] = t;
33             }
34         }
35         //当l==r时,arr[l]左边的数据小于等于temp,arr[r]右边的数据大于等于temp
36         arr[left] = arr[l];
37         arr[l] = temp;
38         quickSort(arr,left,l-1,sortAsc);
39         quickSort(arr,l+1,right,sortAsc);
40     }

View Code

四、归并排序

 1     /**
 2      * 归并排序
 3      *
 4      * @Author:
 5      * @Date: 2020/10/15
 6      * @Return: void
 7      * @param arr
 8      * @param start
 9      * @param end
10      * @param sortAsc
11      **/
12     public void mergeSort(int[] arr,int start, int end,boolean sortAsc){
13         if(start >= end){
14             return;
15         }
16 
17         int lstart = start,lend = (end+start)/2;
18         int rstart = lend+1,rend = end;
19         mergeSort(arr,lstart,lend,sortAsc);
20         mergeSort(arr,rstart,rend,sortAsc);
21 
22         int[] temp = new int[end-start+1];
23         int tk = 0;
24         while(lstart<=lend && rstart<=rend){
25             if(sortAsc){
26                 temp[tk++] = arr[lstart] < arr[rstart]?arr[lstart++]:arr[rstart++];
27             }else{
28                 temp[tk++] = arr[lstart] > arr[rstart]?arr[lstart++]:arr[rstart++];
29             }
30         }
31         while(lstart<=lend){
32             temp[tk++] = arr[lstart++];
33         }
34         while(rstart<=rend){
35             temp[tk++] = arr[rstart++];
36         }
37         for (int i = 0; i <= end-start; i++) {
38             arr[i+start] = temp[i];
39         }
40     }

View Code

五、桶排序

 1     /**
 2      * 桶排序
 3      *
 4      * @Author: 
 5      * @Date: 2020/10/15
 6      * @Return: void
 7      * @param arr
 8      * @param sortAsc
 9      **/
10     public void bucketSort(int[] arr,boolean sortAsc){
11         //求出最大值确定桶
12         int max = 0;
13         for (int i = 0; i < arr.length; i++) {
14             max = Math.max(max,arr[i]);
15         }
16 
17         int[] bucket = new int[max+1];
18 
19         for (int i = 0; i < arr.length; i++) {
20             //桶数组此下标有数据,该元素值加1
21             bucket[arr[i]]++;
22         }
23 
24         int i=0;
25         if(sortAsc){
26             for (int j = 0; j < bucket.length; j++) {
27                 while (bucket[j]-->0){
28                     arr[i++] = j;
29                 }
30             }
31         }else{
32             for (int j = bucket.length-1; j >= 0; j--) {
33                 while (bucket[j]-->0){
34                     arr[i++] = j;
35                 }
36             }
37         }
38     }

View Code

posted @ 2020-10-15 14:41 霖林焚轮阅读(68) 评论(0) 收藏举报

刷新页面返回顶部

呜啦啦的博客

数据结构-排序算法

公告