public static void main(String []args){
int[] arr= new int[15];
for (int i=0;i<arr.length;i++){
arr[i] = new Random().nextInt(15);
}
System.out.println(Arrays.toString(arr));
bubbleSort(arr);
System.out.println(Arrays.toString(arr));
}
private static void bubbleSort(int[] arr) {
long startTime = System.nanoTime();
for(int i=0;i<arr.length-1;i++){//冒泡趟数
for(int j=0;j<arr.length-i-1;j++){
if(arr[j]>arr[j+1]){
swap(arr,j,j+1);
}
}
}
long endTime = System.nanoTime();
//执行时间
System.out.println((endTime - startTime)/1000.0 + "ms");
}
//交换
private static void swap(int[] arr,int a,int b){
int temp = arr[a];
arr[a] = arr[b];
arr[b] = temp;
}

Kotlin版：

fun main() {
val arr = IntArray(15)
for (i in arr.indices) {
arr[i] = Random().nextInt(15)
}
println("排序前:${Arrays.toString(arr)}")
bubbleSort(arr)
println("排序后:${Arrays.toString(arr)}")
}

private fun bubbleSort(array: IntArray){
val startTime = System.nanoTime()
for (i in 0 until  array.size -1){
for (j in 0 until array.size -i -1){
if (array[j]>array[j+1]){
swap(array,j,j+1)
}
}
}
val endTime = System.nanoTime()
//执行时间
println(((endTime - startTime) / 1000.0).toString() + "ms")
}
//交换
private fun swap(array: IntArray,a:Int,b:Int){
val temp = array[a]
array[a] = array[b]
array[b] = temp
}

改进版：

加标志，加入了判断是否已经排序了的boolean变量，之后就退出循环。可避免已经有序的情况下重复的无意义的循环判断。

//加入了判断是否已经排序了的boolean变量
private static
4000
void bubbleSort(int[] arr) {
long start = System.nanoTime();
for(int i=0;i<arr.length-1;i++){//冒泡趟数
boolean isSort = true;
for(int j=0;j<arr.length-i-1;j++){
if(arr[j]>arr[j+1]){
swap(arr,j,j+1);
isSort = false;
}
}
if (isSort) break;
}
long end = System.nanoTime();
System.out.println((end - start)/1000.0 + "ms");
}

记录上一次最后交换的那个位置，下一轮交换只需要进行到这个位置即可

//java版
private static void bubbleSort2(int[] arr) {
long startTime = System.nanoTime();
for (int end = arr.length - 1; end > 0; end--) {
int border = 0;
for (int i = 0; i < end; i++) {
if (arr[i] > arr[i + 1]) {
swap(arr, i, i + 1);
border = i + 1;
}
}
end = border;
}
long endTime = System.nanoTime();
System.out.println((endTime - startTime) / 1000.0 + "ms");
}

//kotlin
private fun bubbleSort2(arr: IntArray) {
val startTime = System.nanoTime()
var end = arr.size - 1
while (end > 0) {
var border = 0
for (i in 0 until end) {
if (arr[i] > arr[i + 1]) {
swap(arr, i, i + 1)
border = i + 1
}
}
end = border
end--
}
val endTime = System.nanoTime()
println(((endTime - startTime) / 1000.0).toString() + "ms")
}

2.选择排序（Selection Sort）

2.1工作原理

首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置.
再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。

2.2算法描述

n个记录的直接选择排序可经过n−1n-1n−1趟直接选择排序得到有序结果。具体算法描述如下：

