算法笔记——左神初级（2）快速排序、堆排序
快速排序
快速排序的核心思想是按基准值分区：
荷兰国旗问题：
public static int[] partition(int[] arr, int L, int R, int p) {
int less = L - 1;
int more = R + 1;
while (L < more) {
if (arr[L] < p) {
swap(arr, ++less, L++);
} else if (arr[L] > p) {
swap(arr, --more, L);
} else {
L++;
}
}
return new int[] {
less + 1, more - 1 };
}
返回的是等于基准值的数字在数组中的位置。
快排代码
public static void quickSort(int[] arr) {
if (arr == null || arr.length < 2) {
return;
}
quickSort(arr, 0, arr.length - 1);
}
public static void quickSort(int[] arr, int L, int R) {
if (L < R) {
//swap(arr, L + (int) (Math.random() * (R - L + 1)), R);
int[] p = partition(arr, L, R);
quickSort(arr, L, p[0] - 1);
quickSort(arr, p[1] + 1, R);
}
}
public static int[] partition(int[] arr, int l, int r) {
int less = l - 1;
int more = r;
while (l < more) {
if (arr[l] < arr[r]) {
swap(arr, ++less, l++);
} else if (arr[l] > arr[r]) {
swap(arr, --more, l);
} else {
l++;
}
}
swap(arr, more, r);
return new int[] {
less + 1, more };
}
public static void swap(int[] arr, int i, int j) {
int tmp = arr[i];
arr[i] = arr[j];
arr[j] = tmp;
}
这是改进后的经典快排。可以看到partition函数会返回除基准值以外的数，而对基准值做了保留（这里基准值指的是若干个相等的数！） 而经典快排，一次只搞定一个数，也就是把初始的右侧数作为基准放中间，小于等于放左边，大于放右边。这样会导致左边会包含等于基准值的若干个数。 虽然复杂度相同，但常数时间会有差距。
可以看见快排的核心函数是partiton函数，该函数的作用是把输入数组的右侧数据用来做基准值，对数据进行快排，返回基准值的左边部分（比基准值小）和右边部分（比基准值大），再对左右部分进行partition。嵌套，最终对数组完成排序。
经典快排的问题是他的效率会和数据状况有关系，
参考master公式
具体原因是经典快排可能导致子区域划分极不平均。
经典快排的复杂度
最好的情况复杂度为T(N)=2T(N/2)+O(N),否则复杂度较高。
随机快速排序
所以随机快排是从数组中间取出一个数放到最右边，再进行快排。
随机快排和上面的经典快排代码基本相同，唯一区别如下。
public static void quickSort(int[] arr, int L, int R) {
if (L < R) {
swap(arr, L + (int) (Math.random() * (R - L + 1)), R); //先随机取出一个数放到最后
int[] p = partition(arr, L, R);
quickSort(arr, L, p[0] - 1);
quickSort(arr, p[1] + 1, R);
}
}
随机快排复杂度
期望复杂度：O(N*logN)，额外空间复杂度为O(logN)
这个额外空间复杂度的来源是记录的断点位置，能被二分多少次，就需要存多少个。这是长期期望的概率，否则最差的情况额外复杂度为O(N)。
工程上需要改成非递归版本~~
堆结构
堆的结构就是一棵完全二叉树；
完全二叉树就是从树的每层从左往右依次补全
完全二叉树是由满二叉树而引出来的，若设二叉树的深度为h，除第 h 层外，其它各层 (1～h-1) 的结点数都达到最大个数(即1~h-1层为一个满二叉树)，第 h 层所有的结点都连续集中在最左边，这就是完全二叉树。
堆一般都是用完全二叉树来实现的。
左孩子： 2i+1； 右孩子：2i+2
父节点：（i-1）/2
大根堆：任何一颗子树的最大值都是这个子树的头部
小根堆：任何一颗子树的最小值都是这个子树的头部
怎样建立一个大根堆？
代码如下：（加入一个新节点往上调整的函数——heapInsert）
public static void heapInsert(int[] arr, int index) {
while (arr[index] > arr[(index - 1) / 2]) {
//如果大于父节点
swap(arr, index, (index - 1) / 2); //交换其和父节点的位置
index = (index - 1) / 2; //再将新的父节点与它的父节点比较，循环
}
}
上述过程中，arr是待排序的数组，i（index）之前已经排好了大根堆，i指的是排好的大根堆中的下个数的索引。
如果 i 索引的数大于父节点，交换其和父节点的位置，再将新的父节点与它的父节点比较，循环
如果 i 索引的数不大于父节点，i++
建立一个大根堆的时间复杂度
注意，一个新节点 i 加入进来，最多比较的次数其实就是高度，也即是log（i-1）
所以建立一个大根堆的时间复杂度为
log1+log2+log3+……+log（N-1） = O（N）
当大根堆里的数变化后，怎么维持大根堆结构？
heapify函数
heapsize是指这个堆的大小（最大不超过数组长度）
public static void heapify(int[] arr, int index, int heapsize) {
int left = index * 2 + 1;
while (left < heapsize) {
//左孩子没有越界
int largest = left + 1 < heapsize && arr[left + 1] > arr[left] ? left + 1 : left;
largest = arr[largest] > arr[index] ? largest : index; //左右孩子最大值和我自身作比较
if (largest == index) {
//不用往下沉了
break;
}
swap(arr, largest, index); //否则往下沉
index = largest;
left = index * 2 + 1;
}
}
小结
建立大根堆的过程使用的函数为heapInsert，
当大根堆里的数变化后，维持大根堆结构函数为heapify，
堆数据可以增加也可以减少，堆数据增加可以使用heapInsert，
堆数据减少时将根节点弹出，最后节点放到根节点，再进行heapify
堆在系统中一般称呼叫优先级队列，调整代价较小，只需要承担logN的复杂度就可以完成，非常重要
例子：求输出若干数后的中位数
一个数列不断增加，需要随时求所有数的中位数，可以使用堆进行运算（分成大根堆和小根堆）
算法流程：
1.首先创建两个堆，一个大根堆，一个小根堆 （大根堆里装较小的数，小根堆里装大的数）
2.将第一个数据防入大根堆
3.将下一个数据跟大根堆中的数据进行比较，如果数据小于大根堆中的根，则放入大根堆中，否则装入小根堆中。
4.如果大根堆和小根堆中的数目相差2，则将数据较多的堆的父节点弹出，放入数据较少的数据堆中当父节点。弹出根节点的堆，将堆底的数放到堆顶，然后执行响应的heapify操作，同时heapsize减一。接收节点的堆采用heapinsert操作。 回到步骤3 。
中位数的数据只会从大根堆和小根堆的父节点中选出，随时进入数据，则可以随时调整，复杂度较低。
堆排序
步骤：
1、全部形成大根堆
2、堆顶跟最后数交换
3、heapsize减一（最大的数就被留到了最后）
4、对根节点进行heapify操作，重新生成大根堆
5、回到步骤2，直到排完。
代码如下：
public class Code_03_HeapSort {
public static void heapSort(int[] arr) {
if (arr == null || arr.length < 2) {
return;
}
for (int i = 0; i < arr.length; i++) {
heapInsert(arr, i);
}
int size = arr.length;
swap(arr, 0, --size);
while (size > 0) {
heapify(arr, 0, size);
swap(arr, 0, --size);
}
}
public static void heapInsert(int[] arr, int index) {
while (arr[index] > arr[(index - 1) / 2]) {
swap(arr, index, (index - 1) / 2);
index = (index - 1) / 2;
}
}
public static void heapify(int[] arr, int index, int heapsize) {
int left = index * 2 + 1;
while (left < heapsize) {
//左孩子没有越界
int largest = left + 1 < heapsize && arr[left + 1] > arr[left] ? left + 1 : left;
largest = arr[largest] > arr[index] ? largest : index; //左右孩子最大值和我自身作比较
if (largest == index) {
//我比左右孩子大，不用往下沉了
break;
}
swap(arr, largest, index);
index = largest;
left = index * 2 + 1;
}
}
public static void swap(int[] arr, int i, int j) {
int tmp = arr[i];
arr[i] = arr[j];
arr[j] = tmp;
}