Java实现常见的几种排序

Posted 萌虾

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Java实现常见的几种排序相关的知识,希望对你有一定的参考价值。

 1 package Sort;
 2 
 3 /**
 4  * Created by lenovo on 2017/9/6.
 5  */
 6 /*
 7 * 优化的冒泡排序
 8 * 如果数组i之后元素之间没有发生交换,那么说明i之后的元素已经排好序了,此时flag标记为false,
 9 * 数组排序结束,否则继续进行比较、交换。
10 * */
11 public class BubbleSort {
12     public void bubbleSort(int[] array) {
13         int length = array.length;
14         boolean flag = true;
15         for (int i = 0; i < length-1 && flag; i++) {
16             flag = false;
17             for (int j = length-2; j >=i; j--) {
18                 if (array[j] > array[j + 1]) {
19                     swap(array, j, j + 1);
20                     flag = true;
21                 }
22             }
23         }
24     }
25     public void swap(int[] array, int i, int j) {
26         int temp = array[i];
27         array[i] = array[j];
28         array[j] = temp;
29     }
30     public static void main(String[] args){
31         BubbleSort bubbleSort=new BubbleSort();
32         int[] a={5,2,3,4,1};
33         bubbleSort.bubbleSort(a);
34         for (int n:a)System.out.println(n);
35     }
36 }
 1 package Sort;
 2 
 3 /**
 4  * Created by lenovo on 2017/9/6.
 5  */
 6 /*
 7 *简单选择排序
 8 * 每轮比较过后,找出最小值的下标minIndex,如果i==minIndex,则找到最小值,不需要交换;
 9 * 如果i!=minIndex,则需要交换i与minIndex位置的数值
10 * */
11 public class SelectSort {
12     public void selectSort(int[] array){
13         int length=array.length;
14         int minIndex;
15         for (int i=0;i<length-1;i++){
16             minIndex=i;
17             for (int j=i+1;j<length;j++){
18                 if (array[j]<array[minIndex])
19                     minIndex=j;
20             }
21             if (minIndex!=i)
22                 swap(array,minIndex,i);
23         }
24     }
25     public void swap(int[] array, int i, int j) {
26         int temp = array[i];
27         array[i] = array[j];
28         array[j] = temp;
29     }
30     public static void main(String[] args){
31         SelectSort selectSort=new SelectSort();
32         int[] a={5,2,3,4,1};
33         selectSort.selectSort(a);
34         for (int n:a)System.out.println(n);
35     }
36 }
 1 package Sort;
 2 
 3 /**
 4  * Created by lenovo on 2017/9/5.
 5  */
 6 public class HeapSort {
 7     //堆排序:
 8     // 将无序序列{50,10,90,30,70,40,80,60,20}转换成{0,50,10,90,30,70,40,80,60,20}
 9     // 使原序列数字下标一次为1,2,3,4,5,6,7,8,9;
10     // 1,将无序序列构建成一个大顶堆(大顶堆:任意结点的值大于其所有子结点的值);
11     // 2,结合完全二叉树性质,找出该大顶堆中的根结点(下标为在[1,length/2]范围的结点都是根结点);
12     // 3,将所有的根结点所在的子树构建成一个大顶堆;
13     // 4,将整个无序序列构建成一个大顶堆后,将堆顶结点值与当前大顶堆最后一个结点值交换,
14     // 此时大顶堆结构被破坏,再将[1,i-1]重构成大顶堆,i的初始值为length,之后重复步骤4;
15     public void heapSort(int[] array) {
16         int length = array.length;
17         int i;
18         int[] heapArray = new int[length + 1];
19         System.arraycopy(array, 0, heapArray, 1, length);
20         for (i = length / 2; i > 0; i--)
21             HeapAdjust(heapArray, i, length);
22         for (i = length; i > 1; i--) {
23             swap(heapArray, 1, i);
24             HeapAdjust(heapArray, 1, i - 1);
25         }
26         System.arraycopy(heapArray, 1, array, 0, length);
27     }
28 
29     public void HeapAdjust(int[] array, int i, int length) {
30         int root = array[i];
31         for (int j = 2 * i; j <= length; j = 2 * j) {
32             if (j < length && array[j + 1] > array[j])
33                 j = j + 1;
34             if (root < array[j]) {
35                 array[i] = array[j];
36                 i = j;
37             } else break;
38         }
39         array[i] = root;
40     }
41 
42     public void swap(int[] array, int i, int j) {
43         int temp = array[i];
44         array[i] = array[j];
45         array[j] = temp;
46     }
47 }
 1 package Sort;
 2 
 3 /**
 4  * Created by lenovo on 2017/9/4.
 5  */
 6 public class StraightInsertSort {
 7     //直接插入排序
 8     public void straightInsertSort(int[] array) {
 9         int length = array.length;
10         int soldier, i, j;
11         for (i = 1; i < length; i++) {
12             if (array[i - 1] > array[i]) {
13                 soldier = array[i];//设置哨兵
14                 for (j = i - 1; j >= 0 && array[j] > soldier; j--)
15                     array[j + 1] = array[j];
16                 array[j + 1] = soldier;
17             }
18         }
19     }
20 
21     public static void main(String[] args) {
22         StraightInsertSort s = new StraightInsertSort();
23         int[] a = {5, 3, 4, 6, 2};
24         s.straightInsertSort(a);
25         for (int n : a) System.out.print(n);
26     }
27 }
 1 package Sort;
 2 
 3 /**
 4  * Created by lenovo on 2017/9/5.
 5  */
 6 public class ShellSort {
 7     //希尔排序:设置增量,将序列分割成几个子序列,分别对子序列进行“直接插入排序”,使整个序列基本有序;
 8     // 最后increment=1再对整个序列进行直接插入排序。
 9     public void shellSort(int[] array) {
10         int length = array.length;
11         int increment = length;
12         int soldier, i, j;
13         do {
14             increment = increment / 3 + 1;
15             for (i = increment; i < length; i += increment) {
16                 if (array[i - increment] > array[i]) {
17                     soldier = array[i];
18                     for (j = i - increment; j >= 0 && array[j] > soldier; j -= increment)
19                         array[j + increment] = array[j];
20                     array[j + increment] = soldier;
21                 }
22             }
23         } while (increment > 1);
24     }
25 
26 }
 1 package Sort;
 2 
 3 /**
 4  * Created by lenovo on 2017/9/5.
 5  */
 6 public class MergeSort {
 7     //归并排序
 8     public void mergeSort(int[] array) {
 9         int length = array.length;
10         int[] newArray = new int[length];
11         int k = 1;
12         while (k < length) {
13             //将array序列分割成若干长度为k的子序列,再将这些子序列两两合并,放进序列newArray
14             MergePass(array, newArray, k, length);
15             //长度k加倍
16             k = k * 2;
17             //将进行过一轮排序以及合并后的序列newArray再分割成若干长度为k的子序列,再将这些子序列两两合并,放进序列Array
18             MergePass(newArray, array, k, length);
19             //长度k再加倍
20             k = k * 2;
21         }
22     }
23 
24     public void MergePass(int[] array, int[] newArray, int dis, int length) {
25         int i = 0;
26         /*
27         * 情况1:按长度为dis来分割整个序列array,分割过程中当剩余的序列array长度>=2dis时,
28         * 可以进行分割归并,如下
29         * */
30         while (i <= length - 2 * dis) {
31             Marge(array, newArray, i, i + dis - 1, i + 2 * dis - 1);
32             i = i + dis * 2;
33         }
34         /*
35         *情况2:分割过程中当最后剩余的序列array长度在(dis,2dis)范围时,将序列仅且分为2个子序列,
36         *  一个长度为dis,另一个长度不足dis,将两个子序列进行归并
37         * */
38         if (i < length - dis)
39             Marge(array, newArray, i, i + dis - 1, length - 1);
40         /*
41         * 情况3:分割过程中当最后剩余的序列array长度在<dis时,那么只有一个长度不足dis的子序列,
42         * 无法进行归并,则剩下的这个子序列直接添加进newArray末尾
43         * */
44         else
45             for (int j = i; j < length; j++) {
46                 newArray[j] = array[j];
47             }
48     }
49 
50     public void Marge(int[] array, int[] newArray, int i, int mid, int last) {
51         int k = i;//newArray下标k
52         int j = mid + 1;
53         //待合并的两个子序列array[i,mid]和array[mid+1,last]的元素逐个进行比较,
54         // 从小到大依次存入newArray数组里面,算是完成了两个子序列的合并
55         for (; i <= mid && j <= last; k++) {
56             if (array[i] < array[j]) newArray[k] = array[i++];
57             else newArray[k] = array[j++];
58         }
59         //上述比较过后,将第一个子序列的剩余元素存入newArray
60         if (i <= mid)
61             for (int l = i; l <= mid; l++)
62                 newArray[k++] = array[l];
63         //上述比较过后,将第二个子序列的剩余元素存入newArray
64         if (j <= last)
65             for (int l = j; l <= last; l++)
66                 newArray[k++] = array[l];
67     }
68 }
 1 package Sort;
 2 
 3 /**
 4  * Created by lenovo on 2017/9/5.
 5  */
 6 public class QuickSort {
 7     //快速排序
 8     //找一个分割点part,part左边的数小于part,右边的数大于part,依次规则,
 9     // 将子序列的首个数字设置成一个哨兵,将它与该子序列的其他元素进行比较交换,
10     // 使得整个子序列最终的排序结果为:哨兵左边的数小于哨兵,右边的数大于哨兵,返回part的下标;
11     //然后以part下标为分割点将序列分为左右两个子序列。
12     //依次对左右子序列进行寻找分割点、分割成更小的子序列的操作,直到序列不能再分割。
13     public void quickSort(int[] array) {
14         int length = array.length;
15         QSort(array, 0, length - 1);
16     }
17 
18     public void QSort(int[] array, int low, int high) {
19         int partIndex;
20         if (low < high) {
21             partIndex = getPartIndex(array, low, high);
22             QSort(array, low, partIndex);
23             QSort(array, partIndex + 1, high);
24         }
25     }
26 
27     public int getPartIndex(int[] array, int low, int high) {
28         int soldier = array[low];
29         while (low < high) {
30             while (low < high && array[high] >= soldier)
31                 high--;
32             swap(array, low, high);
33             while (low < high && array[low] <= soldier)
34                 low++;
35             swap(array, low, high);
36         }
37         return low;
38     }
39     public void swap(int[] array, int i, int j) {
40         int temp = array[i];
41         array[i] = array[j];
42         array[j] = temp;
43     }
44 
45 }

 

以上是关于Java实现常见的几种排序的主要内容,如果未能解决你的问题,请参考以下文章

JAVA常见的几种排序算法

Java中数组常见的几种排序方法!

常见的几种限流算法代码实现(JAVA)

常见的几种限流算法代码实现(JAVA)

常见的几种限流算法代码实现(JAVA)

常见的几种数组排序方法