java综合排序算法,排序算法的思维分析以及java实现

堆排序(HeapSort)

思想：首先要了解堆这种数据结构以及如何建堆(堆大致可以理解为一颗完全二叉树)，堆分为大根堆(父节点的数据大于等于子节点)和小根堆(父节点的数据小于等于子节点)，想要最终得到非降序列，堆排序一般使用大根堆。

具体可以参考文章点击打开链接，写的特别详细。

堆排序算法的粗略描述如下：

(l)建立包含K1，K2，…，Kn的堆；

(2)FORi＝nTO

2 STEP –1 DO

(R1«Ri．

重建包含K1，K2，…，Ki–1的堆)

堆排序的平均复杂度为：O(nlogn),是一种不稳定的排序方法

代码实现：

import java.util.Arrays;

public class HeapSort {

public static void heapSort(int[] a) {

int arrayLength = a.length;

// 循环建堆

for (int i = 0; i < arrayLength - 1; i++) {

// 建堆

buildMaxHeap(a, arrayLength - 1 - i);

// 交换堆顶和最后一个元素

swap(a, 0, arrayLength - 1 - i);

//System.out.println("\n"+Arrays.toString(a));

}

}

// 对data数组从0到lastIndex建大顶堆

public static void buildMaxHeap(int[] data, int lastIndex) {

// 从lastIndex处节点(最后一个节点)的父节点开始

for (int i = (lastIndex - 1) / 2; i >= 0; i--) {

// k保存正在判断的节点

int k = i;

// 如果当前k节点的子节点存在

while (k * 2 + 1 <= lastIndex) {

// k节点的左子节点的索引

int biggerIndex = 2 * k + 1;

// 如果biggerIndex小于lastIndex，即biggerIndex+1代表的k节点的右子节点存在

if (biggerIndex < lastIndex) {

// 若果右子节点的值较大

if (data[biggerIndex] < data[biggerIndex + 1]) {

// biggerIndex总是记录较大子节点的索引

biggerIndex++;

}

}

// 如果k节点的值小于其较大的子节点的值

if (data[k] < data[biggerIndex]) {

// 交换他们

swap(data, k, biggerIndex);

// 将biggerIndex赋予k，开始while循环的下一次循环，重新保证k节点的值大于其左右子节点的值

k = biggerIndex;

} else {

break;

}

}

}

}

// 交换

private static void swap(int[] data, int i, int j) {

int tmp = data[i];

data[i] = data[j];

data[j] = tmp;

}

public static void main(String[] args) {

int[] A = { 3, 2, 7, 1, 8, 5, 6, 4 };

System.out.println("排序之前的数组A：");

for (int i = 0; i < A.length; i++)

System.out.print(A[i] + " ");

// 堆排序

heapSort(A);

System.out.println("\n\n排序之后的数组Ａ");

for (int i = 0; i < A.length; i++)

System.out.print(A[i] + " ");

}

}

选择排序小结：

直接选择排序中，为了从R[1..n]中选出关键字最小的记录，必须进行n-1次比较，然后在R[2..n]中选出关键字最小的记录，又需要做n-2次比较。事实上，后面的n-2次比较中，有许多比较可能在前面的n-1次比较中已经做过，但由于前一趟排序时未保留这些比较结果，所以后一趟排序时又重复执行了这些比较操作。

堆排序可通过树形结构保存部分比较结果，可减少比较次数。复杂度低，实用性更强。