术语
- 时间复杂度:算法执行所消耗的时间。
- 空间复杂度:算法执行所消耗的存储空间。
- 稳定排序:相同的两个元素,排序前后顺序不变,用于两个排序关键字的情况,如对价格升序的同时销量也升序。
- 不稳定排序:相同的两个元素,排序前后顺序可能发生改变,如快速排序、希尔排序、选择排序、堆排序(快些选堆)。
- 原地排序:无需额外存储空间,直接在原数组上进行排序,所以会修改原数组。
- 非原地排序:需要利用额外的存储空间来辅助排序。
一、选择排序:选择最小元素与首元素交换
1、找到数组中最小的那个元素,将它和数组的第一个元素交换位置;
2、这样一趟比较下来,排在第一的元素就会是最小的数;
2、在剩下的元素中找到最小的元素,将它和数组的第二个元素交换位置;
3、如此往复,直到将整个数组排序。
/**
* <dl>
* <dt><b>1.选择排序</b></dt>
* <dd>每一轮选出最小值,交换到左侧</dd>
* </dl>
* @param a 待排序数组
*/
public static void selectSort(int[] a) {
int n = a.length;
int minIndex = 0;
// 只需比较n-1轮
for (int i = 0; i < n - 1; i++) {
minIndex = i;
// 每轮比较n-1-i次
for (int j = i + 1; j < n; j++) {
if (a[j] < a[i]) {
// 最小值下标
minIndex = j;
}
}
// 最小值与a[i]交换
int temp = a[i];
a[i] = a[minIndex];
a[minIndex] = temp;
}
}
性质:
- 时间复杂度:O(n2)
- 空间复杂度:O(1)
- 不稳定排序
- 原地排序
二、插入排序:将元素插入到不比它大的位置(插扑克牌)
1、从数组第2个元素开始抽取元素;
2、把它与左边第一个元素比较,如果左边第一个元素比它大,则继续与左边第二个元素比较下去,直到遇到不比它大的元素,然后插到这个元素的右边;
3、这样一趟比较下来,该元素已经被插入到适当的位置,其左侧都不比它大;
4、继续选取第3,4,….n个元素,重复步骤 2 ,选择适当的位置插入。
/**
* <dl>
* <dt><b>2.插入排序</b></dt>
* <dd>维护一个有序区,把元素一个一个插入到有序区的适当位置,直到所有元素有序为止</dd>
* </dl>
* @param a 待排序数组
*/
public static void insertSort(int[] a) {
int n = a.length;
int j = 0;
int insValue = 0;
// 只需比较n-1轮
for (int i = 0; i < n - 1; i++) {
// 假定a[0]有序,从a[1]开始
j = i + 1;
// 待插入值
insValue = a[j];
// 比待插入值大的元素(待插入值前面的)后移,给待插入值腾出位置
while (j > 0 && insValue < a[j - 1]) {
a[j] = a[j - 1];
j -= 1;
}
// 把待插入值放在适当位置上
a[j] = insValue;
}
}
性质:
- 时间复杂度:O(n2)
- 空间复杂度:O(1)
- 稳定排序
- 原地排序
三、冒泡排序:元素两两比较,最大元素交换到末尾
1、把第一个元素与第二个元素比较,如果第一个比第二个大,则交换他们的位置;
2、接着继续比较第二个与第三个元素,如果第二个比第三个大,则交换他们的位置;
3、这样一趟比较下来,排在最后的元素就会是最大的数;
4、如此往复,直到将整个数组排序。
/**
* <dl>
* <dt><b>3.冒泡排序(标准版)</b></dt>
* <dd>两两比较,左比右大就交换,最大的数冒泡到右侧</dd>
* </dl>
* @param a 待排序数组
*/
public static void bubbleSort(int[] a) {
int n = a.length;
// 交换用临时变量
int temp = 0;
// 只需比较n-1轮
for (int i = 0; i < n - 1; i++) {
// 每轮比较n-1-i次
for (int j = 1; j < n; j++) {
if (a[j - 1] > a[j]) {
temp = a[j - 1];
a[j - 1] = a[j];
a[j] = temp;
}
}
}
}
性质:
- 时间复杂度:O(n2)
- 空间复杂度:O(1)
- 不稳定排序
- 原地排序
假如从开始的第一对到结尾的最后一对,相邻的元素之间都没有发生交换的操作,这意味着右边的元素总是大于等于左边的元素,此时的数组已经是有序的了,我们无需再对剩余的元素重复比较下去了。
优化之后的代码如下所示:
/**
* <dl>
* <dt><b>3.冒泡排序(优化版)</b></dt>
* <dd>两两比较,左比右大就交换,最大的数冒泡到右侧</dd>
* <dd>1.如果一轮比较后没有交换,那么数组已经有序</dd>
* <dd>2.每排序一轮,内层循环的次数可以减1</dd>
* <dd>3.用异或交换值</dd>
* </dl>
* @param a 待排序数组
*/
public static void bubbleSortOptimization(int[] a) {
// 优化2:内层循环次数
int loops = a.length;
// 优化1:交换标志
boolean swapFlag = false;
// 只需比较n-1轮
for (int i = 0; i < a.length - 1; i++) {
// 每轮循环都要初始化交换标志
swapFlag = false;
// 每轮比较loops - 1次
for (int j = 1; j < loops; j++) {
if (a[j - 1] > a[j]) {
// 优化3:用异或交换值
a[j - 1] = a[j - 1] ^ a[j];
a[j] = a[j] ^ a[j - 1];
a[j - 1] = a[j - 1] ^ a[j];
// 已交换
swapFlag = true;
}
}
// 缩减内层循环次数
loops--;
// 本轮没有交换,结束
if (!swapFlag) {
return;
}
}
}
四、希尔排序:将插入排序的1替换成逐步折半的step
希尔排序就是为了加快速度简单地改进了插入排序,交换不相邻的元素以对数组的局部进行排序。
1、让数组中任意间隔为 step = n / 2 的元素有序;
2、让数组中任意间隔为 step = n / 4 的元素有序;
3、直到数组中任意间隔为 step = 1 的元素有序,此时整个数组就是有序的。
/**
* <dl>
* <dt><b>4.希尔排序</b></dt>
* <dd>将插入排序的1替换成逐步折半的step</dd>
* </dl>
* @param a 待排序数组
*/
public static void shellSort(int[] a) {
int n = a.length;
int j = 0;
int insValue = 0;
// 采用逐步折半的增量方法
for (int step = n / 2; step > 0; step /= 2) {
// 只需比较n-1轮
for (int i = 0; i < n - step; i++) {
// 假定a[0]有序,从a[step]开始
j = i + step;
// 待插入值
insValue = a[j];
// 比待插入值小的元素(待插入值前面的)后移,给待插入值腾出位置
while (j > 0 && insValue < a[j - step]) {
a[j] = a[j - step];
j -= step;
}
// 把待插入值放在适当位置上
a[j] = insValue;
}
}
}
性质:
- 时间复杂度:O(nlogn)
- 空间复杂度:O(1)
- 不稳定排序
- 原地排序
五、归并排序:将左右数组排序,然后归并
1、通过递归的方式将大的数组一直分割,直到数组的大小为 1,此时只有一个元素,那么该数组就是有序的了;
2、把两个数组大小为1的合并成一个大小为2的数组;
3、把两个数组大小为2的合并成一个大小为4的数组;
4、直到全部小的数组合并起来,此时整个数组就是有序的。
/** 辅助数组 */
private static int[] aux = null;
/**
* <dl>
* <dt><b>5.归并排序</b></dt>
* <dd>将左右数组排序,然后归并</dd>
* </dl>
* @param a 待排序数组
*/
public static void mergeSort(int[] a) {
// 辅助数组分配内存空间
aux = new int[a.length];
// 自顶向下
// upToDown(a, 0, a.length - 1);
// 自底向上
downToUp(a);
}
/**
* <dl>
* <dt><b>5.归并排序(自顶向下)</b></dt>
* <dd>递归调用</dd>
* </dl>
* @param a 待排序数组
* @param left 要排序的最小下标
* @param right 要排序的最大下标
*/
public static void upToDown(int[] a, int left, int right) {
// 左右指针相遇时返回
if (left >= right) {
return;
}
int mid = left + (right - left) / 2;
// 将左边排序
upToDown(a, left, mid);
// 将右边排序
upToDown(a, mid + 1, right);
// 归并
merge(a, left, mid, right);
}
/**
* <dl>
* <dt><b>5.归并排序(自底向上)</b></dt>
* <dd>先两两归并,再四四归并,以此类推</dd>
* </dl>
* @param a 待排序数组
*/
public static void downToUp(int[] a) {
int n = a.length;
// a[0...sz...sz+sz-1]排序,a[sz+sz...sz+sz+sz-1...sz+sz+sz+sz-1]排序
// 每次都是sz+sz个元素排序
for (int sz = 1; sz < n; sz = sz + sz) {
for (int left = 0; left < n - sz; left += sz + sz) {
merge(a, left, left + sz - 1, Math.min(left + sz + sz - 1, n - 1));
}
}
}
/**
* <dl>
* <dt><b>5.归并排序(归并)</b></dt>
* <dd>先将数组复制到辅助数组,然后左右数组分别归并到原数组</dd>
* </dl>
* @param a 待排序数组
* @param left 要排序的最小下标
* @param mid 中间下标
* @param right 要排序的最大下标
*/
public static void merge(int[] a, int left, int mid, int right) {
for (int i = left; i <= right; i++) {
// 辅助数组初始化
aux[i] = a[i];
}
int i = left;
int j = mid + 1;
// 归并回原数组
for (int k = left; k <= right; k++) {
if (i > mid) {
// 左边用尽,取右边元素
a[k] = aux[j++];
} else if (j > right) {
// 右边用尽,取左边元素
a[k] = aux[i++];
} else if (aux[i] > aux[j]) {
// 取最小的,即右边元素
a[k] = aux[j++];
} else {
// 取最小的,即左边元素
a[k] = aux[i++];
}
}
}
性质:
- 时间复杂度:O(nlogn)
- 空间复杂度:O(n)
- 稳定排序
- 非原地排序
六、快速排序:选择一个切分元素使得左边的元素都小于它,右边的元素都不小于它
1、选择一个切分元素,暂存到tmp变量;
2、交换左边大于tmp和右边小于tmp的元素;
3、将切分元素与左右相遇位置元素交换;
4、如此往复,直到将整个数组排序。
/**
* <dl>
* <dt><b>6.快速排序</b></dt>
* <dd>选择一个切分元素,暂存到tmp变量中</dd>
* <dd>使得左边的元素都比他小,右边的都比它大</dd>
* <dd>如此循环,直到左右指针相遇</dd>
* </dl>
* @param a 待排序数组
* @param left 待排序的最小下标
* @param right 待排序的最大下标
*/
public static void quickSort(int[] a, int left, int right) {
// 左右指针相遇时返回
if (left >= right) {
return;
}
// 切分元素的下标
int mid = partition(a, left, right);
// 继续对左侧切分
quickSort(a, left, mid - 1);
// 继续对右侧切分
quickSort(a, mid + 1, right);
}
/**
* @param a 待排序数组
* @param left 待排序的最小下标
* @param right 待排序的最大下标
* @return 切分元素下标
*/
public static int partition(int[] a, int left, int right) {
// 暂存切分元素
int pivot = a[left];
int i = left;
int j = right + 1;
int tmp = 0;
while (true) {
// 找到左侧大于切分元素的下标
while (a[++i] <= pivot) {
// 直到最大下标也没找到
if (i == right) {
break;
}
}
// 找到右侧小于切分元素的下标
while (a[--j] >= pivot) {
// 直到最小下标也没找到
if (j == left) {
break;
}
}
// 左右指针相遇,结束
if (i >= j) {
break;
}
// 交换a[i]和a[j]
tmp = a[i];
a[i] = a[j];
a[j] = tmp;
}
// 交换a[left]和a[j]
a[left] = a[j];
// 使中轴元素处于有序的位置
a[j] = pivot;
return j;
}
性质:
- 时间复杂度:O(nlogn)
- 空间复杂度:O(logn)
- 不稳定排序
- 原地排序
七、堆排序:将无序数组构建成排序二叉堆
1、把无序数组构建成二叉堆;
2、堆顶堆底元素互换;
3、调节打乱后的堆,产生新的堆顶。
/**
* <dl>
* <dt><b>7.堆排序</b></dt>
* <dd>把无序数组构建成二叉堆</dd>
* <dd>循环删除堆顶元素,移到集合尾部,调节打乱后的堆,产生新的堆顶</dd>
* </dl>
* @param a 待排序数组
*/
public static void heapSort(int[] a) {
int n = a.length;
// 把无序数组构建成二叉堆
for (int i = (n - 2) / 2; i >= 0; i--) {
downAdjust(a, i, n);
}
int tmp = 0;
// 排序二叉堆
for (int i = n - 1; i > 0; i--) {
// 堆顶堆底元素互换
tmp = a[0];
a[0] = a[i];
a[i] = tmp;
// 调节打乱后的堆,产生新的堆顶
downAdjust(a, 0, i);
}
}
/**
* <dl>
* <dt><b>下沉调整</b></dt>
* </dl>
* @param a 待调整的堆
* @param parent 待下沉的父节点
* @param length 堆的有效大小
*/
public static void downAdjust(int[] a, int parent, int length) {
// 保存父节点的值
int tmp = a[parent];
// 左子节点
int child = parent * 2 + 1;
while (child < length) {
if (child + 1 < length && a[child + 1] > a[child]) {
// 指向最大的那个子节点
child++;
}
// 如果父节点大于等于最大子节点的值,无需下沉,跳出
if (tmp >= a[child]) {
break;
}
// 子节点上浮
a[parent] = a[child];
// 当前子节点变为父节点
parent = child;
// 当前子节点的子节点
child = child * 2 + 1;
}
// 父节点移动到合适的位置
a[parent] = tmp;
}
性质:
- 时间复杂度:O(nlogn)
- 空间复杂度:O(1)
- 不稳定排序
- 原地排序
八、计数排序:统计字母个数,创建长度27的数组,每个元素表示字母出现的次数
计数排序是一种适合于最大值和最小值的差值不是不是很大的排序。
1、假设数组取值范围[0, max],那么创建一个长度为max+1的计数数组;
2、数值出现一次,计数数组对应元素值+1,然后将计数数组写回原数组。
/**
* <dl>
* <dt><b>8.计数排序(标准版)</b></dt>
* <dd>假设数组取值范围[0, max],那么创建一个长度为max+1的计数数组</dd>
* <dd>数值出现一次,计数数组对应元素值+1,然后将计数数组写回原数组</dd>
* @param a 待排序数组
* </dl>
*/
public static void countSort(int[] a) {
int max = a[0];
for (int i = 1; i < a.length; i++) {
// 找出最大值
if (a[i] > max) {
max = a[i];
}
}
// 计数数组
int[] counts = new int[max + 1];
for (int i : a) {
// 计数
counts[i]++;
}
int index = 0;
for (int i = 0; i < counts.length; i++) {
while (counts[i] > 0) {
// 回写
a[index++] = i;
// 计数减1
counts[i]--;
}
}
}
性质:
- 时间复杂度:O(n + k)
- 空间复杂度:O(k)
- 稳定排序
- 非原地排序
注:k 表示临时数组的大小
上面的代码中,我们是根据 max 的大小来创建对应大小的数组,假如原数组只有10个元素,并且最小值为 min = 10000,最大值为 max = 10005,那我们创建 10005 + 1 大小的数组不是很吃亏,最大值与最小值的差值为 5,所以我们创建大小为6的临时数组就可以了。
也就是说,我们创建的临时数组大小 (max - min + 1)就可以了,然后在把 min作为偏移量。优化之后的代码如下所示:
/**
* <dl>
* <dt><b>8.计数排序(优化版)</b></dt>
* <dd>计数数组的大小设置为max-min+1</dd>
* @param a 待排序数组
* </dl>
*/
public static void countSortOptimization(int[] a) {
int max = a[0];
int min = a[0];
for (int i = 1; i < a.length; i++) {
// 找出最值
max = Math.max(a[i], max);
min = Math.min(a[i], min);
}
// 计数数组
int[] counts = new int[max - min + 1];
for (int i : a) {
// 计数
counts[i - min]++;
}
int index = 0;
for (int i = 0; i < counts.length; i++) {
while (counts[i] > 0) {
// 回写
a[index++] = i + min;
// 计数减1
counts[i]--;
}
}
}
九、桶排序:以十位上的数字划分0~9共10个桶,对应数字分别放入桶中进行排序,然后再进行归并
1、创建(max-min)/length+1个桶,相应地将i元素放入(a[i]-min)/length桶中;
2、再对每个桶进行排序,可以使用快速排序、归并排序等;
3、将排序后的桶依次写回数组,此时整个数组就是有序的。
/**
* <dl>
* <dt><b>9.桶排序</b></dt>
* <dd>创建(max-min)/length+1个桶,相应地将i元素放入(a[i]-min)/length桶中</dd>
* <dd>再对每个桶进行排序,最后将排序后的桶依次写回数组</dd>
* </dl>
* @param a 待排序数组
*/
public static void bucketSort(int[] a) {
int min = Integer.MAX_VALUE;
int max = Integer.MIN_VALUE;
for (int i : a) {
min = Math.min(min, i);
max = Math.max(max, i);
}
int n = a.length;
int bucketLength = (max - min) / n + 1;
// 用ArrayList作为桶,每个桶里面还是一个ArrayList
ArrayList<ArrayList<Integer>> bucketArr = new ArrayList<>(bucketLength);
for (int i = 0; i < bucketLength; i++) {
bucketArr.add(new ArrayList<Integer>());
}
int bucketIndex = 0;
for (int i = 0; i < n; i++) {
// 对应桶下标
bucketIndex = (a[i] - min) / n;
// 放入对应桶
bucketArr.get(bucketIndex).add(a[i]);
}
int index = 0;
// 可以使用各种方法对每个桶排序,并放入数组
for (ArrayList<Integer> arrayList : bucketArr) {
Collections.sort(arrayList);
for (int i : arrayList) {
a[index] = i;
index++;
}
}
}
性质:
- 时间复杂度:O(n + k)
- 空间复杂度:O(n + k)
- 稳定排序
- 非原地排序
注:k 表示桶的个数
十、基数排序:从个位开始分别放入桶中,然后写回数组,个位、十位依次有序
1、个位放入对应的桶,再将桶中数据写回数组,此时个位有序;
2、十位放入对应的桶,再将桶中数据写回数组,此时十位有序;
3、如此往复,直到将整个数组排序。
/**
* <dl>
* <dt><b>10.基数排序</b></dt>
* <dd>个位放入对应的桶,清空桶,十位放入对应的桶,清空桶</dd>
* </dl>
* @param a 待排序数组
*/
public static void radixSort(int[] a) {
// 10进制
int radix = 10;
int n = a.length;
int max = Integer.MIN_VALUE;
for (int i : a) {
// 最大值
max = Math.max(max, i);
}
for (int i = 1; max / i > 0; i *= radix) {
int[][] buckets = new int[radix][n];
int remainder = 0;
for (int j = 0; j < n; j++) {
// 求当前位
remainder = (a[j] / i) % radix;
// 放入对应的桶中
buckets[remainder][j] = a[j];
}
// 桶中数据放入数组,第一轮个位有序,第二轮十位有序
int k = 0;
for (int[] bucket : buckets) {
for (int buc : bucket) {
if (buc != 0) {
a[k] = buc;
k++;
}
}
}
}
}
性质:
- 时间复杂度:O(n * k)
- 空间复杂度:O(n + k)
- 稳定排序
- 非原地排序
注:k 表示桶的个数
算法总结
排序算法 | 平均时间复杂度 | 最好 | 最坏 | 空间复杂度 | 稳定性 |
---|---|---|---|---|---|
选择排序 | O(n^2) | O(n^2) | O(n^2) | O(1) | 不稳定 |
插入排序 | O(n^2) | O(n) | O(n^2) | O(1) | 稳定 |
冒泡排序 | O(n^2) | O(n) | O(n^2) | O(1) | 稳定 |
希尔排序 | O(n^1.3) | O(n) | O(nlog2n) | O(1) | 不稳定 |
归并排序 | O(nlogn) | O(nlogn) | O(nlogn) | O(n) | 稳定 |
快速排序 | O(nlogn) | O(nlogn) | O(n^2) | O(logn) | 不稳定 |
堆排序 | O(nlogn) | O(nlogn) | O(nlogn) | O(1) | 不稳定 |
计数排序 | O(n+k) | O(n+k) | O(n+k) | O(k) | 稳定 |
桶排序 | O(n+k) | O(n+k) | O(n+k) | O(n+k) | 稳定 |
基数排序 | O(n*k) | O(n*k) | O(n*k) | O(n+k) | 稳定 |