注：此博客不再更新，所有最新文章将发表在个人独立博客limengting.site。分享技术，记录生活，欢迎大家关注
关于排序算法可以查看这篇新的总结：
https://limengting.site/2018/10/20/排序算法总结/
（1）冒泡排序：
算法描述：从头开始，两两交换，大的沉底，每轮确定一个最大的数，每轮逐渐缩小范围end- -，直到end = 1，即只有两个数
时间复杂度：O(n²)
空间复杂度：O(1)
稳定性：可以做到稳定的，遇到相等的后面的代替前面的沉底
package sword_to_offer_sort;
import java.util.Scanner;
public class BubbleSort {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
while (sc.hasNext()) {
int n = sc.nextInt();
int[] arr = new int[n];
for (int i = 0; i < n; i++) {
arr[i] = sc.nextInt();
}
bubbleSort(arr);
printArray(arr);
}
sc.close();
}
private static void printArray(int[] arr) {
for (int i = 0; i < arr.length - 1; i ++) {
System.out.print(arr[i] + " ");
}
System.out.print(arr[arr.length - 1]);
}
private static void bubbleSort(int[] arr) {
if (arr == null || arr.length < 2) return;
for (int end = arr.length - 1; end >= 1; end --) {
for (int i = 0; i <= end - 1; i ++) {
if (arr[i] > arr[i + 1])
swap(arr, i, i + 1);
}
}
}
private static void swap(int[] arr, int i, int j) {
int tmp = arr[i];
arr[i] = arr[j];
arr[j] = tmp;
}
}
（2）选择排序：
算法描述：第一轮在0n-1上选出最小的，用minIndex记录，和0位置的数交换，第二轮在1n-1上选出最小的，和1位置的数交换…第n+1轮在n~n-1上选出最小的和n位置的数交换
时间复杂度：O(n²)
空间复杂度：O(1)
稳定性：无法实现稳定性，例如5,5,5,5,4,0,1，第一轮选出0和第一个5交换，第一个5本来在最前面但是通过交换跑到其他5后面去了
package sword_to_offer_sort;
import java.util.Scanner;
public class SelectionSort {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
while (scanner.hasNext()) {
int n = scanner.nextInt();
int[] arr = new int[n];
for (int i = 0; i < n; i ++) {
arr[i] = scanner.nextInt();
}
selectionSort(arr);
printArray(arr);
}
scanner.close();
}
private static void printArray(int[] arr) {
for (int i = 0; i < arr.length - 1; i ++) {
System.out.print(arr[i] + " ");
}
System.out.println(arr[arr.length - 1]);
}
private static void selectionSort(int[] arr) {
if (arr == null || arr.length < 2) return;
for (int start = 0; start < arr.length - 1; start ++) {
int minIndex = start;
for (int i = start; i < arr.length; i ++) {
minIndex = arr[i] < arr[minIndex] ? i : minIndex;
}
swap(arr, start, minIndex);
}
}
private static void swap(int[] arr, int i, int j) {
int tmp = arr[i];
arr[i] = arr[j];
arr[j] = tmp;
}
}
（3）插入排序：
算法描述：类比于斗地主新抓一张牌插牌，和每一张牌比较，手上这张牌如果比前一张牌小则换，一次次换。
时间复杂度：和数据状况有关，逆序时最坏O(n²)，已经排好序的最好O(n)
空间复杂度：O(1)
稳定性：可以实现稳定性，相等时不再往前插入即可
package sword_to_offer_sort;
import java.util.Scanner;
public class InsertionSort {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
while(scanner.hasNext()) {
int n = scanner.nextInt();
int[] arr = new int[n];
for (int i = 0; i < n; i ++) {
arr[i] = scanner.nextInt();
}
insertionSort(arr);
printArray(arr);
}
scanner.close();
}
private static void printArray(int[] arr) {
for (int i = 0; i < arr.length - 1; i ++) {
System.out.print(arr[i] + " ");
}
System.out.print(arr[arr.length - 1]);
}
private static void insertionSort(int[] arr) {
if (arr == null || arr.length < 2) return;
for (int i = 1; i < arr.length; i ++) {
// 待插进来的数是arr[j + 1]，若比前面的数小则和前面的数交换位置
for (int j = i - 1; j >= 0 && arr[j + 1] < arr[j]; j --) {
swap(arr, j, j + 1);
}
}
}
private static void swap(int[] arr, int i, int j) {
int tmp = arr[i];
arr[i] = arr[j];
arr[j] = tmp;
}
}
（4）归并排序 -> 小和问题，逆序对问题
算法描述：先以中点为界分治，然后申请一个helper[]数组，通过两个指针外排merge，谁小填谁，把helper填满后复制到原数组的相应位置
时间复杂度：O(n*logn)
① T(n) = 2T(n/2) + O(n)
利用master定理得出O(n*logn)
② merge一次O(n),分治的深度为logn，故logn次merge
空间复杂度：helper[]数组造成的O(n)
稳定性：可以实现稳定性，左右相等先把左边的填入helper[]即可
归并排序：
package sword_to_offer_sort;
import java.util.Scanner;
public class MergeSort {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
while (scanner.hasNext()) {
int n = scanner.nextInt();
int[] arr = new int[n];
for (int i = 0; i < n; i ++) {
arr[i] = scanner.nextInt();
}
mergeSort(arr);
printArray(arr);
}
}
private static void printArray(int[] arr) {
if (arr == null || arr.length < 1) return;
for (int i = 0; i < arr.length - 1; i ++) {
System.out.print(arr[i] + " ");
}
System.out.println(arr[arr.length - 1]);
}
private static void mergeSort(int[] arr) {
if (arr == null || arr.length < 2) return;
mergeSort(arr, 0, arr.length - 1);
}
private static void mergeSort(int[] arr, int l, int r) {
if (l < r) {
int mid = l + (r - l) / 2;
mergeSort(arr, l, mid);
mergeSort(arr, mid + 1, r);
merge(arr, l, mid, r);
}
}
private static void merge(int[] arr, int l, int mid, int r) {
int p1 = l, p2 = mid + 1;
int[] helper = new int[r - l + 1];
int i = 0;
while (p1 <= mid && p2 <= r) {
helper[i++] = arr[p1] <= arr[p2] ? arr[p1++] : arr[p2++];
}
while (p1 <= mid) {
helper[i++] = arr[p1++];
}
while (p2 <= r) {
helper[i++] = arr[p2++];
}
for (i = 0; i < helper.length; i ++) {
arr[l + i] = helper[i];
}
}
}
小和问题：
package sword_to_offer_sort;
import java.util.Scanner;
public class SmallSum {
public static void main1(String[] args) {
Scanner scanner = new Scanner(System.in);
while (scanner.hasNext()) {
int n = scanner.nextInt();
int[] arr = new int[n];
for (int i = 0; i < n; i ++) {
arr[i] = scanner.nextInt();
}
System.out.println(smallSum(arr));
}
scanner.close();
}
private static int smallSum(int[] arr) {
if (arr == null || arr.length < 2) return 0;
return mergeSort(arr, 0, arr.length - 1);
}
private static int mergeSort(int[] arr, int l, int r) {
int res = 0;
if (l < r) {
int mid = l + ((r - l) >> 1);
res = mergeSort(arr, l, mid) + mergeSort(arr, mid + 1, r) + merge(arr, l, mid, r);
}
return res;
}
private static int merge(int[] arr, int l, int mid, int r) {
int res = 0;
int i = 0;
int[] helper = new int[r - l + 1];
int p1 = l, p2 = mid + 1;
while (p1 <= mid && p2 <= r) {
// p1指的数小才有小和
res += arr[p1] < arr[p2] ? (r - p2 + 1) * arr[p1] : 0;
helper[i++] = arr[p1] < arr[p2] ? arr[p1++] : arr[p2++];
}
//p2越界
while (p1 <= mid) {
helper[i++] = arr[p1++];
}
//p1越界
while (p2 <= r) {
helper[i++] = arr[p2++];
}
for (i = 0; i < helper.length; i ++) {
arr[l + i] = helper[i];
}
return res;
}
// 对数器
// 1、实现一个绝对正确但是复杂度不好的方法b，即对数器
public static int comparator(int[] arr) {
int res = 0;
for (int i = 0; i < arr.length; i ++) {
for (int j = 0; j < i; j ++) {
if (arr[j] < arr[i])
res += arr[j];
}
}
return res;
}
// 2、实现一个随机样本产生器
public static int[] generateRandomArray(int maxSize, int maxValue) {
// 生成一个数组长度为[0, maxSize]的数组
// Math.random()得到[0,1)
// Math.random() * (maxSize + 1)得到[0, maxSize + 1)
// (int) (M(maxSize + 1) * Math.random())得到[0, maxSize]中的随机整数
int[] arr = new int[(int) ((maxSize + 1) * Math.random())];
for (int i = 0; i < arr.length; i++) {
// (int) ((maxValue + 1) * Math.random())得到[0, maxValue]中的随机整数
// - (int) ((maxValue + 1） * Math.random())得到[ - maxValue, 0]中的随机整数
// (int) ((maxValue + 1) * Math.random()) - (int) ((maxValue + 1)* Math.random())得到[-maxValue, maxValue]中的随机整数
arr[i] = (int) ((maxValue + 1) * Math.random()) - (int) ((maxValue + 1)* Math.random());
}
return arr;
}
// 3、将产生的随机数组拷贝成两份
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;
}
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 = 50;
int maxValue = 10;
boolean succeed = true;
for (int i = 0; i < testTime; i++) {
int[] arr1 = generateRandomArray(maxSize, maxValue);
int[] arr2 = copyArray(arr1);
int[] arr3 = copyArray(arr1);
if (smallSum(arr1) != comparator(arr2)) {
succeed = false;
System.out.println("Input array: ");
printArray(arr3);
System.out.println("My result: " + smallSum(arr1));
System.out.println("True result: " + comparator(arr2));
break;
}
}
System.out.println(succeed ? "Nice!" : "Fucking fucked!");
}
}
逆序对问题：
这里写代码片
（5）快速排序 -> partition函数 -> 荷兰国旗问题
算法描述：每次随机选一个数和最后一个数交换，把最后一个数拿出来作为划分点，每次将数组分成小于x等于x大于x三块（往左边边界和右边边界里发货，arr[cur] < arr[num] 则把现在的数和小于边界的下一个位置交换，cur++；=则直接cur++；>则把大于边界的前一个数和当前数交换再考察换过来的数是<,>还是=），再分别把左右拿去递归划分
时间复杂度：O(n*logn)
最好情况：分成两半，T(n) = 2T(n / 2) + O(n)，算出时间复杂度O(nlogn)
平均情况：设长度为n的数组的平均比较次数为C(n),则C(n) = n - 1 + 1 / n * (C(0) + C(n - 1) + C(1) + C(n - 2) + … + C(n - 1) + C(0))，算出收敛到O(nlogn)
空间复杂度：O(logn)
空间为记下的划分点，划分点层数为logn
稳定性：无法实现稳定性
随机快排：
package sword_to_offer_sort;
import java.util.Scanner;
public class QuickSort {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
while (scanner.hasNext()) {
int n = scanner.nextInt();
int[] arr = new int[n];
for (int i = 0; i < n; i++) {
arr[i] = scanner.nextInt();
}
quickSort(arr);
printArray(arr);
}
}
public static void quickSort(int[] arr) {
if (arr == null || arr.length < 2) return;
quickSort(arr, 0, arr.length - 1);
}
private static void quickSort(int[] arr, int l, int r) {
if (l < r) {
// randomIndex : [l, r + 1) = l + [0, r + 1 - l)
// 把randomIndex指向的数和最后一个数arr[r]交换，以arr[randomIndex]为切分标准
swap(arr, (int) (l + (r - l + 1) * Math.random()), r);
int[] equalRange = partition(arr, l, r);
quickSort(arr, l, equalRange[0] - 1);
quickSort(arr, equalRange[1] + 1, r);
}
}
private static int[] partition(int[] arr, int l, int r) {
int less = l - 1, more = r;
int cur = l;
while (cur < more) {
if (arr[cur] < arr[r]) {
swap(arr, cur++, ++less);
} else if (arr[cur] > arr[r]) {
swap(arr, cur, --more);
} else {
cur++;
}
}
swap(arr, cur, r);
return new int[] {less + 1, more - 1};
}
private static void printArray(int[] arr) {
if (arr == null || arr.length == 0) return;
for (int i = 0; i < arr.length - 1; i++) {
System.out.print(arr[i] + " ");
}
System.out.println(arr[arr.length - 1]);
}
private static void swap(int[] arr, int i, int j) {
int tmp = arr[i];
arr[i] = arr[j];
arr[j] = tmp;
}
}
荷兰国旗问题：
package sword_to_offer_sort;
import java.util.Scanner;
public class NetherlandsFlag {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
while (scanner.hasNext()) {
int n = scanner.nextInt();
int[] arr = new int[n];
for (int i = 0; i < n; i ++) {
arr[i] = scanner.nextInt();
}
int num = scanner.nextInt();
partition(arr, num);
printArray(arr);
}
}
private static void printArray(int[] arr) {
for (int i = 0; i < arr.length - 1; i ++) {
System.out.print(arr[i] + " ");
}
System.out.println(arr[arr.length - 1]);
}
private static void swap(int[] arr, int i, int j) {
int tmp = arr[i];
arr[i] = arr[j];
arr[j] = tmp;
}
private static void partition(int[] arr, int num) {
if (arr == null || arr.length < 2) return;
int less = -1, more = arr.length;
int cur = 0;
while (cur != more) {
if (arr[cur] < num) {
swap(arr, cur++, ++less);
} else if (arr[cur] > num) {
swap(arr, cur, --more);
} else {
cur++;
}
}
}
}
（6）堆排序 -> 快速得到中位数问题
堆是一棵完全二叉树，（应用层面上）称为优先队列
下标为i的左孩子的下标：2 * i + 1，右孩子下标：2 * i + 2,父节点下标：(i - 1) / 2，注意不能写成(i - 1) >> 1，当i为0，-1右移一位补全符号位后还是-1
建堆heapInsert(),把数组调成大根堆：从i=0开始一个个插入，每个节点插入完调整成大根堆（向上和父比较，比父大则交换）后再插下一个
节点上的某个值变小后要下沉heapify()：左右两个孩子中最大的若比我大则和我交换,向下调整
算法描述：建堆之后把头结点和最后一个节点交换，heapSize–,把堆调成大根堆，再把头结点和倒数第二个节点交换…
时间复杂度：O(n*logn)，建堆nlogn，heapify()的过程nlogn
空间复杂度：O(1)
稳定性：无法实现稳定性，建堆的过程就不稳定
堆排序：
package sword_to_offer_sort;
import java.util.Scanner;
public class HeapSort {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
while (scanner.hasNext()) {
int n = scanner.nextInt();
int[] arr = new int[n];
for (int i = 0; i < n; i++) {
arr[i] = scanner.nextInt();
}
heapSort(arr);
printArray(arr);
}
scanner.close();
}
private static void heapSort(int[] arr) {
if (arr == null || arr.length < 2) return;
// 建堆
for (int i = 0; i < arr.length; i++) {
heapInsert(arr, i);
}
int heapSize = arr.length;
swap(arr, 0, --heapSize);
while (heapSize > 0) {
heapify(arr, 0, heapSize);
swap(arr, 0, --heapSize);
}
}
private static void heapInsert(int[] arr, int index) {
while (arr[index] > arr[(index - 1) / 2]) {
swap(arr, index, (index - 1) / 2);
index = (index - 1) / 2;
}
}
private static void heapify(int[] arr, int index, int heapSize) {
int left = index * 2 + 1;
while (left < heapSize) {
int maxIndex = left + 1 < heapSize && arr[left + 1] > arr[left] ? left + 1 : left;
maxIndex = arr[maxIndex] > arr[index] ? maxIndex : index;
if (maxIndex == index) break;
swap(arr, index, maxIndex);
index = maxIndex;
left = index * 2 + 1;
}
}
private static void swap(int[] arr, int i, int j) {
int tmp = arr[i];
arr[i] = arr[j];
arr[j] = tmp;
}
private static void printArray(int[] arr) {
if (arr == null || arr.length < 1) return;
for (int i = 0; i < arr.length - 1; i++) {
System.out.print(arr[i] + " ");
}
System.out.print(arr[arr.length - 1]);
}
}
快速得到中位数问题：
这里写代码片
（7）工程中的综合排序算法
基础类型->快排
自定义的class->归并排序
分治的时候数据量小于60 -> 插排
（8）非基于比较的排序
非基于比较的排序与被排序的样本的实际数据状况很有关系，不常用
① 桶排序之计数排序
算法描述：
遍历，每个值的词频，再创建一个新的数组按照词频将原数组复原成一个已经排序的数组
时间复杂度：O(n)
空间复杂度：O(n)
这里写代码片
② 桶排序之基数排序
这里写代码片
待更新…
3691
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