初始状态：无序区为R[1..n]R[1..n]R[1..n]，有序区为空；
第i趟排序(i=1,2,3…n−1)(i=1,2,3…n-1)(i=1,2,3…n−1)开始时，当前有序区和无序区分别为R[1..i−1]和R(i..n）R[1..i-1]和R(i..n）R[1..i−1]和R(i..n）。该趟排序从当前无序区中选出关键字最小的记录 R[k]R[k]R[k]，将它与无序区的第1个记录RRR交换，使R[1..i]R[1..i]R[1..i]和R[i+1..n)R[i+1..n)R[i+1..n)分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区；
n−1n-1n−1趟结束，数组有序化了。

2.3动图演示

2.4代码实现

//选择排序
private static void selectionSort(int[] arr) {
for (int i = 0; i < arr.length; i++) {
//记录后面最小的下标
int mIndex = i;
for (int j = i; j < arr.length; j++) {
if (arr[j] < arr[mIndex]){//找到最小的数
mIndex = j;//将最小的索引保存
}
}
swap(arr, i, mIndex);
}
}

3.插入排序（Insertion Sort）

3.1 算法描述

一般来说，插入排序都采用in-place在数组上实现。具体算法描述如下：

从第一个元素开始，该元素可以认为已经被排序；
取出下一个元素，在已经排序的元素序列中从后向前扫描；
如果该元素（已排序）大于新元素，将该元素移到下一位置；
重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；
将新元素插入到该位置后；
重复步骤2~5。

3.2 动图演示

3.3代码实现

Java版

//插入排序
private static void insertionSort(int[] array) {
int current;
for (int i = 0; i < array.length - 1; i++) {
current = array[i + 1];
int preIndex = i;
while (preIndex >= 0 && current < array[preIndex]) {
array[preIndex+1] = array[preIndex];
preIndex--;
}
array[preIndex + 1] = current;
}
}

Kotlin版

//插入排序
private fun insertionSort(array: IntArray) {
var current: Int
for (i in 0 until array.size - 1) {
current = array[i + 1]
var preIndex = i
while (preIndex >= 0 && current < array[preIndex]) {
array[preIndex + 1] = array[preIndex]
preIndex--
}
array[preIndex + 1] = current
}
}

4.希尔排序(Shell Sort)

希尔排序是希尔（Donald Shell）于1959年提出的一种排序算法。希尔排序也是一种插入排序，它是简单插入排序经过改进之后的一个更高效的版本，也称为缩小增量排序，同时该算法是冲破O(n2）O(n^2）O(n2）的第一批算法之一。它与插入排序的不同之处在于，它会优先比较距离较远的元素。希尔排序又叫缩小增量排序。

希尔排序使更高效的插入排序，它的思想在于，

把数组分成几块，每一块进行一个插入排序；
而分块的依据在于增量的选择分好块之后，从gapgapgap开始到nnn，每一组和它前面的元素（自己组内的）进行插入排序；

每次和组内的元素比较完之后，最后的元素基本就是有序的了，希尔排序相对于插入排序的优势在于插入排序每次只能将数据移动一位，不过希尔排序时间复杂度的大小还是要取决于步长的合适度，另外希尔排序不是一种稳定的排序算法。

4.1 算法描述

我们来看下希尔排序的基本步骤，在此我们选择增量gap=length/2gap=length/2gap=length/2，缩小增量继续以gap=gap/2gap = gap/2gap=gap/2的方式，这种增量选择我们可以用一个序列来表示，n/2,(n/2)/2...1{n/2,(n/2)/2...1}n/2,(n/2)/2...1，称为增量序列。希尔排序的增量序列的选择与证明是个数学难题，我们选择的这个增量序列是比较常用的，也是希尔建议的增量，称为希尔增量，但其实这个增量序列不是最优的。此处我们做示例使用希尔增量。

先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，具体算法描述：

选择一个增量序列t1，t2，…，tkt_1，t_2，…，t_kt1，t2，…，tk，其中ti>tjt_i>t_jti>tj，tk=1t_k=1tk=1；
按增量序列个数kkk，对序列进行kkk 趟排序；
每趟排序，根据对应的增量tit_iti，将待排序列分割成若干长度为mmm 的子序列，分别对各子表进行直接插入排序。仅增量因子为111时，整个序列作为一个表来处理，表长度即为整个序列的长度。

4.2 过程演示

4.3动图演示

4.4 代码实现

Java版：

　　/**
* 希尔排序
*/
private static void shellSort(int[] arr) {
long startTime = System.nanoTime();
int len = arr.length;
int temp;
int gap = len / 2; //增量序列
while (gap > 0) {
for (int i = gap; i < len; i++) { //从数组第gap个元素开始
temp = arr[i];  //每个元素与自己组内的数据进行直接插入排序
int preIndex = i - gap;
while (preIndex >= 0 && arr[preIndex] > temp) {
arr[preIndex + gap] = arr[preIndex];
preIndex -= gap;
}
arr[preIndex + gap] = temp;
}
gap /= 2;
}
long endTime = System.nanoTime();
System.out.println((endTime - startTime) / 1000.0 + "ms");
}

Kotlin版

private fun shellSort(arr: IntArray) {
val startTime = System.nanoTime()
val len = arr.size
var temp: Int
var gap = len / 2
while (gap > 0) {
for (i in gap until len) {
temp = arr[i]
var preIndex = i - gap
while (preIndex >= 0 && arr[preIndex] > temp) {
arr[preIndex + gap] = arr[preIndex]
preIndex -= gap
}
arr[preIndex + gap] = temp
}
gap /= 2
}
val endTime = System.nanoTime()
println(((endTime - startTime) / 1000.0).toString() + "ms")
}

5.快速排序（Quick Sort）

快速排序的基本思想：通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。

5.1 算法描述

快速排序使用分治法来把一个串（list）分为两个子串（sub-lists）。具体算法描述如下：

从数列中挑出一个元素，称为 “基准”（pivot）；
重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；
递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。

5.2 动图演示

5.3 代码实现

Java版

//快速排序方法
private static void quickSort(int[] array, int start, int end) {
if (array.length < 1 || start < 0 || end >= array.length || start > end) {
return;
}
int smallIndex = partition(array, start, end);
if (smallIndex > start) {
quickSort(array, start, smallIndex - 1);
}
if (smallIndex < end) {
quickSort(array, smallIndex + 1, end);
}
}
//快速排序算法——partition
private static int partition(int[] array, int start, int end) {
int pivot = (int) (start + Math.random() * (end - start + 1));
int smallIndex = start - 1;
swap(array, pivot, end);
for (int i = start; i <= end; i++)
if (array[i] <= array[end]) {
smallIndex++;
if (i > smallIndex)
swap(array, i, smallIndex);
}
return smallIndex;
}

//交换数组内两个元素
private static void swap(int[] array, int i, int j) {
int temp = array[i];
array[i] = array[j];
array[j] = temp;
}

Kotlin版

//快速排序方法
private fun quickSort(array: IntArray, start: Int, end: Int) {
if (array.isEmpty() || start < 0 || end >= array.size || start
4000
> end) {
return
}
val smallIndex = partition(array, start, end)
if (smallIndex > start) {
quickSort(array, start, smallIndex - 1)
}
if (smallIndex < end) {
quickSort(array, smallIndex + 1, end)
}
}
//快速排序算法——partition
private fun partition(array: IntArray, start: Int, end: Int): Int {
val pivot = (start + Math.random() * (end - start + 1)).toInt()
var smallIndex = start - 1
swap(array, pivot, end)
for (i in start..end)
if (array[i] <= array[end]) {
smallIndex++
if (i > smallIndex)
swap(array, i, smallIndex)
}
return smallIndex
}
//交换数组内两个元素
private fun swap(array: IntArray, i: Int, j: Int) {
val temp = array[i]
array[i] = array[j]
array[j] = temp
}

快速排序可优化的地方:

优化选取基准,如采用"三数取中"、“九数取中”

优化不必要的交换
优化数组时的排序方案
优化递归操作

具体不在此展开，感兴趣的可以查看其他资料深入研究。

6.堆排序（Heap Sort）

堆排序（Heap sort）是指利用堆这种数据结构所设计的一种排序算法。堆是一个近似完全二叉树的结构，并同时满足堆的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。

6.1 算法描述

将初始待排序关键字序列(R1,R2….Rn)(R1,R2….Rn)(R1,R2….Rn)构建成大顶堆，此堆为初始的无序区；
将堆顶元素R[1]R[1]R[1]与最后一个元素R[n]R
R[n]交换，此时得到新的无序区(R1,R2,……Rn−1)(R1,R2,……Rn-1)(R1,R2,……Rn−1)和新的有序区(Rn)(Rn)(Rn),且满足R[1,2…n−1]<=R[n]R[1,2…n-1]<=R
R[1,2…n−1]<=R[n]；
由于交换后新的堆顶R[1]R[1]R[1]可能违反堆的性质，因此需要对当前无序区(R1,R2,……Rn−1)(R1,R2,……Rn-1)(R1,R2,……Rn−1)调整为新堆，然后再次将R[1]R[1]R[1]与无序区最后一个元素交换，得到新的无序区(R1,R2….Rn−2)(R1,R2….Rn-2)(R1,R2….Rn−2)和新的有序区(Rn−1,Rn)(Rn-1,Rn)(Rn−1,Rn)。不断重复此过程直到有序区的元素个数为n−1n-1n−1，则整个排序过程完成。

6.2 动图演示

6.3 代码实现

注意：这里用到了完全二叉树的部分性质：详情见《数据结构二叉树知识点总结》

Java版

//声明全局变量，用于记录数组array的长度；
static int len;
private static int[] heapSort(int[] array) {
len = array.length;
if (len < 1) return array;
//构建一个最大堆
buildMaxHeap(array);
while (len > 0) {
swap(array, 0, len - 1);
len--;
adjustHeap(array, 0);
}
return array;
}

//调整使之成为最大堆
private static void adjustHeap(int[] array, int i) {
int maxIndex = i;
//如果有左子树，且左子树大于父节点，则将最大指针指向左子树
if (i * 2 < len && array[i * 2] > array[maxIndex]) {
maxIndex = i * 2;
}
//如果有右子树，且右子树大于父节点，则将最大指针指向右子树
if (i * 2 + 1 < len && array[i * 2 + 1] > array[maxIndex]) {
maxIndex = i * 2 + 1;
}
//如果父节点不是最大值，则将父节点与最大值交换，并且递归调整与父节点交换的位置。
if (maxIndex != i) {
swap(array, maxIndex, i);
adjustHeap(array, maxIndex);
}
}

//建立最大堆
private static void buildMaxHeap(int[] array) {
for (int i = (len / 2 - 1); i >= 0; i--) {
adjustHeap(array, i);
}
}

Kotlin版

private fun heapSort(array: IntArray): IntArray {
len = array.size
if (len < 1) return array
//构建一个最大堆
buildMaxHeap(array)
while (len > 0) {
swap(array, 0, len - 1)
len--
adjustHeap(array, 0)
}
return array
}

//调整使之成为最大堆
private fun adjustHeap(array: IntArray, i: Int) {
var maxIndex = i
//如果有左子树，且左子树大于父节点，则将最大指针指向左子树
if (i * 2 < len && array[i * 2] > array[maxIndex]) {
maxIndex = i * 2
}
//如果有右子树，且右子树大于父节点，则将最大指针指向右子树
if (i * 2 + 1 < len && array[i * 2 + 1] > array[maxIndex]) {
maxIndex = i * 2 + 1
}
//如果父节点不是最大值，则将父节点与最大值交换，并且递归调整与父节点交换的位置。
if (maxIndex != i) {
swap(array, maxI
4000
ndex, i)
adjustHeap(array, maxIndex)
}
}

//建立最大堆
private fun buildMaxHeap(array: IntArray) {
for (i in len / 2 - 1 downTo 0) {
adjustHeap(array, i)
}
}

7、归并排序（Merge Sort）

和选择排序一样，归并排序的性能不受输入数据的影响，但表现比选择排序好的多，因为始终都是O(nlogn)O(nlogn)O(nlogn)的时间复杂度。代价是需要额外的内存空间。

归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。归并排序是一种稳定的排序方法。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为2-路归并。

7.1 算法描述

把长度为nnn的输入序列分成两个长度为n/2n/2n/2的子序列；
对这两个子序列分别采用归并排序；
将两个排序好的子序列合并成一个最终的排序序列。

7.2 动图演示

7.3 代码实现

Java版

　   /**
* 归并排序
*/
private static int[] mergeSort(int[] array) {
if (array.length < 2) return array;
int mid = array.length / 2;
int[] left = Arrays.copyOfRange(array, 0, mid);
int[] right = Arrays.copyOfRange(array, mid, array.length);
return merge(mergeSort(left), mergeSort(right));
}

/**
* 归并排序——将两段排序好的数组结合成一个排序数组
*/
private static int[] merge(int[] left, int[] right) {
int[] result = new int[left.length + right.length];
for (int index = 0, i = 0, j = 0; index < result.length; index++) {
if (i >= left.length)
result[index] = right[j++];
else if (j >= right.length)
result[index] = left[i++];
else if (left[i] > right[j])
result[index] = right[j++];
else
result[index] = left[i++];
}
return result;
}

Kotlin版：

/**
* 归并排序
*/
private fun mergeSort(array: IntArray): IntArray {
if (array.size < 2) return array
val mid = array.size / 2
val left = Arrays.copyOfRange(array, 0, mid)
val right = Arrays.copyOfRange(array, mid, array.size)
return merge(mergeSort(left), mergeSort(right))
}

/**
* 归并排序——将两段排序好的数组结合成一个排序数组
*/
private fun merge(left: IntArray, right: IntArray): IntArray {
val result = IntArray(left.size + right.size)
var index = 0
var i = 0
var j = 0
while (index < result.size) {
when {
i >= left.size -> result[index] = right[j++]
j >= right.size -> result[index] = left[i++]
left[i] > right[j] -> result[index] = right[j++]
else -> result[index] = left[i++]
}
index++
}
return result
}

8.其他排序

桶排序、基数排序、计数排序（略），后期看情况继续完善。

9.总结

本文总结了常见的七种算法，主要在于了解各自的算法思想。图片大多来源于网络，侵删。如有不足之处，欢迎指正。

上一篇：常见的数据结构和算法小结

参考资料：

1.十大经典排序算法最强总结（含JAVA代码实现）

2.五分钟学算法

3.程杰 .大话数据结构. 北京：清华大学出版社, 2011

内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理

标签：

相关文章推荐

新的分享

章节导航