只知道冒泡排序？来看看这些排序算法
只知道冒泡排序？来看看这些排序算法
Lvshen
发布于 2022-05-05 08:20:30
发布于 2022-05-05 08:20:30
代码可运行
运行总次数：0
代码可运行
关联问题
换一批
那些年我们面试时经常会被问到排序算法，还有被要求现场手写排序算法。这篇文章我们来介绍下程序员遇到过的排序算法。
插入排序
❝
- 从第一个元素开始，该元素可以认为已经被排序；
- 取出下一个元素，在已经排序的元素序列中从后向前扫描；
- 如果该元素（已排序）大于新元素，将该元素移到下一位置；
- 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；
- 将新元素插入到该位置后；
- 重复步骤2~5。
❞
private static int[] insertionSort(int[] array) {
if (array.length == 0) {
return array;
}
int current;
for (int i = 0; i < array.length - 1; i++) {
current = array[i + 1];
int preIndex = i;
while (preIndex >= 0 && current < array[preIndex]) {
array[preIndex + 1] = array[preIndex];
preIndex--;
}
array[preIndex + 1] = current;
}
return array;
}
冒泡排序
❝
- 比较相邻的元素。如果第一个比第二个大，就交换它们两个；
- 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；
- 针对所有的元素重复以上的步骤，除了最后一个；
- 重复步骤1~3，直到排序完成。
❞
public static int[] bubbleSort(int[] array) {
if (array.length == 0) {
return array;
}
for (int i = 0; i < array.length; i++) {
for (int j = 0; j < array.length - 1 - i; j++) {
if (array[j + 1] < array[j]) {
int temp = array[j + 1];
array[j + 1] = array[j];
array[j] = temp;
}
}
}
return array;
}
选择排序（性能最稳定的排序算法之一）
❝
- 初始状态：无序区为R[1..n]，有序区为空；
- 第i趟排序(i=1,2,3…n-1)开始时，当前有序区和无序区分别为R[1..i-1]和R(i..n）。该趟排序从当前无序区中-选出关键字最小的记录 R[k]，
- 将它与无序区的第1个记录R交换，使R[1..i]和R[i+1..n)分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区；
- n-1趟结束，数组有序化了
❞
public static int[] selectionSort(int[] array) {
if (array.length == 0) {
return array;
}
for (int i = 0; i < array.length; i++) {
int minIndex = i;
for (int j = i; j < array.length; j++) {
// 找到最小的数
if (array[j] < array[minIndex]) {
// 将最小数的索引保存
minIndex = j;
}
}
int temp = array[minIndex];
array[minIndex] = array[i];
array[i] = temp;
}
return array;
}
希尔排序
public static int[] shellSort(int[] array) {
int len = array.length;
int temp, gap = len / 2;
while (gap > 0) {
for (int i = gap; i < len; i++) {
temp = array[i];
int preIndex = i - gap;
while (preIndex >= 0 && array[preIndex] > temp) {
array[preIndex + gap] = array[preIndex];
preIndex -= gap;
}
array[preIndex + gap] = temp;
}
gap /= 2;
}
return array;
}
归并排序
public static int[] mergeSort(int[] array) {
if (array.length < 2) {
return array;
}
int mid = array.length / 2;
int[] left = Arrays.copyOfRange(array, 0, mid);
int[] right = Arrays.copyOfRange(array, mid, array.length);
return merge(mergeSort(left), mergeSort(right));
}
快速排序方法
public static int[] quickSort(int[] array, int start, int end) {
if (array.length < 1 || start < 0 || end >= array.length || start > end) {
return null;
}
int smallIndex = partition(array, start, end);
if (smallIndex > start) {
quickSort(array, start, smallIndex - 1);
}
if (smallIndex < end) {
quickSort(array, smallIndex + 1, end);
}
return array;
}
private static int partition(int[] array, int start, int end) {
int pivot = (int) (start + Math.random() * (end - start + 1));
int smallIndex = start - 1;
swap(array, pivot, end);
for (int i = start; i <= end; i++) {
if (array[i] <= array[end]) {
smallIndex++;
if (i > smallIndex) {
swap(array, i, smallIndex);
}
}
}
return smallIndex;
}
private static void swap(int[] array, int i, int j) {
int temp = array[i];
array[i] = array[j];
array[j] = temp;
}桶排序
public class BucketSort {
@Test
public void test1(){
int[] t = {5 ,3 ,5 ,2 ,8};
bucketSort(t);
}
private void bucketSort(int[] t) {
int a[] = new int[11];
for (int i = 0; i < a.length; i++) {
a[i] = 0;
}
for (int i = 0; i < t.length; i++) {
int index = t[i];
if (a[index] != 0) {
a[index]++;
} else {
a[index] = 1;
}
}
for (int i = 0; i < a.length; i++) {
if (a[i] == 0) {
continue;
}
for (int j = 0; j < a[i]; j++) {
System.out.println(i);
}
}
}
}
本文参与 腾讯云自媒体同步曝光计划，分享自微信公众号。
原始发表：2020-07-21，如有侵权请联系 cloudcommunity@tencent.com 删除
评论
登录后参与评论
暂无评论
腾讯云开发者
