一、概念
排序分为内部排序和外部排序,通常我们说的排序算法指内部排序,即将数据在内存中进行排序。
内部排序又分为比较排序和非比较排序。比较排序包括:冒泡排序、快速排序、插入排序、选择排序、归并排序等;
非比较排序包括:计数排序、基数排序、桶排序等。
算法复杂度:
注:稳定性指两个相等的元素,排序后这两个元素的位置先后是否一定跟原来一致,一致为稳定。
二、插入排序
1、直接插入排序
概念:构建有序序列,对于未排序的数据,在已排序序列中从后向前扫描,找到相应的位置并插入。
时间复杂度(平均):O(n^2)
空间复杂度:O(1)
稳定
public class DirectInsertSort {
public void sort(int[] arr) {
int j, insertNode;
for (int i = 1; i < arr.length; i++) {
insertNode = arr[i];
j = i - 1;
while (j >= 0 && insertNode < arr[j]) {
arr[j + 1] = arr[j];
j--;
}
arr[j + 1] = insertNode;
}
}
public static void main(String[] args) {
int[] arr = { 49, 38, 65, 97, 76, 13, 27, 49 };
new DirectInsertSort().sort(arr);
System.out.println(Arrays.toString(arr));
}
}
2、希尔排序
概念:设置步长,优先比较距离较远的元素,然后逐渐减小步长,最终通过一次直接插入排序完成。
时间复杂度(平均):O(n^1.3)
空间复杂度:O(1)
不稳定
public class ShellSort {
public void sort(int[] arr) {
int temp;
int dk = arr.length / 2;
while (dk > 0) {
for (int i = dk; i < arr.length; i++) {
temp = arr[i];
int j = i - dk;
while (j >= 0 && arr[j] > temp) {
arr[j + dk] = arr[j];
j -= dk;
}
arr[j + dk] = temp;
}
dk = dk / 2;
}
}
public static void main(String[] args) {
int[] arr = { 49, 38, 65, 97, 76, 13, 27, 49 };
new ShellSort().sort(arr);
System.out.println(Arrays.toString(arr));
}
}
三、选择排序
1、简单选择排序
概念:每次从未排序队列中选择最小的元素放到已排序队列第1个位置,接着从剩下的中找最小的元素放到已排序队列第2个位置,如此重复。
时间复杂度(平均):O(n^2)
空间复杂度:O(1)
不稳定
public class SimpleSelectSort {
public void sort(int[] arr) {
int min;
for (int i = 0; i < arr.length - 1; i++) {
// 找到最小元素的下标
min = i;
for (int j = i + 1; j < arr.length; j++) {
if (arr[j] < arr[min])
min = j;
}
// 交换
int temp = arr[min];
arr[min] = arr[i];
arr[i] = temp;
}
}
public static void main(String[] args) {
int[] arr = { 49, 38, 65, 97, 76, 13, 27, 49 };
new SimpleSelectSort().sort(arr);
System.out.println(Arrays.toString(arr));
}
}
2、堆排序
待完成。。。
四、交换排序
1、冒泡排序
概念:相邻两个比较,将最大的元素往后移。
时间复杂度(平均):O(n^2)
空间复杂度:O(1)
稳定
public class BubbleSort {
public void sort(int[] arr) {
int temp;
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]) {
temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}
public static void main(String[] args) {
int[] arr = { 49, 38, 65, 97, 76, 13, 27, 49 };
new BubbleSort().sort(arr);
System.out.println(Arrays.toString(arr));
}
}
2、快速排序
概念:找一个元素,所有元素跟这个元素比较,比它小的放左边,比它大的放右边,然后分别再递归左右两边。
时间复杂度(平均):O(nlogn)
空间复杂度:O(nlogn)
不稳定
public class QuickSort {
public void sort(int[] arr, int low, int high) {
if (low < high) {// 递归终止条件
int mid = qsort(arr, low, high);
sort(arr, low, mid - 1);
sort(arr, mid + 1, high);
}
}
/*
* 递归函数
* 通过arr[low]将数组分成左右两部分
*/
private int qsort(int[] arr, int low, int high) {
int pivot = arr[low];
while (low < high) {
while (low < high && pivot <= arr[high])
high--;
arr[low] = arr[high];
while (low < high && pivot >= arr[low])
low++;
arr[high] = arr[low];
}
arr[low] = pivot;
return low;
}
public static void main(String[] args) {
int[] arr = { 49, 38, 65, 97, 76, 13, 27, 49 };
new QuickSort().sort(arr, 0, arr.length - 1);
System.out.println(Arrays.toString(arr));
}
}
五、归并排序
概念:从中间劈开,左右两边分别排序,然后再合并。
时间复杂度(平均):O(nlogn)
空间复杂度:O(n)
稳定
public class MergeSort {
public void sort(int[] arr) {
int[] temp = new int[arr.length];
msort(arr, 0, arr.length - 1, temp);
}
private void msort(int[] arr, int low, int high, int[] temp) {
if (low < high) {// 递归终止条件
int mid = (low + high) / 2;
msort(arr, low, mid, temp);
msort(arr, mid + 1, high, temp);
merge(arr, low, high, mid, temp);
}
}
// 合并
private void merge(int[] arr, int low, int high, int mid, int[] temp) {
int i = low;
int j = mid + 1;
int k = 0;
while (i <= mid && j <= high) {
if (arr[i] <= arr[j]) {
temp[k++] = arr[i++];
} else {
temp[k++] = arr[j++];
}
}
while (i <= mid)
temp[k++] = arr[i++];
while (j <= high)
temp[k++] = arr[j++];
k = 0;
while (low <= high) {
arr[low++] = temp[k++];
}
}
public static void main(String[] args) {
int[] arr = { 49, 38, 65, 97, 76, 13, 27, 49 };
new MergeSort().sort(arr);
System.out.println(Arrays.toString(arr));
}
}