1、对数器
- 一个想要测试的方法a
- 实现一个绝对正确但复杂度不好的方法b
- 实现一个随机样本产生器
- 实现比对方法
- a b 比对多次，验证a是否正确
- 如果有样本出错，打印样本分析哪个方法出错
- 当样本数量很多时比对测试依然正确，确定方法a正确
//使用对数器测试排序算法
public class Code_test {
//绝对正确的方法b
public static void comparator(int[] arr) {
Arrays.sort(arr);
}
//生成随机数组(随机样本产生器)
public static int[] generateRandomArray(int maxSize, int maxValue) {
int[] arr = new int[(int) ((maxSize + 1) * Math.random())];
for (int i = 0; i < arr.length; i++) {
arr[i] = (int) ((maxValue + 1) * Math.random()) - (int) (maxValue * Math.random());
}
return arr;
}
//拷贝数组
public static int[] copyArray(int[] arr) {
if (arr == null) {
return null;
}
int[] res = new int[arr.length];
for (int i = 0; i < arr.length; i++) {
res[i] = arr[i];
}
return res;
}
//比对方法 a b数组完全相同
public static boolean isEqual(int[] arr1, int[] arr2) {
if ((arr1 == null && arr2 != null) || (arr1 != null && arr2 == null)) {
return false;
}
if (arr1 == null && arr2 == null) {
return true;
}
if (arr1.length != arr2.length) {
return false;
}
for (int i = 0; i < arr1.length; i++) {
if (arr1[i] != arr2[i]) {
return false;
}
}
return true;
}
//打印数组
public static void printArray(int[] arr) {
if (arr == null) {
return;
}
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
System.out.println();
}
public static void main(String[] args) {
int testTime = 500000;
int maxSize = 100;
int maxValue = 100;
boolean succeed = true;
for (int i = 0; i < testTime; i++) {
int[] arr1 = generateRandomArray(maxSize, maxValue);
int[] arr2 = copyArray(arr1);
mergeSort(arr1);
comparator(arr2);
if (!isEqual(arr1, arr2)) {
succeed = false;
break;
}
}
System.out.println(succeed ? "Nice!" : "Fucking fucked!");
int[] arr = generateRandomArray(maxSize, maxValue);
printArray(arr);
mergeSort(arr);
printArray(arr);
}
2、冒泡排序
时间复杂度O（N^2），空间复杂度O（1）
//冒泡排序
public static void bubbleSort(int[] arr) {
if (arr == null || arr.length < 2) {
return;
}
//0 ~ end（arr.length()-1）
//0 ~ end-1
//...
for (int i = arr.length - 1; i > 0; i--) {
for (int j = 0; j < i; j++) {
//相邻元素比较
if (arr[j] > arr[j + 1]) {
//交换
swap(arr, j, j + 1);
}
}
}
}
//数组元素交换，使用位运算方法，更快
private static void swap(int[] arr, int j, int i) {
arr[i] = arr[i] ^ arr[j];
arr[j] = arr[i] ^ arr[j];
arr[i] = arr[i] ^ arr[j];
}
3、插入排序
时间复杂度O（N^2），空间复杂度O（1）
public static void insertSort(int[] arr) {
if (arr == null || arr.length < 2) {
return;
}
//假设第0个元素已经排好
for (int i = 1; i < arr.length; i ++) {
//每插入一个元素，将该元素及其之前元素一同排好序
for (int j = i - 1; j >= 0 && arr[j] > arr[j + 1]; j --) {
swap(arr, j, j + 1);
}
}
}
4、选择排序
时间复杂度O（N^2），空间复杂度O（1）
public static void selectSort(int[] arr) {
if (arr == null || arr.length < 2) {
return;
}
for (int i = 0; i < arr.length - 1; i ++) {
int minIndex = i;//保存最小数下标，假设0最小
//找最小数下标
for (int j = i + 1; j < arr.length; j ++) {
minIndex = arr[j] < arr[minIndex] ? j : minIndex;
}
swap(arr, i, minIndex);
}
}
5、递归行为
6、归并排序
时间复杂度O(N*logN)，空间复杂度O(N)
public static void mergeSort(int[] arr) {
if (arr == null || arr.length < 2) {
return;
}
mergeSort(arr, 0, arr.length - 1);
}
public static void mergeSort(int[] arr, int l, int r) {
//左边=右边 即只有一个数
if (l == r) {
return;
}
//中间数 即 mid=(l+r)/2 <==> mid=l+(r-l)/2(防止溢出)
// /2 <==> >>1 使用位运算更块
int mid = l + ((r - l) >> 1);
mergeSort(arr, l, mid);//左边排序
mergeSort(arr, mid + 1, r);//右边排序
merge(arr, l, mid, r);//左右归并
}
public static void merge(int[] arr, int l, int m, int r) {
//辅助数组
int[] help = new int[r - l + 1];
int i = 0;
int p1 = l;//设置一个指针指向左边的开端l
int p2 = m + 1;//设置一个指针指向右边的开端m+1
//比较左右两边，将最小的放入辅助数组help，指针继续右移
while (p1 <= m && p2 <= r) {
help[i++] = arr[p1] < arr[p2] ? arr[p1++] : arr[p2++];
}
//右边元素全部放入
while (p1 <= m) {
help[i++] = arr[p1++];
}
//左边元素已经全部放入
while (p2 <= r) {
help[i++] = arr[p2++];
}
//将辅助数组元素拷贝到原数组
for (i = 0; i < help.length; i ++) {
arr[l + i] = help[i];
}
}
7、荷兰国旗问题
给定一个数组arr，和一个数num，请把小于num的数放在数组的
左边，等于num的数放在数组的中间，大于num的数放在数组的
右边。
要求额外空间复杂度O(1)，时间复杂度O(N)
//荷兰国旗问题
public static int[] partition(int[] arr, int l, int r, int num) {
//区域边界值
int less = l - 1;//小于区域右边
int more = r + 1;//大于区域左边
//循环条件 l<more 思想：小于区域推着等于区域向右移动
while (l < more) {
//当前值arr[l]小于给定值num
if (arr[l] < num) {
//arr[l]与小于区域下一个数（++less）交换swap，小于区域向右扩大1,当前指针向右移动
swap(arr, ++less, l++);
} else if (arr[l] > num) {//当前值arr[l]大于给定值num
//arr[l]与大于区域前一个数（--more）交换，大于区域向左扩大1
swap(arr, --more, l);
} else {//当前值arr[l]等于给定值num
l++;//当前指针直接向后移
}
}
return new int[] { less + 1, more - 1 };
}
8、快速排序
//快速排序
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);//p[0] - 1：小于区域右边界
quickSort(arr, p[1] + 1, r);//p[1] + 1：大于区域左边界
}
}
//改进的荷兰国旗问题
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);
//less+1:等于区域左边界，more：等于区域右边界
return new int[] {less + 1, more};
}
9、堆排序
堆结构详解
堆： 完全二叉树（满二叉树或二叉树最后一排依次排列）
堆可用数组结构存储，可以不存在树，只是将数组想象成树结构
建立大根堆 heapinsert：加入节点，向上对比，往上调整
大根堆调整 heapify：根节点与左右孩子最大值比较，大于则不动，小于则向下调整
堆结构的减少（eg.大根堆）
弹出堆顶：将堆最后一个位置与堆顶位置交换，标记越界的变量并减一，从0位置开始heapify调整为大根堆
//建立大根堆，index：加入节点序号
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：堆顶元素序号 size：堆大小
public static void heapify(int[] arr, int index, int size) {
//其左孩子序号
int left = index * 2 + 1;
//保证左孩子在堆内
while (left < size) {
//left + 1 < size：保证右孩子在堆内，如果右孩子的值大于左孩子，则记录最大值序号
int largest = left + 1 < size && arr[left + 1] > arr[left] ? left + 1 : left;
//最大值与堆顶元素比较，更新最大值序号
largest = arr[index] > arr[largest] ?index : largest;
//如果最大值序号与堆顶序号相同，退出
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;
}
堆排序
时间复杂度O(N*logN)，额外空间复杂度O(1)
- 建立大根堆
- 堆顶元素与最后一个元素交换，并在堆结构中删去，直至堆中元素删完
//堆排序
public static void heapSort(int[] arr) {
if (arr == null || arr.length < 2) {
return;
}
//1.将数组建立大根堆
for (int i = 0; i < arr.length; i ++) {
heapInsert(arr, i);
}
int size = arr.length;//堆大小,标记越界变量
//2.将堆顶元素与最后一个元素交换，删去堆最后一个元素
swap(arr, 0, --size);
//堆存在元素
while (size > 0) {
//调整最大堆
heapify(arr, 0, size);
//将堆顶元素与最后一个元素交换，删去堆最后一个元素
swap(arr, 0, --size);
}
}
堆结构非常重要
1，堆结构的heapInsert与heapify
2，堆结构的增大和减少
3，如果只是建立堆的过程，时间复杂度为O(N)
4，优先级队列结构，就是堆结构
10、桶排序
桶排序、计数排序、基数排序的介绍
1，非基于比较的排序，与被排序的样本的实际数据状况很有关系，所
以实际中并不经常使用
2，时间复杂度O(N)，额外空间复杂度O(N)
3，稳定的排序
//桶排序
public static void bucketSort(int[] arr) {
if (arr == null || arr.length < 2) {
return;
}
//找出arr中的最大值
int max = Integer.MIN_VALUE;
for (int i = 0; i < arr.length; i ++) {
max = Math.max(max, arr[i]);
}
//max+1：桶容量，创建桶
int[] bucket = new int[max + 1];
for (int i = 0; i < arr.length; i ++) {
//将arr中的元素放入桶中（元素值==桶序号）
bucket[arr[i]]++;
}
int i = 0;
for (int j = 0; j < bucket.length; j ++) {
//将桶中的元素依次放入原数组arr中
while (bucket[j]-- > 0) {
arr[i++] = j;
}
}
}
补充问题
给定一个数组，求如果排序之后，相邻两数的最大差值
要求时间复杂度O(N)，且要求 不能用基于比较 的排序。（言外之意就是利用桶排序的方法）
public static int maxGap(int[] nums) {
//没有数或只有一个元素 返回0
if (nums == null || nums.length < 2) {
return 0;
}
//定义三个变量
int len = nums.length;
int min = Integer.MAX_VALUE;
int max = Integer.MIN_VALUE;
//找出数组中最大值和最小值
for (int i = 0; i < len; i ++) {
max = Math.max(max, nums[i]);
min = Math.min(min, nums[i]);
}
//所有元素值相同，差值为0
if (min == max) {
return 0;
}
//len个数，准备len+1个桶
boolean[] hasNum = new boolean[(len + 1)];//是否使用过该桶
int[] maxs = new int[(len + 1)];
int[] mins = new int[(len + 1)];
int bid = 0;//指示桶序号
for (int i = 0; i < len; i ++) {
bid = bucket(nums[i], len, min, max);//计算出桶序号
//找出该桶中最小值 mins[bid]：原桶中最小值 nums[i]：当前数
mins[bid] = hasNum[bid] ? Math.min(mins[bid], nums[i]) : nums[i];
//找出该桶中最大值
maxs[bid] = hasNum[bid] ? Math.max(maxs[bid], nums[i]) : nums[i];
hasNum[bid] = true;//标记该桶已经访问过
}
int res = 0;
//lastMax:上一个桶中最大值 maxs[0]：第0个桶中最大值
int lastMax = maxs[0];
for (int i = 1; i <= len; i ++) {
if (hasNum[i]) {
//该桶中的最小值 - 上一个桶中最大值
res = Math.max(res, mins[i] - lastMax);
lastMax = maxs[i];//更新
}
}
return res;
}
//计算桶序号
public static int bucket(long num, long len, long min, long max) {
return (int) ((num - min) * len / (max - min));
}
11、衡量排序稳定性
稳定性：相同元素排好序 后的位置与原始位置的相对次序关系
稳定性汇总：冒泡、插入、归并排序可以做到稳定性，而选择、快速（暂时这样理解）、堆排序不稳定
通过举反例来证明
工程中综合排序算法
12、比较器的使用
- 排序（基于比较的排序）
- 优先级队列（实质就是堆）
- TreeSet（红黑树）
import java.util.Arrays;
import java.util.Comparator;
public class Code_09_Comparator {
//比较器的使用
//定义类型
public static class Student {
public String name;
public int id;
public int age;
public Student(String name, int id, int age) {
this.name = name;
this.id = id;
this.age = age;
}
}
//以id号上升排序的比较器
public static class IdAscendingComparator implements Comparator<Student> {
@Override
public int compare(Student o1, Student o2) {
//返回：负数、0、正数
return o1.id - o2.id;
}
}
public static class IdDescendingComparator implements Comparator<Student> {
@Override
public int compare(Student o1, Student o2) {
return o2.id - o1.id;
}
}
public static class AgeAscendingComparator implements Comparator<Student> {
@Override
public int compare(Student o1, Student o2) {
return o1.age - o2.age;
}
}
public static class AgeDescendingComparator implements Comparator<Student> {
@Override
public int compare(Student o1, Student o2) {
return o2.age - o1.age;
}
}
public static void printStudents(Student[] students) {
for (Student student : students) {
System.out.println("Name : " + student.name + ", Id : " + student.id + ", Age : " + student.age);
}
System.out.println("===========================");
}
public static void main(String[] args) {
Student student1 = new Student("A", 1, 23);
Student student2 = new Student("B", 3, 20);
Student student3 = new Student("C", 2, 21);
Student[] students = {student1, student2, student3};
printStudents(students);
//报错：Student cannot be cast to java.base/java.lang.Comparable
//自定义类不知道按哪种比较器进行排序
//Arrays.sort(students);
//printStudents(students);
//指定按照id上升排序
Arrays.sort(students, new IdAscendingComparator());
printStudents(students);
Arrays.sort(students, new AgeAscendingComparator());
printStudents(students);
}
}
有关排序问题的补充
1，归并排序的额外空间复杂度可以变成O(1)，但是非常难，不
需要掌握，可以搜“归并排序 内部缓存法”
2，快速排序可以做到稳定性问题，但是非常难，不需要掌握，
可以搜“01 stable sort”
3，有一道题目，是奇数放在数组左边，偶数放在数组右边，还
要求原始的相对次序不变 ，做到空间复杂度O(1) 时间复杂度O(N) => 此题就是0 1标准，如果能做到，则快排的partition就是稳定的，荷兰国旗问题做不到稳定性，除非看 “01 stable sort”
819
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
