class1 排序（左程云左神算法 初级笔记 2018）
class1
DAY1
-
排序
//交换数组中两元素位置 public static void swap(int[] arr, int i, int j){ if(i == j) return; //防止&a，&b指向同一个地址；那样结果会错误,导致结果为0。 arr[i] = arr[i] ^ arr[j]; //使用异或交换数组的两个数，速度快 arr[j] = arr[i] ^ arr[j]; arr[i] = arr[i] ^ arr[j]; // int swap = arr[i]; // arr[i] = arr[j]; // arr[j] = swap; }- 冒泡排序 – 时间复杂度O(N^2)，额外空间复杂度O(1)
public static int[] bubbleSort(int[] arr){ if (arr == null || arr.length<2){ return arr; } 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); } } } return arr; }- 选择排序 – 时间复杂度O(N^2)，额外空间复杂度O(1)
public static int[] selectionSort(int[] arr){ if (arr == null || arr.length<2){ return arr; } for(int i = 0;i<arr.length-1;i++) { int minIndex = i; for (int j = i + 1; j < arr.length; j++) { minIndex = arr[j] < arr[minIndex] ? j : minIndex; } swap(arr, i, minIndex); } return arr; }- 插入排序的细节讲解与复杂度分析 – 时间复杂度O(N^2)，额外空间复杂度O(1)
public static int[] insertionSort(int[] arr){ if (arr == null || arr.length<2){ return arr; } 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); } } return arr; } -
对数器的概念和使用
0、有一个你想要测的方法a，
1、实现一个绝对正确但是复杂度不好的方法b，
2、实现一个随机样本产生器
3、实现比对的方法
4、把方法a和方法b比对很多次来验证方法a是否正确。
5、如果有一个样本使得比对出错，打印样本分析是哪个方法出错
6、当样本数量很多时比对测试依然正确，可以确定方法a已经正确- 在笔试前，应该准备模板：二叉树的随机样本发生器，数组的随机样本发生器…
- 堆，排序等很多东西都要准备模板！！！
import java.util.Arrays;
public class Test {
public static void bubbleSort(int[] arr) {
if (arr == null || arr.length < 2) {
return;
}
for (int e = arr.length-1; e > 0; e--) {
for (int i = 0; i < e; i++) {
if (arr[i] > arr[i + 1]) {
swap(arr, i, i + 1);
}
}
}
}
public static void swap(int[] arr, int i, int j) {
arr[i] = arr[i] ^ arr[j];
arr[j] = arr[i] ^ arr[j];
arr[i] = arr[i] ^ arr[j];
}
// 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())]; //随机数组的大小为[0-maxSize]
for (int i = 0; i < arr.length; i++) {
arr[i] = (int) ((maxValue + 1) * Math.random()) - (int) (maxValue * Math.random()); //给随机数组加入随机元素，元素范围[-maxValue-maxValue]
}
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 = arr1; //引用传递，导致结果肯定两数组是同一个对象
int[] arr2 = copyArray(arr1);
bubbleSort(arr1);
comparator(arr2);
if (!isEqual(arr1, arr2)) {
succeed = false;
break;
}
}
System.out.println(succeed ? "Nice!" : "Fucking fucked!");
int[] arr = generateRandomArray(maxSize, maxValue);
printArray(arr);
bubbleSort(arr);
printArray(arr);
}
}DAY2
-
剖析递归行为和递归行为时间复杂度的估算
-
master公式的使用：T(N) = a*T(N/b) + O(N^d)
其中：N为父问题的样本量，N/b为子过程样本量，a为子过程发生次数，O(N^d) 为剩余过程的时间复杂度
-
则复杂度计算方法为：
- log(b,a) > d -> 复杂度为O(N^log(b,a))
- log(b,a) = d -> 复杂度为O(N^d * logN)
- log(b,a) < d -> 复杂度为O(N^d)
注：要想使用master公司，子过程规模必须一样!
-
-
归并排序 – 时间复杂度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; } int mid = L + ((R-L) >> 1); //相当于(L+R)/2（L+R可能会溢出，不安全） mergeSort(arr,L,mid); //T(N/2) mergeSort(arr,mid+1,R); //T(N/2) merge(arr,L,mid,R); //O(N) //复杂度：T(N) = 2 T(N/2) + O(N) } public static void merge(int[] arr,int L,int M,int R){ int[] temp = new int[R-L+1]; int i = 0; int p1 = L; int p2 = M+1; while(p1<=M && p2<=R){ temp[i++] = arr[p1] < arr[p2] ? arr[p1++] : arr[p2++]; } //只有一个越界 while(p1 <= M){ temp[i++] = arr[p1++]; } while(p2 <= R){ temp[i++] = arr[p2++]; } for(i =0;i<temp.length;i++){ arr[L+i] = temp[i]; } } -
小和问题 – 在一个数组中，每一个数左边比当前数小的数累加起来，叫做这个数组的小和。
求一个数组的小和
package com.godzuo.java;
import java.util.Arrays;
/**
* @author quanquan
* @create 2020-04-19-15:31
*/
public class SmallSum {
public static int SmallSum(int[] arr){
if (arr == null || arr.length<2){
return 0;
}
return mergeSort(arr,0,arr.length-1);
}
public static int mergeSort(int[] arr,int L,int R){
if(L == R) {
return 0;
}
int mid = L + ((R-L) >> 1); //相当于(L+R)/2（L+R可能会溢出，不安全）
return mergeSort(arr,L,mid) + mergeSort(arr,mid+1,R) + merge(arr,L,mid,R); //O(N)
//复杂度：T(N) = 2 T(N/2) + O(N)
}
public static int merge(int[] arr,int L,int M,int R){
int[] temp = new int[R-L+1];
int i = 0;
int p1 = L;
int p2 = M+1;
int res = 0;
while(p1<=M && p2<=R){
res += arr[p1] < arr[p2] ? (R - p2 + 1) * arr[p1] : 0;
temp[i++] = arr[p1] < arr[p2] ? arr[p1++] : arr[p2++];
}
//只有一个越界
while(p1 <= M){
temp[i++] = arr[p1++];
}
while(p2 <= R){
temp[i++] = arr[p2++];
}
// 将临时数组temp拷贝给arr
for(i =0;i<temp.length;i++){
arr[L+i] = temp[i];
}
return res;
}
public static void main(String[] args) {
int[] arr = {2,8,6,7,5,3,9};
System.out.println(SmallSum(arr));
System.out.println(Arrays.toString(arr));
}
}- 逆序对问题 – 在一个数组中，左边的数如果比右边的数大，则折两个数构成一个逆序对，请打印所有逆序
对
package com.godzuo.java;
/**
* @author quanquan
* @create 2020-04-19-16:25
*/
public class InversePair {
public static void InversePair(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)/2（L+R可能会溢出，不安全）
mergeSort(arr,L,mid); //T(N/2)
mergeSort(arr,mid+1,R); //T(N/2)
merge(arr,L,mid,R); //O(N)
//复杂度：T(N) = 2 T(N/2) + O(N)
}
public static void merge(int[] arr,int L,int M,int R){
int[] temp = new int[R-L+1];
int i = 0;
int p1 = L;
int p2 = M+1;
while(p1<=M && p2<=R){
for(int j=0;j+p2<=R;j++){
System.out.print(arr[p1] > arr[p2] ? "("+arr[p1]+","+arr[p2+j]+")" : "");
}
temp[i++] = arr[p1] > arr[p2] ? arr[p1++] : arr[p2++];
}
//只有一个越界
while(p1 <= M){
temp[i++] = arr[p1++];
}
while(p2 <= R){
temp[i++] = arr[p2++];
}
for(i =0;i<temp.length;i++){
arr[L+i] = temp[i];
}
}
public static void main(String[] args) {
int[] arr = {4,5,8,3,2,1};
InversePair(arr);
}
}