| 类别 | 排序方法 | 平均情况 | 最好情况 | 最坏情况 | 空间复杂度 | 稳定性 |
|---|---|---|---|---|---|---|
| 插入排序 | 插入排序 | 稳定 | ||||
| 插入排序 | Shell排序 | 不稳定 | ||||
| 选择排序 | 选择排序 | 不稳定 | ||||
| 选择排序 | 堆排序 | 不稳定 | ||||
| 交换排序 | 冒泡排序 | 稳定 | ||||
| 交换排序 | 快速排序 | 不稳定 | ||||
| 归并排序 | 归并排序 | 稳定 | ||||
| 基数排序 | 基数排序 | 稳定 |
基数排序中r代表关键字的基数，d代表长度，n代表关键字的个数
package com.sort_algorithm;
import java.util.Arrays;
public class SortSummarize {
public static void main(String[] args) {
int[] a = { 9, 8, 7, 6, 5, 1, 3, 0, 10, -1, 99, -10 };
int[] b = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 17, 16 };
// 将a的地址也就是引用给了b，使b的引用发生了改变。此时打印，其实打印的是同一个地址下的数组，
// 此时a、b都指向a的值，原来的b数组会因为没有被引用到，被JVM的GC回收
b = a;
// 将b的地址也就是引用给了a，使a的引用发生了改变。此时打印，其实打印的是同一个地址下的数组，
// 此时a、b都指向b的值，原来的a数组会因为没有被引用到，被JVM的GC回收
// a = b;
print("选择排序 ", selectSort(a));
print("冒泡排序 ", bubbleSort(b));
print("插入排序 ", insertSort(b));
print("归并排序 ", mergeSort(b));
print("希尔排序 ", shellSort(b));
print("堆排序 ", heapSort(b));
print("快速排序 ", quickSort(b));
}
/**
* 冒泡排序算法：每次将最小的一个数”浮“上去 最好情况O(n),即数组本身有序 最坏情况O(n^2)
*/
public static int[] bubbleSort(int[] a) {
a = Arrays.copyOf(a, a.length);
int count = 0;
boolean terminated = false;
for (int i = 0; i < a.length - 1 && !terminated; i++) {
terminated = true;
for (int j = a.length - 2; j >= i; j--) {
count++;
if (a[j] > a[j + 1]) {
swap(a, j + 1, j);
terminated = false;
}
}
}
System.out.println("冒泡排序比较次数: " + count);
return a;
}
/**
* 选择排序：每次选出待排序中最小的一个
*/
public static int[] selectSort(int[] a) {
a = Arrays.copyOf(a, a.length);
int count = 0;
for (int i = 0; i < a.length - 1; i++) {
int min = a[i];
int minIndex = i;
for (int j = i + 1; j < a.length; j++) {
count++;
if (a[j] < min) {
minIndex = j;
min = a[j];
}
}
swap(a, i, minIndex);
}
System.out.println("选择排序比较次数: " + count);
return a;
}
public static int[] insertSort(int[] a) {
a = Arrays.copyOf(a, a.length);
int count = 0;
for (int i = 1; i < a.length; i++) {// i之前有序,i指向待排序的元素
if (a[i] < a[i - 1]) {
int temp = a[i];
int j = i - 1;// j指向当前元素的前一个
for (; j >= 0 && a[j] > temp; j--) {
count++;
a[j + 1] = a[j];
}
a[j + 1] = temp;
}
}
System.out.println("插入排序比较次数: " + count);
return a;
}
private static void swap(int[] a, int i, int j) {
if (i == j)
return;
int temp = a[i];
a[i] = a[j];
a[j] = temp;
}
/**
* 希尔排序
*
* @param a
* @return
*/
public static int[] shellSort(int[] a) {
a = Arrays.copyOf(a, a.length);
int count = 0;
int increment = a.length;
do {
increment = increment / 3 + 1;
for (int i = increment; i < a.length; i = i + increment) {
if (a[i] < a[i - increment]) {
int temp = a[i];
int j = i - increment;
for (; j >= 0 && a[j] > temp; j -= increment) {
count++;
a[j + increment] = a[j];
}
a[j + increment] = temp;
}
}
} while (increment > 1);
System.out.println("希尔排序比较次数： " + count);
return a;
}
/**
* 堆排序
*
* @param a
* @return
*/
public static int[] heapSort(int[] a) {
a = Arrays.copyOf(a, a.length);
int length = a.length;
for (int i = length / 2 - 1; i >= 0; i--)// 2*i+1<=length-1,最后一个有左孩子的节点
heapAdjust(a, i, length);
for (int i = length - 1; i >= 0; i--) {
swap(a, 0, i);
heapAdjust(a, 0, i);//
}
return a;
}
// 每次将以i为root的子树满足最大堆特性;i指向待调整的节点
private static void heapAdjust(int[] a, int i, int length) {
int temp = a[i];
for (int j = 2 * i + 1; j < length; j = 2 * i + 1) {// 刚开始时指向左孩子
if (j + 1 < length && a[j + 1] > a[j])// 如果有做右孩子，且右孩子比左孩子大
j++;// j指向左右孩子中值较大的一个
if (temp >= a[j])
break;
a[i] = a[j];
i = j;
}
a[i] = temp;
}
public static int[] mergeSort(int[] a) {
a = Arrays.copyOf(a, a.length);
int[] aux = new int[a.length];
mergeSort(a, aux, 0, a.length - 1);
return a;
}
private static void mergeSort(int[] a, int[] aux, int lo, int high) {
if (lo >= high)
return;
int mid = (lo + high) / 2;
mergeSort(a, aux, lo, mid);
mergeSort(a, aux, mid + 1, high);
merge(a, aux, lo, mid, high);
}
private static void merge(int[] a, int aux[], int lo, int mid, int high) {
for (int i = lo; i <= high; i++) {
aux[i] = a[i];
}
int lo_h = mid + 1;
for (int i = lo; i <= high; i++) {
if (lo > mid)
a[i] = aux[lo_h++];
else if (lo_h > high)
a[i] = aux[lo++];
else {
if (aux[lo] <= aux[lo_h])
a[i] = aux[lo++];
else
a[i] = aux[lo_h++];
}
}
}
/**
* 快速排序
*
* @param a
* @return
*/
public static int[] quickSort(int[] a) {
a = Arrays.copyOf(a, a.length);
quickSort(a, 0, a.length - 1);
return a;
}
private static void quickSort(int[] a, int low, int high) {
if (low >= high)
return;
int partition = partition(a, low, high);
quickSort(a, low, partition - 1);
quickSort(a, partition + 1, high);
}
private static int partition(int[] a, int low, int high) {
int tempt = a[low];
while (low < high) {
while (low < high && a[high] >= tempt)
high--;
// swap(a,low,high);
a[low] = a[high];
while (low < high && a[low] <= tempt)
low++;
// swap(a,low,high);
a[high] = a[low];
}
a[low] = tempt;
return low;
}
private static void print(String str, int[] a) {
System.out.println(str);
for (int i = 0; i < a.length; i++)
System.out.print(a[i] + " ");
System.out.println("\n");
}
/**
* 下面是链表的快速排序
*
* @param str
* @param a
*/
public static ListNode quickSort(ListNode begin, ListNode end) {
// 判断为空，判断是不是只有一个节点
if (begin == null || end == null || begin == end)
return begin;
// 从第一个节点和第一个节点的后面一个几点
// begin指向的是当前遍历到的最后一个<= nMidValue的节点
ListNode first = begin;
ListNode second = begin.next;
int nMidValue = begin.val;
// 结束条件，second到最后了
while (second != end.next && second != null) {// 结束条件
// 一直往后寻找<=nMidValue的节点，然后与fir的后继节点交换
if (second.val < nMidValue) {
first = first.next;
// 判断一下，避免后面的数比第一个数小，不用换的局面
if (first != second) {
int temp = first.val;
first.val = second.val;
second.val = temp;
}
}
second = second.next;
}
// 判断，有些情况是不用换的，提升性能
if (begin != first) {
int temp = begin.val;
begin.val = first.val;
first.val = temp;
}
// 前部分递归
quickSort(begin, first);
// 后部分递归
quickSort(first.next, end);
return begin;
}
/**
* 链表的归并排序
*/
public ListNode sortList1(ListNode head) {
if (head == null || head.next == null)
return head;
quickSort(null, null);
return mergeSort(head);
}
private ListNode mergeSort(ListNode head) {
if (head == null || head.next == null)
return head;
ListNode mid = getMid(head);
ListNode second = mid.next;
mid.next = null;
ListNode left = mergeSort(head);
ListNode right = mergeSort(second);
return merge(right, left);
}
private ListNode merge(ListNode l1, ListNode l2) {
ListNode dummy = new ListNode(0);
ListNode cur = dummy;
while (l1 != null && l2 != null) {
if (l1.val <= l2.val) {
cur.next = l1;
l1 = l1.next;
} else {
cur.next = l2;
l2 = l2.next;
}
cur = cur.next;
}
if (l1 != null)
cur.next = l1;
else
cur.next = l2;
return dummy.next;
}
private ListNode getMid(ListNode head) {
if (head == null || head.next == null)
return head;
ListNode slow = head;
ListNode faster = head.next;
while (faster != null && faster.next != null) {
slow = slow.next;
faster = faster.next.next;
}
return slow;
}
}
package com.sort_algorithm;
public class ListNode {
int val;
ListNode next;
public ListNode(int x) {
val = x;
next = null;
}
}