快排---一次只搞定一个数字---就是选中的记录点
public static void quickSort1(int[] arr, int left, int right) {
if (left >= right) {
return;
}
int key = (int) Math.random() * (right - left + 1);
int i = left;
int j = right;
while (i < j) {
while (arr[j] >= arr[key] && i < j) {
j--;
}
while (arr[i] <= arr[key] && i < j) {
i++;
}
swap(arr, i, j);
}
arr[left]=arr[i];
arr[i]=arr[key];
quickSort1(arr, left, i - 1);
quickSort1(arr, i + 1, right);
}
使用荷兰国旗问题思路来加速快排过程------三路快排-----一次搞定多个数字--所有和记录点相等的数字
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 heapSort(int[] arr) {
if (arr.length < 2 || arr == null) {
return;
}
// 构建堆
for (int i = 0; i < arr.length; i++) {
heapInsert(arr, i);
}
int size = arr.length-1; // 堆的大小
swap(arr, 0, size); // 和最后交换 弹出堆顶
while (size > 0) { // 交换之后 要进行调整堆
heapify(arr, 0, size);
swap(arr, 0, --size);
}
}
// 堆是一种完全二叉树 从左到右填充
// 构建大根堆 O(N) index为数组当前位置
//大根堆的建立:有任何一个子树变成大根堆。复杂度=log1+ log2+… +logN=O(N)
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; // index来到父亲位置
}
}
// 调整堆 某个值变小了(index) 将其往下沉
private static void heapify(int[] arr, int index, int size) {
int left = index * 2 + 1; // 左孩子
while (left < size) {
// 左右孩子谁大返回谁的索引
int largest = left + 1 < size && arr[left + 1] > arr[left] ? left + 1 : left;
// 和父亲比较 谁大返回谁的索引
largest = arr[largest] > arr[index] ? largest : index;
if (largest == index) {
break;// 不用调整
}
// 进行到此说明孩子要调整 和孩子交换
swap(arr, index, largest);
index=largest; //当前节点变成孩子之一
left = index * 2 + 1;
}
}
private static void swap(int[] arr, int i, int j) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
优先队列是小根堆
public void test() {
//优先队列是个小根堆
PriorityQueue<Integer> minHeap=new PriorityQueue<>();
PriorityQueue<Integer> maxHeap = new PriorityQueue<Integer>(new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
return o2.compareTo(o1);
}
});
}