1.概念
排序 就是一串记录，按照其中的某个或者关键字的大小，递增或者递减的排列起来的操作。
1.1.稳定性
2.七大排序总览
常见的排序算法 1.插入排序（直接插入排序和希尔排序）
2.选择排序（选择排序和堆排序）
3.交换排序（冒泡排序和快速排序）
4.归并排序
部分详解
一.插入排序
1.1 直接插入排序-原理
排序数字被看成两个部分 有序区间和无序区间
每次选择无序区间的第一个元素，在有序区间内选择合适的位置插入。
1.2代码实现
public static void insertSort(int[] array)
{
for (int i = 1; i < array.length; i++)
{
// 有序区间: [0, i) // 无序区间: [i, array.length)
int v = array[i];
// 无序区间的第一个数 int j = i - 1; // 不写 array[j] == v 是保证排序的稳定性
for (; j >= 0 && array[j] > v; j--)
{
array[j + 1] = array[j];
}
array[j + 1] = v;
}
}
1.3性能分析
时间复杂度
最好 最坏 平均 空间复杂度
O(n) O(n^2) O(n^2) O（1）
数据有序 数据逆序
稳定性：稳定
插入排序 数据有接近有序，效率越高。
2.希尔排序
2.2代码实现
public static void shellSort(int[] array) {
int gap = array.length; while (gap > 1) {
insertSortGap(array, gap);
gap = (gap / 3) + 1; // OR gap = gap / 2;
}
insertSortGap(array, 1);
}
private static void insertSortGap(int[] array, int gap) {
for (int i = 1; i < array.length; i++) {
int v = array[i]; int j = i - gap;
for (; j >= 0 && array[j] > v; j -= gap) {
array[j + gap] = array[j];
}array[j + gap] = v;
}
}
2.3性能分析
时间复杂度 空间复杂度
最好 最坏 平均
O（n） O(n^2) O(n^1.3) O（1）
数据有序
稳定性：不稳定
二.选择排序
1.1直接选择排序-原理
1.2代码实现
public static void selectSort(int[] array) {
for (int i = 0; i < array.length - 1; i++) {
// 无序区间: [0, array.length - i) // 有序区间: [array.length - i, array.length)
int max = 0;
for (int j = 1; j < array.length - i; j++)
{
if (array[j] > array[max])
{
max = j;
}
}
int t = array[max];
array[max] = array[array.length - i - 1];
array[array.length - i - 1] = t;
}
}
1.3性能分析
时间复杂度 空间复杂度
O（n^2） O(1)
数据不敏感 数据不敏感
稳定性：不稳定
2.1堆排序
2.2代码实现
public static void heapSort(int[] array) {
createHeap(array);
for (int i = 0; i < array.length - 1; i++) {
// 交换前 // 无序区间: [0, array.length - i) // 有序区间: [array.length - i, array.length)
swap(array, 0, array.length - 1);
// 交换后 // 无序区间: [0, array.length - i - 1) // 有序区间: [array.length - i - 1, array.length) // 无序区间长度: array.length - i - 1
shiftDown(array, array.length - i - 1, 0);
}
}
private void swap(int[] array, int i, int j)
{
int t = array[i]; array[i] = array[j]; array[j] = t;
}
private void createHeap(int[] array) {
for (int i = (array.length - 1) / 2; i >= 0; i--)
{
shiftDown(array, array.length, i);
}
}
public static void shiftDown(int[] array, int size, int index) {
int left = 2 * index + 1; while (left < size) {
int max = left; int right = 2 * index + 2; if (right < size) {
if (array[right] > array[left])
{
max = right;
}
}
if (array[index] >= array[max])
{
break;
}
nt t = array[index]; array[index] = array[max]; array[max] = t;
index = max; left = 2 * index + 1;
}
}
2.3性能分析
时间复杂度 空间复杂度
O（n^log(n)） O(1)
数据不敏感 数据不敏感
稳定性：不稳定
三.交换排序
3.1冒泡排序
在无序区间，通过相邻数的比较，将最大的数冒泡到无序区间的最后，持续这个过程，直到数组整体有序。
3.2代码实现
public static void bubbleSort(int[] array)
{
for (int i = 0; i < array.length - 1; i++)
{
boolean isSorted = true; for (int j = 0; j < array.length - i - 1; j++)
{ // 相等不交换，保证稳定性
if (array[j] > array[j + 1])
{
swap(array, j, j + 1);
isSorted = false;
}
} if (isSorted)
{
break;
}
}
}
3.3性能分析
时间复杂度 空间复杂度
最好 最坏 平均
O(n) O(n^2) O(n^2) O(1)
数据有序 数据逆序
稳定性：稳定
2.快速排序
public static void quickSort(int[] array)
{
quickSortInternal(array, 0, array.length - 1);
}// [left, right] 为待排序区间
private static void quickSortInternal(int[] array, int left, int right)
{
if (left == right)
{
return;
}if (left > right) { return; }// 最简单的选择基准值的方式，选择 array[left] 作为基准值 // pivotIndex 代表基准值最终停留的下标
int pivotIndex = partition(array, left, right); // [left, pivotIndex - 1] 都是小于等于基准值的 //
[pivotIndex + 1, right] 都是大于等于基准值的 quickSortInternal(array, left, pivotIndex - 1);
quickSortInternal(array, pivotIndex + 1, right); }
代码实现：
private static int partition(int[] array, int left, int right)
{
int i = left; int j = right; int pivot = array[left];
while (i < j) {
while (i < j && array[j] >= pivot)
{
j--;
}while (i < j && array[i] <= pivot)
{
i++;
}
swap(array, i, j);
}swap(array, i, left);
return i;
}
挖坑法
private static int partition(int[] array, int left, int right)
{
int i = left; int j = right; int pivot = array[left];
while (i < j)
{
while (i < j && array[j] >= pivot)
{
j--;
}
array[i] = array[j];
while (i < j && array[i] <= pivot) {
i++;
}
array[j] = array[i];
}
array[i] = pivot; return i;
}
前后遍历法实现：
private static int partition(int[] array, int left, int right)
{
int d = left + 1; int pivot = array[left];
for (int i = left + 1; i <= right; i++)
{
if (array[i] < pivot)
{
swap(array, i, d); d++;
}
}
swap(array, d, left); return d;
}
性能分析
时间复杂度 空间复杂度
最好 最坏 平均 最好 最坏 平均
O（n*log(n)） O(n^2) O（n*log(n) O(log(n)） O(n) O(log(n)）
稳定性：不稳定
private static void merge(int[] array, int low, int mid, int high)
{
int i = low; int j = mid; int length = high - low;
int[] extra = new int[length]; int k = 0; // 选择小的放入 extra
while (i < mid && j < high) {
// 加入等于，保证稳定性
if (array[i] <= array[j])
{
extra[k++] = array[i++];
}
else { extra[k++] = array[j++];
}
}
// 将属于元素放入 extra
while (i < mid)
{
extra[k++] = array[i++];
}while
(j < right) {
extra[k++] = array[j++];
}
// 从 extra 搬移回
array for (int t = 0; t < length; t++)
{
// 需要搬移回原位置，从 low 开始 array[low + t] = extra[t]；
}
}
实现：
public static void mergeSort(int[] array) {
mergeSortInternal(array, 0, array.length);
}// 待排序区间为 [low, high)
private static void mergeSortInternal(int[] array, int low, int high)
{
if (low - 1 >= high)
{
return;
}
int mid = (low + high) / 2;
mergeSortInternal(array, low, mid);
mergeSortInternal(array, mid, high);
merge(array, low, mid, high);
}
性能分析
时间复杂度 空间复杂度
O（n*log(n)） O(n)
数据不敏感 数据不敏感
稳定性：稳定
扫一扫
3196
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
