数据结构之排序算法
一.排序算法
就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。
1.比较类排序：通过比较来决定元素间的相对次序，由于其时间复杂度不能突破O(nlogn)，因此也称为非线性时间比较类排序。
选择排序、冒泡排序、插入排序、希尔排序、归并排序、堆排序、快速排序
2.非比较类排序：不通过比较来决定元素间的相对次序，它可以突破基于比较排序的时间下界，以线性时间运行，因此也称为线性时间非比较类排序。
计数排序、桶排序、基数排序
3.稳定：如果a原本在b前面，而a==b，排序之后a仍然在b的前面。
4.不稳定：如果a原本在b的前面，而a==b，排序之后 a 可能会出现在 b 的后面。
5.时间复杂度：对排序数据的总的操作次数。反映当n变化时，操作次数呈现什么规律。
6.空间复杂度：是指算法在计算机内执行时所需存储空间的度量，它也是数据规模n的函数。
二.十大排序
1.选择排序
选择排序(Selection-sort)是一种简单直观的排序算法。它的工作原理：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。
时间复杂度：O(n^2) 空间复杂度： O(1) 稳定性： 不稳定
2.冒泡排序
冒泡排序是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。
时间复杂度：O(n^2) 空间复杂度：O(1) 稳定性： 稳定
3.插入排序
插入排序（Insertion-Sort）的算法描述是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。
时间复杂度：O(n^2) 空间复杂度：O(1) 稳定性： 稳定
4.希尔排序
1959年Shell发明，第一个突破O(n^2)的排序算法，是简单插入排序的改进版。它与插入排序的不同之处在于，它会优先比较距离较远的元素。希尔排序又叫缩小增量排序。
时间复杂度：O(n^1.3) 空间复杂度：O(1) 稳定性： 不稳定
5.归并排序
归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为2路归并。
时间复杂度：O(nlogn) 空间复杂度：S(n) 稳定性： 稳定
6.堆排序
堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。
时间复杂度：O(nlog2n) 空间复杂度：O(1) 稳定性： 不稳定
7.快速排序
快速排序的基本思想：通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，比另一部分的关键字大，则可分别对这两部分记录继续进行排序，以达到整个序列有序。
时间复杂度：O(nlogn) 空间复杂度：O(1) 稳定性：不稳定
8.计数排序
计数排序不是基于比较的排序算法，其核心在于将输入的数据值转化为键存储在额外开辟的数组空间中。 作为一种线性时间复杂度的排序，计数排序要求输入的数据必须是有确定范围的整数。
时间复杂度：O(n+m) 空间复杂度：O(n+m) 稳定性：稳定
9.桶排序
桶排序是计数排序的升级版。它利用了函数的映射关系，高效与否的关键就在于这个映射函数的确定。桶排序 (Bucket sort)的工作的原理：假设输入数据服从均匀分布，将数据分到有限数量的桶里，每个桶再分别排序（有可能再使用别的排序算法或是以递归方式继续使用桶排序进行排）。
时间复杂度：O(n+m) 空间复杂度：O(n+m) 稳定性：稳定
10.基数排序
基数排序是按照低位先排序，然后收集；再按照高位排序，然后再收集；依次类推，直到最高位。有时候有些属性是有优先级顺序的，先按低优先级排序，再按高优先级排序。最后的次序就是高优先级高的在前，高优先级相同的低优先级高的在前。
时间复杂度：O(n+m) 空间复杂度：O(n+m) 稳定性：稳定
三.代码
1.Test
package p5.排序算法;
/*
算法的执行时间
除了跟算法的策略有关系之外
还跟数据分布情况有关系
数据分布情况：
完全随机 大致有序 大致平稳
选择 5 5 4
冒泡 4 4 5
插入 3 1 3
希尔 2 3 2
归并 1 2 1
单快 1+ 3+ 1+
双快 1+ 1+ 1+
三快 n n n
基排 3- 4 3-
桶排序 4+ 3- 4+
*/
public class TestSort {
public static void main(String[] args) {
ArrayData data = new ArrayData(0);
int[] arr = data.makeData();
test01(arr);
test02(arr);
test03(arr);
test04(arr);
test05(arr);
test06(arr);
test07(arr);
test08(arr);
test09(arr);
test10(arr);
}
private static void test10(int[] arr) {
BucketSort bucketSort = new BucketSort(arr);
Long start = System.currentTimeMillis();
bucketSort.sort();
Long end = System.currentTimeMillis();
System.out.println("桶排序：" + (end - start) + "ms");
}
private static void test09(int[] arr) {
RadixSort radixSort = new RadixSort(arr);
Long start = System.currentTimeMillis();
radixSort.sort();
Long end = System.currentTimeMillis();
System.out.println("基数排序：" + (end - start) + "ms");
}
private static void test08(int[] arr) {
QuickSort03 quickSort03 = new QuickSort03(arr);
Long start = System.currentTimeMillis();
quickSort03.sort();
Long end = System.currentTimeMillis();
System.out.println("三路快排：" + (end - start) + "ms");
}
private static void test07(int[] arr) {
QuickSort02 quickSort02 = new QuickSort02(arr);
Long start = System.currentTimeMillis();
quickSort02.sort();
Long end = System.currentTimeMillis();
System.out.println("双路快排：" + (end - start) + "ms");
}
private static void test06(int[] arr) {
QuickSort01 quickSort01 = new QuickSort01(arr);
Long start = System.currentTimeMillis();
quickSort01.sort();
Long end = System.currentTimeMillis();
System.out.println("单路快排：" + (end - start) + "ms");
}
private static void test05(int[] arr) {
MergeSort mergeSort = new MergeSort(arr);
Long start = System.currentTimeMillis();
mergeSort.sort();
Long end = System.currentTimeMillis();
System.out.println("归并排序：" + (end - start) + "ms");
}
private static void test04(int[] arr) {
ShellSort shellSort = new ShellSort(arr);
Long start = System.currentTimeMillis();
shellSort.sort();
Long end = System.currentTimeMillis();
System.out.println("希尔排序：" + (end - start) + "ms");
}
private static void test03(int[] arr) {
InsertionSort insertionSort = new InsertionSort(arr);
Long start = System.currentTimeMillis();
insertionSort.sort();
Long end = System.currentTimeMillis();
System.out.println("插入排序：" + (end - start) + "ms");
}
private static void test02(int[] arr) {
BubbleSort bubbleSort = new BubbleSort(arr);
Long start = System.currentTimeMillis();
bubbleSort.sort();
Long end = System.currentTimeMillis();
System.out.println("冒泡排序: " + (end - start) + "ms");
}
private static void test01(int[] arr) {
SelectionSort selectionSort = new SelectionSort(arr);
Long start = System.currentTimeMillis();
selectionSort.sort();
Long end = System.currentTimeMillis();
System.out.println("选择排序: " + (end - start) + "ms");
}
}
2.ArrayData
package p5.排序算法;
import java.util.Random;
public class ArrayData {
//产生数据 完全随机0 大致有序1 大致平稳2
private int type;
private Random random = new Random();
private int[] arr = new int[10000];
public ArrayData(int type) {
this.type = type;
}
public int[] makeData() {
if (type == 0) {
for (int i = 0; i < arr.length; i++) {
arr[i] = random.nextInt(10000);
}
} else if (type == 1) {
for (int i = 0; i < arr.length; i++) {
arr[i] = (i + 1) * 100 + random.nextInt(300);
}
} else {
for (int i = 0; i < arr.length; i++) {
arr[i] = 5000 + (i % 2 == 0 ? random.nextInt(500) : -random.nextInt(500));
}
}
return arr;
}
}3.Sort
package p5.排序算法;
public abstract class Sort {
public int[] arr;
public Sort(){}
public Sort(int[] arr) {
this.arr = new int[arr.length];
for (int i = 0; i < arr.length; i++) {
this.arr[i] = arr[i];
}
}
public abstract void sort();
public void swap(int i, int j) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
4.选择排序
package p5.排序算法;
//选择排序 O(n^2) S(1) 不稳定
public class SelectionSort extends Sort{
public SelectionSort(int[] arr) {
super(arr);
}
@Override
public void sort() {
for (int i = 0; i < arr.length - 1; i++) {
for (int j = i + 1; j < arr.length; j++) {
if (arr[i] > arr[j]) {
swap(i,j);
}
}
}
}
}5.冒泡排序
package p5.排序算法;
//冒泡排序 O(n^2) S(1) 稳定
public class BubbleSort extends Sort{
public BubbleSort(int[] arr) {
super(arr);
}
@Override
public void sort() {
for (int i = 0; i < arr.length - 1; i++) {
for (int j = 0; j < arr.length - i - 1; j++) {
if (arr[j] < arr[j + 1]) {
swap(j,j + 1);
}
}
}
}
}
6.插入排序
package p5.排序算法;
//插入排序 O(n^2) S(1) 稳定
public class InsertionSort extends Sort{
public InsertionSort(int[] arr) {
super(arr);
}
@Override
public void sort() {
for (int i = 0; i < arr.length; i++) {
int e = arr[i];
int j = 0;
for (j = i; j > 0 && arr[j - 1] > e; j--) {
arr[j] = arr[j - 1];
}
arr[j] = e;
}
}
}
7.希尔排序
package p5.排序算法;
//希尔排序 O(n^1.3) S(1) 不稳定
public class ShellSort extends Sort{
public ShellSort (int[] arr) {
super(arr);
}
@Override
public void sort() {
int len = arr.length;
for (int gap = len / 2; gap > 0; gap = gap / 2) {
for (int i = gap; i < len; i++) {
int e = arr[i];
int j = i;
while (j - gap >= 0 && arr[j - gap] > e) {
arr[j] = arr[j - gap];
j = j - gap;
}
arr[j] = e;
}
}
}
}
8.归并排序
package p5.排序算法;
//归并排序 O(nlogn) S(n) 稳定
public class MergeSort extends Sort{
public MergeSort(int[] arr) {
super(arr);
}
@Override
public void sort() {
mergeSort(0, arr.length - 1);
}
private void mergeSort(int L, int R) {
if (L >= R) {
return;
}
int mid = (L + R) / 2;
//递归排序当前层级的左边
mergeSort(L, mid);
//递归排序当前层级的右边
mergeSort(mid + 1, R);
//左边排序完了 右边排序也完了
//将左右进行合并
//特殊 如果左边的最大值arr[mid]小于等于右边的最小值arr[mid+1] 则不需要合并
if (arr[mid] > arr[mid + 1]) {
merge(L, mid, R);
}
}
private void merge(int L, int mid, int R) {
int[] aux = new int[R - L + 1];
//复制当前层级中 原数组的内容给aux
for (int k = L; k <= R; k++) {
aux[k - L] = arr[k];
}
int i = L;
int j = mid + 1;
for (int k = L; k <= R; k++) {
if (i > mid) { //左边完毕
arr[k] = aux[j - L];
j++;
} else if (j > R) { //右边完毕
arr[k] = aux[i - L];
i++;
} else if (aux[i - L] < aux[j - L]) {
arr[k] = aux[i - L];
i++;
} else {
arr[k] = aux[j - L];
j++;
}
}
}
}
9.单路快速排序
package p5.排序算法;
import java.security.PublicKey;
//单路快速排序
public class QuickSort01 extends Sort{
public QuickSort01(int[] arr) {
super(arr);
}
@Override
public void sort() {
quickSort(0, arr.length - 1);
}
private void quickSort(int L, int R) {
if (L >= R) {
return;
}
//先对数组进行划分 并返回划分后的中点
int p = partition(L, R);
quickSort(L, p - 1);
quickSort(p + 1, R);
}
private int partition(int L, int R) {
//优化一下 随机让后面的数字和第一个数字换一下
//尽量避免极端情况
swap(L, (int) (Math.random() * (R - L + 1) + L));
int v = arr[L];
//arr[l+1 ~ j] < v < arr[j+1 ~ i)
int j = L;
for (int i = L + 1; i <= R; i++) {
if (arr[i] < v) {
swap(j + 1, i);
j++;
}
}
swap(L, j);
return j;
}
}
10.双路快速排序
package p5.排序算法;
//双路快速排序
public class QuickSort02 extends Sort{
public QuickSort02(int[] arr) {
super(arr);
}
@Override
public void sort() {
quickSort(0, arr.length - 1);
}
private void quickSort(int L, int R) {
if (L >= R) {
return;
}
//对数组进行划分 并返回划分后的中点
int p = partition(L, R);
quickSort(L,p - 1);
quickSort(p + 1, R);
}
private int partition(int L, int R) {
//优化一下 随机让后面的数字和第一个数字换一下
//尽量避免极端情况（升序情况）
swap(L, (int) (Math.random() * (R - L + 1) + L));
int v = arr[L];
int i = L + 1;
int j = R;
while (true) {
while (i <= R && arr[i] < v) {
i++;
}
while (j >= L + 1 && arr[j] > v) {
j--;
}
if (i > j) {
break;
}
swap(i, j);
i++;
j--;
}
swap(L, j);
return j;
}
}
11.三路快速排序
package p5.排序算法;
//三路快速排序
public class QuickSort03 extends Sort {
public QuickSort03(int[] arr) {
super(arr);
}
@Override
public void sort() {
quickSort(0, arr.length - 1);
}
private void quickSort(int L, int R) {
if (L >= R) {
return;
}
swap(L, (int) (Math.random() * (R - L + 1) + L));
int v = arr[L];
int lt = L;
int gt = R + 1;
int i = L + 1;
while (i < gt) {
if (arr[i] < v) {
swap(i, lt + 1);
lt++;
i++;
} else if (arr[i] > v) {
swap(i, gt - 1);
gt--;
} else {
i++;
}
}
swap(L, lt);
quickSort(L,lt - 1);
quickSort(gt, R);
}
}
12.桶排序
package p5.排序算法;
import java.util.ArrayList;
import java.util.Comparator;
//桶排序
public class BucketSort extends Sort {
public BucketSort(int[] arr) {
super(arr);
}
@Override
public void sort() {
//1.找到最大值和最小值
int max = arr[0];
int min = arr[0];
for (int i = 1; i < arr.length; i++) {
if (arr[i] > max) {
max = arr[i];
}
if (arr[i] < min) {
min = arr[i];
}
}
//2.确定桶的个数并创建桶
int bucketNum = (max - min) / arr.length + 1;
ArrayList list[] = new ArrayList[bucketNum];
for (int i = 0; i < list.length; i++) {
list[i] = new ArrayList<>();
}
//3.遍历源数据 将数据进行分类处理
for (int i = 0; i < arr.length; i++) {
list[(arr[i] - min) / arr.length].add(arr[i]);
}
//4.对每一个桶进行排序
for (int i = 0; i < list.length; i++) {
list[i].sort(new Comparator() {
@Override
public int compare(Integer o1, Integer o2) {
return o1 -o2;
}
});
// System.out.println("第" + (i+1) + "个桶:" + list[i].toString());
}
//5.将所有桶中的数据依次返回到原数组中即可
int index = 0; //原数组的角标
for (int i = 0; i < list.length; i++) {
for (int j = 0; j < list[i].size(); j++) {
arr[index++] = list[i].get(j);
}
}
// System.out.println(Arrays.toString(arr));
}
}
13.基数排序
package p5.排序算法;
import java.util.LinkedList;
//基数排序
public class RadixSort extends Sort {
public RadixSort(int[] arr) {
super(arr);
}
@Override
public void sort() {
//1.找 分类-收集 的轮数（最大值的长度）
int radix = getRadix();
//2.创建桶 list所有桶的集合 每一个桶是LinkedList当成队列来用
LinkedList[] list = new LinkedList[10];
for (int i = 0; i < list.length; i++) {
list[i] = new LinkedList<>();
}
//3.开始 分类-收集
for (int r = 1; r <= radix; r++) {
//分类过程
for (int i = 0; i < arr.length; i++) {
list[getIndex(arr[i], r)].offer(arr[i]);
}
int index = 0; //遍历arr原数组
//收集的过程
for (int i = 0; i < list.length; i++) {
while (!list[i].isEmpty()) {
arr[index++] = list[i].poll();
}
}
}
}
private int getIndex(int num, int r) {
int ret = 0;
for (int i = 1; i <= r; i++) {
ret = num % 10;
num /= 10;
}
return ret;
}
private int getRadix() {
int max = arr[0];
for (int i = 1; i < arr.length; i++) {
if (arr[i] > max) {
max = arr[i];
}
}
return (max + "").length();
}
}