参考文章

快速排序

public class Solution {private static int partition(int[] arr, int left, int right) {int temp = arr[left];	// 1while(left < right) {while(left < right && temp <= arr[right]) right--;arr[left] = arr[right];	// 2while(left < right && temp >= arr[left]) left++;arr[right] = arr[left];	// 3}arr[left] = temp;	// 4return left;}private static void quicSort(int[] arr, int left, int right) {if(left<right) {int mid = partition(arr, left, right);quicSort(arr,left, mid-1);quicSort(arr,mid+1, right);}}public static void main(String[] args) {int[] arr = {3,5,1,32,8,5,3,0};quicSort(arr, 0, arr.length-1);Arrays.stream(arr).forEach((n)->{System.out.print(n + " ");});}
}

• 时间复杂度O($nlogn$)：快排使用的是递归，需要做logn次分割，而每次划分需要找对应的基准元素，需要O(n)时间。
• 空间复杂度O($logn$)：平均情况下，递归树的高度为logn。

归并排序

public class Solution {// 主要是这里，对于两个有序数组合并，是挺简单的。// 如何把它拆分出来是一个问题。private static int[] mergeSort(int[] arr, int left, int right) {if(left == right) { //长度为1，直接放回return new int[]{arr[left]};}int mid = ((right - left) >> 1 ) + left;int[] l = mergeSort(arr, left, mid);int[] r = mergeSort(arr, mid+1, right);return mergeTwoArray(l,r);}// 归并思想挺简单的，如下private static int[] mergeTwoArray(int[] l, int[] r) {int[] res = new int[l.length+r.length];int left = 0, right = 0, index = 0;while(left < l.length && right < r.length) {if(l[left] < r[right]) {res[index++] = l[left++];}else {res[index++] = r[right++];}}while(left < l.length) {res[index++] = l[left++];}while(right < r.length) {res[index++] = r[right++];}return res;}public static void main(String[] args) {int[] arr = {3,5,1,32,8,5,3,0};int[] res = mergeSort(arr, 0, arr.length-1);    // 注意这里不是原地排序的，是新开辟一个空间Arrays.stream(res).forEach((n)->{System.out.print(n + " ");});}
}

• 时间复杂度O($nlogn$)：无论原始数组的顺序如何，归并排序都需要将数组不断地分成两半，然后再合并，总共需要进行logn
  层的划分和合并操作，每层操作都需要遍历 O(n)个元素。

• 空间复杂度O($n$)：需要额外的辅助数组。

Dijkstra

package com.zy;import java.util.Arrays;public class Solution {private static final int INF = Integer.MAX_VALUE;public static int[] dijkstra(int[][] graph, int src) {int n = graph.length;int[] dist = new int[n];boolean[] sptSet = new boolean[n];//初始化距离数组和最短路径集合Arrays.fill(dist, INF);dist[src] = 0;// 每次循环找到距离src最近的一个节点，总共循环n-1次for (int count = 0; count < n - 1; count++) {//找到最近节点uint u = minDistance(dist, sptSet);sptSet[u] = true;// 加入u后，各个节点的变化for (int v = 0; v < n; v++) {// 要是还没处理，且u和v是可达的，且刚刚更新的最近节点u不是不可达的，且更新后的距离更短if (!sptSet[v] && graph[u][v] != 0 && dist[u] != INF && dist[u] + graph[u][v] < dist[v]) {dist[v] = dist[u] + graph[u][v];}}}return dist;}private static int minDistance(int[] dist, boolean[] sptSet) {int min = INF, minIndex = -1;for (int v = 0; v < dist.length; v++) {if (!sptSet[v] && dist[v] <= min) {min = dist[v];minIndex = v;}}return minIndex;}public static void main(String[] args) {int[][] graph = {{0, 4, 0, 0, 0, 0, 0, 8, 0},{4, 0, 8, 0, 0, 0, 0, 11, 0},{0, 8, 0, 7, 0, 4, 0, 0, 2},{0, 0, 7, 0, 9, 14, 0, 0, 0},{0, 0, 0, 9, 0, 10, 0, 0, 0},{0, 0, 4, 14, 10, 0, 2, 0, 0},{0, 0, 0, 0, 0, 2, 0, 1, 6},{8, 11, 0, 0, 0, 0, 1, 0, 7},{0, 0, 2, 0, 0, 0, 6, 7, 0}};int src = 0;int[] dist = dijkstra(graph, src);System.out.println("从顶点 " + src + " 到各顶点的最短距离为：");for (int i = 0; i < dist.length; i++) {System.out.println("到顶点 " + i + " 的最短距离是：" + dist[i]);}}
}

• 时间复杂度O($n^2$)：由于使用了邻接矩阵存储图，每次查找距离源点最近的顶点需要遍历所有顶点，更新距离也需要遍历所有顶点。
• 空间复杂度O($n$)：主要使用了 dist 数组和 sptSet 数组来存储距离和标记顶点是否已处理

自定义排序

思考Comparator和Comparable的区别

实现Comparator接口实现。

package com.zy;import java.util.Arrays;
import java.util.Comparator;class Student implements Comparable<Student>{int age;int score;public Student(int age, int score) {this.age = age;this.score = score;}@Overridepublic int compareTo(Student o) {if(this.age != o.age) {return this.age - o.age;}return o.score - this.score;}
}public class Solution {public static void main(String[] args) {Student[] stu = new Student[3];stu[0] = new Student(10,13);stu[1] = new Student(5, 4);stu[2] = new Student(5,33);// 法1Arrays.sort(stu, new Comparator<Student>() {@Overridepublic int compare(Student o1, Student o2) {if(o1.age != o2.age) {return o1.age - o2.age;}return o2.score - o1.score;}});// 法2Arrays.sort(stu, (o1,o2)-> {if(o1.age != o2.age) {return o1.age - o2.age;}return o2.score - o1.score;});// 法3(用Comparable实现默认排序)Arrays.sort(stu);Arrays.stream(stu).forEach(student -> {System.out.println(student.age + " " + student.score);});}
}

交替打印奇偶数

package com.zy;class AlterPrint {private static final Object lock = new Object();private static final int MAX = 200;private static int count = 0;// 打印，唤醒，看有没有终止，有就结束，没有就等待void printNumber() {synchronized (lock) {while(true) {System.out.println(Thread.currentThread().getName() + "打印" + count++);lock.notify();if(count>=MAX) {lock.notifyAll(); //在彻底退出之前，最好都唤醒，不然某些线程会一直等待。break;}try {lock.wait();}catch (InterruptedException e) {e.printStackTrace();}}}}}public class Solution {public static void main(String[] args) {// 实现两个线程交替打印奇偶AlterPrint alterPrint = new AlterPrint();Thread thread0 = new Thread(alterPrint::printNumber, "线程1");Thread thread1 = new Thread(alterPrint::printNumber, "线程2");thread0.start();thread1.start();}}

冒泡排序

public class Solution {private static void swap(int[] arr, int i, int j) {int temp = arr[i];arr[i] = arr[j];arr[j] = temp;}private static void bubbleSort(int[] arr) {for(int i=0;i<arr.length;i++) {boolean flag = true;for(int j=arr.length-1;j>i;j--) {if(arr[j-1] > arr[j]) {swap(arr, j-1, j);flag = false;}}if(flag) break;}}public static void main(String[] args) {int[] arr = {3,4,6,8,3,1,0,22,10};bubbleSort(arr);for(int i : arr) {System.out.println(i);}}}

插入排序

public class Solution {private static void InsertSort(int[] arr) {for(int i=1;i<arr.length;i++) {int key = arr[i];   // 要排序的数字int j = i-1;    // 从有序数组的尾部开始比较while(j >= 0 && arr[j] > key) {arr[j + 1] = arr[j];j = j - 1;}arr[j + 1] = key;}}public static void main(String[] args) {int[] arr = {3,4,6,8,3,1,0,22,10};InsertSort(arr);for(int i : arr) {System.out.println(i);}}
}

堆排序

package com.zy;import java.util.Scanner;public class Main {// 调整有效大小为n的堆中的i节点private static void adjust(int[] nums, int n, int i) {int largest = i;int left = 2 * i + 1;int right = 2 * i + 2;// 找左右节点跟节点i中最大的节点索引 ： largestif(left < n && nums[left] > nums[largest]) {largest = left;}if(right < n && nums[right] > nums[largest]) {largest = right;}if(largest != i) {  // 如果节点i需要往下调整// 跟最大的节点替换后int tmp = nums[i];nums[i] = nums[largest];nums[largest] = tmp;// 接着继续向下调整adjust(nums,n,largest);}}private static void heapSort(int[] arr) {int n = arr.length;// 调整数组，使得父节点>子节点，从最后一个非叶子节点开始for(int i=n/2-1;i>=0;i--) {     // 自己小推一下就知道了adjust(arr, n, i);}// i*2-1for(int i=n-1;i>0;i--) {// 当前父节点移动到末尾（这里他就是排到正确位置了）int temp = arr[0];arr[0] = arr[i];arr[i] = temp;// 剩下部分继续调整adjust(arr, i, 0);}}public static void main(String[] args) {int[] arr = {3,1,2,5,7,4};heapSort(arr);for(int num : arr) {System.out.print(num + " ");}}
}

欧几里得算法求最大公约数

static int gcb(int a, int b) {if(b==0) return a;return gcb(b, a%b);
}

单例模式的双重校验

package com.zy;public class Singleton {private volatile static Singleton singletonInstance;private Singleton(){}public static Singleton getSingleton(){if(singletonInstance == null) {synchronized (Singleton.class) {if(singletonInstance == null) {singletonInstance = new Singleton();}}}return singletonInstance;}
}

LRU