堆排序
1.介绍:对简单的选择排序的一种改进,改进效果非常明显,每次在选择最小记录的同时,并根据比较结果对其他记录做出相应的调整,那么排序效率就会提高很多。
定义:将待排序的序列构造成一个大顶堆,此时,整个序列的最大值就是堆顶的根节点。将它移走(其实就是将其与堆数组的末尾元素进行交换,此时末尾元素就是最大值),然后将剩余的n-1个元素序列从新构造成一个堆,这样就会得到n个元素中的次大值。如此反复进行,就能得到一个有序序列。
public static void heapSort(int[] arr) {
int i;
//构建一个大顶堆
for (i = (arr.length - 1) / 2; i >= 0; i--) {
heapAdjust(arr, i, arr.length);
}
for (i = arr.length -1; i > 1; i--) {
//将堆顶记录和未经排序的最后一个记录交换
MyClass.swap(arr, 0, i);
//从新调整为大顶堆,从第一个元素开始
heapAdjust(arr, 0, i - 1);
}
}
/**
* 构造大顶堆
*
* @param arr
* @param i
* @param length 数组的长度
*/
private static void heapAdjust(int[] arr, int i, int length) {
int temp = arr[i];
// +1 ,是因为数组从0下标开始,可以画图推导一下
for (int j = 2 * i + 1; j < length ; j = j * 2 + 1) {
//取出当前节点的左右节点的最大值
if (j < length -1 && arr[j] < arr[j+1]) {
++j; //代表左右子节点最大值的下标
}
if (temp >= arr[j]) {
break;
}
arr[i] = arr[j];
i = j;//此时从新循环新的节点(刚跟i交换数据的那个节点后面的左,右节点)
}
//将原先堆顶的元素放到最后的位置,也就是j的位置。
arr[i] = temp;
}
归并排序
1.介绍:将初始序列两两进行排序,然后在两两归并,如此重复,得到一个长度为n的有序序列为止。
public static void mergeSort(int[] arr) {
int[] temp = new int[arr.length]; //临时数组
sort(arr, temp, 0, arr.length - 1);
}
private static void sort(int[] arr, int[] temp, int left, int right) {
if (left >= right) return;
int center = (left + right) / 2;
sort(arr, temp, left, center);
sort(arr, temp, center + 1, right);
merge(arr, temp, left, center, right);
}
/**
* 将两个数组进行归并
*
* @param arr
* @param left
* @param center
* @param right
*/
private static void merge(int[] arr, int[] temp, int left, int center, int right) {
// int[] temp = new int[arr.length];
int mid = center + 1;
int p = left;
int start = left;
while (left <= center && mid <= right) {
if (arr[left] <= arr[mid]) {
temp[p++] = arr[left++];
} else {
temp[p++] = arr[mid++];
}
}
//左边剩余数据依次放入临时数组中
while (left <= center) {
temp[p++] = arr[left++];
}
while (mid <= right) {
temp[p++] = arr[mid++];
}
//复制数组
while (start <= right) {
arr[start] = temp[start++];
}
}
快速排序
介绍:选取一个中间值,第一次排序,将比这个中间值大的所有数据放入后面,比它小的所有数据放入前面,再依次从该数后面和前面的数组中依次排序。
public static void quickSort(int[] arr) {
sort(arr, 0, arr.length - 1);
}
private static void sort(int[] arr, int low, int high) {
int pivot;
if (low < high) {
//计算出分量
pivot = partition(arr, low, high);
sort(arr, low, pivot - 1);
sort(arr, pivot + 1, high);
}
}
private static int partition(int[] arr, int low, int high) {
int pivotKet = arr[low]; //初始化中枢值第一个元素
while (low < high) {
while (low < high && arr[high] >= pivotKet) { //最后元素小于中枢值
high--;
}
//只是替换,优化不必要的交换
//MyClass.swap(arr,low,high);
arr[low] = arr[high];
while (low < high && arr[low] <= pivotKet) {
low++;
}
//MyClass.swap(arr,low,high);
arr[high] = arr[low];
}
arr[low] = pivotKet;
return low;
}