注:此博客不再更新,所有最新文章将发表在个人独立博客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)
这里写代码片
② 桶排序之基数排序
这里写代码片
待更新…