冒泡排序
冒泡排序的基本思想是对相领的元素进行两两比较，顺序相反则进行交换，这样一趟下来就能将最小或最大的元素浮到"顶端"，然后将待排序列分为两部分，一部分为有序序列，另一部分是无序序列，只对无序序列中元素进行两两比较。(关键字就是相邻两两比较)
public static void BubbleSort(int[] arr) {
if(arr==null || arr.length<2)
return;
//数组中有多少个元素就进行多少趟
for(int end=arr.length-1;end>0;end--) {
//只对无序序列进行两两比较
for(int i=0;i<end;i++) {
if(arr[i]>arr[i+1])
swap(arr,i,i+1);
}
}
}
时间复杂度：
N为数组长度
(N-1)+(N-2)+(N-3)+…等差数列，之后去掉低阶项和系数，时间复杂度为O(N2)
选择排序
选择排序的基本思想是将待排序序列分为两部分，一部分为有序序列，另一部分是无序序列。第一趟：从a[0]到a[n-1]中找到最小的数a[i]，然后将a[i]与a[0]交换，第二趟：从a[1]到a[n-1]中找到最小的数a[j]，然后将a[j]与a[1]交换,第三趟：从a[2]到a[n-1]中找到最小的数a[k],然后将a[k]与a[2]交换 ……
实例分析：
arr= {2,4,3,7,9,1};
第一趟：1，{2,4,3,7,9}
第二趟：{1,2},{4,3,7,9}
第三趟：{1,2,3},{4,7,9}
…
最后{1,2,3,4,7,9}
public static void selectSort(int[] arr) {
if(arr==null || arr.length<2)
return ;
for(int i=0;i<arr.length;i++) {
int minindex=i;
//找到无序序列中最小的
for(int j=i+1;j<arr.length;j++) {
minindex=arr[j]<arr[minindex]? j:minindex;
}
swap(arr,i,minindex);
}
}
时间复杂度
仍然是(N-1)+(N-2)+(N-3)+…等差数列，之后去掉低阶项和系数，时间复杂度为O(N2)
插入排序
插入排序的基本思想：
- 默认第一个元素已经排好序
- 从无序序列中取出第一个未排序的元素，在已经排好序的元素列表中从后往前扫描，逐一比较
- 如果该元素小于已排序的元素，将该元素插入到下个位置
- 重复步骤三，直到该元素大于有序序列中的元素
实例分析：
{2,4,3,7,9,1}
第一趟：2，{4,3,7,9,1} temp=4
temp大于2
第二趟：{2,4} {3,7,9,1} temp=3
temp小于4 temp大于2
第三趟：{2,3,4} {7,9,1} temp=7
tempd大于4
…
public static void insertSort(int[] arr) {
if(arr==null || arr.length<2)
return ;
//从1开始，默认第0处为已排序
for(int i=1;i<arr.length;i++) {
//从有序序列的最后一个数开始，temp为无序序列的第一个数
//直到遇到比temp大的数
for(int j=i-1;j>=0 && arr[j]>arr[j+1];j--) {
swap(arr,j,j+1);
}
}
}
时间复杂度
选择排序和冒泡排序和数据状况无关，算法的时间复杂度是固定的；而插入排序的时间复杂度涉及到数据的具体情况。
实例分析：
如果数据一开始就是有序的，{1,2,3,4,5}
那么插入排序中第二个for循环实际上是不用执行的，时间复杂度为O(N)
如果数据一开始都是倒序的,{5,4,3,2,1}
时间复杂度是(N-1)+(N-2)+(N-3)+…等差数列，之后去掉低阶项和系数，时间复杂度为O(N2)
而时间复杂度一律按算法流程中最差数据下的指标，所以插入排序的时间复杂度还是为O(N2)
归并排序
归并排序的基本思想就是采用经典的分治（divide-and-conquer）策略（分治法将问题分(divide)成一些小的问题然后递归求解，而治(conquer)的阶段则将分的阶段得到的各答案"修补"在一起，即分而治之)。
归并排序详解
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;
}
int mid = l + ((r - l) >> 1);//L和R中点
mergeSort(arr, l, mid);//T(N/2)
mergeSort(arr, mid + 1, r);//T(N/2)
merge(arr, l, mid, r);//O(N)
}
//快排的方法排序两个数组
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;//左指针
int p2 = m + 1;//右指针
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];
}
}
归并排序的时间复杂度：
根据Master公式(递归的实质和归并排序复杂度计算)为：O(N*logN)
空间复杂度为O(N),创建了help[N]大小内存
快速排序
堆排序
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 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, 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;
}
// for test
public static void comparator(int[] arr) {
Arrays.sort(arr);
}
// for test
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;
}
// for test
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;
}
// for test
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;
}
// for test
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();
}
// for test
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);
heapSort(arr1);
comparator(arr2);
if (!isEqual(arr1, arr2)) {
succeed = false;
break;
}
}
System.out.println(succeed ? "Nice!" : "Fucking fucked!");
int[] arr = generateRandomArray(maxSize, maxValue);
printArray(arr);
heapSort(arr);
printArray(arr);
}
}
桶排序
坐在马桶上学桶排序
桶排序是一种基于计数的排序算法，工作原理是将数组分到有限数量的桶子里，然后对每个桶再分别排序，最后将各个桶中的数据有序的合并起来。
桶排序流程:
- 设置固定数量的空桶
- 将数据放到对应的桶中
- 对每个不为空的桶中数据进行排序
- 拼接不为空的桶中数据，得到结果
实例分析
设有数组 array = [29, 25, 3, 49, 9, 37, 21, 43]，那么数组中最大数为 49，先设置 5 个桶，那么每个桶可存放数的范围为：09、1019、2029、3039、40~49，然后分别将这些数放人自己所属的桶，如下图：
然后，分别对每个桶里面的数进行排序，或者再将数放入桶的同时用插入排序进行排序，最后将各个桶中的数据有序的合并起来
桶排序解决相邻两数最大差值
- 首先求出数组的最大值max和最小值min
- 将该区间均等的划分为N+1份，即N+1个桶，那么由于只有N个数，因此，必定至少有一个桶为空桶
- 遍历数组，将所有数入桶，并记录每一个桶的最大值和最小值
- 无需考虑桶内数的差值，因为它都不会大过空桶两边的桶的数的差值
- 依次遍历每一个桶，找到一个空桶，记录其前一个非空桶的最大值和其后一个非空桶的最小值，它们的差值就是最大的
/**
* 求给定数组排序之后相邻两数的最大差值，要求时间复杂度为O（N）
*/
public class MaxGap {
public static int maxGap(int[] arr) {
if (arr == null || arr.length < 2)
return 0;
int len = arr.length;
//表示桶内是否含有元素
boolean[] hasNum = new boolean[len + 1];
//表示桶内元素中的最小值
int[] mins = new int[len + 1];
//表示桶内元素中的最大值
int[] maxs = new int[len + 1];
int min = Integer.MAX_VALUE;
int max = Integer.MIN_VALUE;
int bid = 0;
//找到数组中的最大值和最小值
for (int e : arr) {
min = Math.min(min, e);
max = Math.max(max, e);
}
if (min == max)
return 0;
for (int i = 0; i < len; i++) {
//将数组元素分配入桶
bid = bucketId(arr[i], len, min, max);
//计算桶内最小值
mins[bid] = hasNum[bid] ? Math.min(mins[bid], arr[i]) : arr[i];
//计算桶内最大值
maxs[bid] = hasNum[bid] ? Math.max(maxs[bid], arr[i]) : arr[i];
hasNum[bid] = true;
}
//差值
int res = 0;
int preMax = maxs[0];
for (int i = 1; i <= len; i++) {
//如果非空桶
if (hasNum[i]) {
res = Math.max(res, mins[i] - preMax);
preMax = maxs[i];
}
}
return res;
}
//判断整数item所属桶的id
public static int bucketId(int num, int len, int min, int max) {
return ((num - min) * len / (max - min));
}
}
排序的稳定性
综合排序
综合排序中若判断数组长度较长，则会进一步判断数组元素类型：
- 数组元素为基本类型则选择快速排序，不需要考虑排序稳定性
- 数组元素为自定义类则选择归并排序，为了排序稳定性
若判断数组长度较短，即样本量很低时，会选择插入排序，小样本下插入排序的O(N2)影响不大，但是插入排序的常数项很小，小样本量下排序很快。
比较器
自定义类在调用系统中排序时，如果不加入比较器，会按照对象在内存中的地址进行排序。我们在调用系统提供给的排序方法时，需要构造自定义比较器。
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;
}
}
//比较器
//返回负数，则第一个参数放在前面(说明第一个参数小)--升序--记住一个就行
//返回0，两个参数相等
//返回正数，则第一个参数放在后面(说明第一个参数大)--降序
public static class IdAscendingComparator implements Comparator<Student> {
@Override
public int compare(Student o1, Student o2) {
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", 2, 21);
Student student3 = new Student("C", 3, 22);
Student[] students = new Student[] { student3, student2, student1 };
printStudents(students);
Arrays.sort(students, new IdAscendingComparator());
printStudents(students);
Arrays.sort(students, new IdDescendingComparator());
printStudents(students);
Arrays.sort(students, new AgeAscendingComparator());
printStudents(students);
Arrays.sort(students, new AgeDescendingComparator());
printStudents(students);
}
}
对数器
- 一个我们想测的方法a
- 实现一个绝对正确但是时间复杂度不好的方法b
- 实现一个样本随机发生器
- 实现比对的方法
- 如果有一个样本使得比对出错，打印出该样本
- 当样本数量很多比对测试依然正确，可以确定方法a正确
随机数组发生器
public static int[] genetrateRandomArray(int size,int value) {
//生成长度随机在范围为[0,size]的数组
int[] arr = new int[(int)((size+1)*Math.random())];
for(int i=0;i<arr.length;i++) {
//生成随机数值
arr[i]=(int)((int)(value+1)*Math.random()-(int)(value-1*Math.random()));
}
return arr;
}
- Math.random() ->double[0,1}
- (int)((size+1)*Math.random())->[0,size]整数
- size=6，size+1=7
- Math.random()->[0,1}*7–>[0,7}double
- double[0,7}->int[0,6]
因此产生[0,size]长度的数组
绝对正确的方法
public static void rightMethod(int[] arr) {
//调用系统提供的排序
//虽然时间复杂度差，但是绝对正确
Arrays.sort(arr);
}
比对
public static boolean isEqual(int[] arr1,int[] arr2) {
if((arr1==null && arr1!=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 main(String[] args) {
//测试次数
int testTime=5000;
int size=10;
int value=500;
int[] arr2 = null;
int[] arr3 = null;
boolean succeed = true;
for(int i=0;i<testTime;i++) {
int arr1[] = genetrateRandomArray(size, value);
//拷贝数组
System.arraycopy(arr1, 0,arr2,0,arr1.length);
System.arraycopy(arr1, 0,arr3,0,arr1.length);
//方法执行
BubbleSort(arr1);
rightMethod(arr2);
if(!isEqual(arr1, arr2)) {
succeed=false;
//测试比对出错，打印出错误样本
for(int j=0;j<arr3.length;j++) {
System.out.println(arr3[i]);
}
break;
}
System.out.println(succeed ?"succeed" :"error");
}
}
扫一扫
825
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
