Java面试宝典系列之基础排序算法

1.介绍

排序是一个在编程中间是非常基础的和重要的，网上也有很多有关排序算法的文章，再次我也是总结学习别人的知识，将别人的知识转为自己的知识，因此做此笔记，以便更好地掌握java常见排序算法。

2.插入算法

2.1 基本思想

每步将一个待排序的记录，按其顺序码大小插入到前面已经排序的字序列的合适位置（从后向前找到合适位置后），直到全部插入排序完为止。

2.2 实例



2.3 算法实现

public class SortSeries {

static int data[] = {57, 68, 59, 52};

public static void insertSort() {
int tmp, j = 0;
for (int k = 0; k < data.length; k++) {
tmp = data[k];
//比较前面所有的数字,如果有大于当前数字的,那个数字就往后移一位,空出来将temp插入
for (j = k - 1; j >= 0 && tmp < data[j]; j--) {
data[j + 1] = data[j];
}
//因为上面最后运行了一次j--,所有下面是data[j + 1]
data[j + 1] = tmp;
}
}

static void print() {
for (int i = 0; i < data.length; i++) {
System.out.print(data[i] + " ");
}
}

public static void main(String[] args) {
insertSort();
print();
}
}

结果：52 57 59 68

3.选择排序

3.1 基本思想

与直接插入排序正好相反，选择排序是从待排序的数中选出最小的放在已经排好的后面，这个算法选数耗时。

3.2 实例



3.3 算法实现

public class SortSeries {

static int data[] = {57, 68, 59, 52};

public static void selectSort() {
int i = 0;
int j, k, tmp = 0;
for (k = 0; k < data.length - 1; k++) {
//每次默认起始比较k下标就是待比较数字中最小值i的下标
i = k;
//从当前数字开始比较,选择出后面数字最小的小标,存入i值
for (j = k + 1; j < data.length; j++) {
if (data[j] < data[i]) {
i = j;
}
}
tmp = data[k];
//当前位置放入从当前到最末位置最小值,即进项数字交换
data[k] = data[i];
data[i] = tmp;
}
}

static void print() {
for (int i = 0; i < data.length; i++) {
System.out.print(data[i] + " ");
}
}

public static void main(String[] args) {
selectSort();
print();
}
}

结果：52 57 59 68

通过循环，找出最小的数的下标，赋值于i，即i永远保持待排序数据中最小的数的下标，最后和当前位置k互换数据即可。

4.快速排序

4.1 基本思想

通过一趟排序将待排序记录分割成独立的两部分，其中一部分记录的关键字均比另一部分关键字小，则分别对这两部分继续进行排序，直到整个序列有序。

4.2 实例

快排的思路：

设置两个指针：i和j，分别指向第一个和最后一个，i像后移动，j向前移动，选第一个数为标准（一般这样做，当然快排的关键就是这个“标准”的选取，每一轮比较这个标准值是不变的），从后面开始，找到第一个比标准小的数，互换位置，然后再从前面，找到第一个比标准大的数，互换位置，第一趟的结果就是标准左边的都小于标准，右边的都大于标准（但不一定有序），分成两拨后，继续递归的使用上述方法，最终有序！

4.3 算法实现

public class SortSeries {

/**
* 查找中轴（初始默认最低位作为中轴）所在位置
* @param numbers 排列数组
* @param low 最小起始下标
* @param high 最大起始下标
* @return
*/
public static int getMiddle(int[] numbers, int low, int high) {
int temp = numbers[low]; //数组的第一个作为中轴
while (low < high) {
while (low < high && numbers[high] > temp) {
high--;
}
numbers[low] = numbers[high];//比中轴小的记录移到低端
while (low < high && numbers[low] < temp) {
low++;
}
numbers[high] = numbers[low]; //比中轴大的记录移到高端
}
numbers[low] = temp; //中轴记录到尾
return low; // 返回中轴的位置
}

/**
* 递归形式的分治排序算法
* @param numbers
* @param low
* @param high
*/
public static void quickSort(int[] numbers, int low, int high) {
if (low < high) {
int middle = getMiddle(numbers, low, high); //将numbers数组进行一分为二 　　
quickSort(numbers, low, middle - 1); //对低字段表进行递归排序 　　
quickSort(numbers, middle + 1, high); //对高字段表进行递归排序
}
}

static void print(int[] numbers) {
for (int i = 0; i < numbers.length; i++) {
System.out.print(numbers[i] + " ");
}
}

public static void main(String[] args) {
int[] numbers = {20, 9, 17, 33, 49, 24, 15, 56, 1};
quickSort(numbers, 0, numbers.length - 1);
print(numbers);
}
}

结果：1 9 15 17 20 24 33 49 56

结合代码，我们分析一下一趟排序的过程，

待排列数组int[] numbers = {20, 9, 17, 33, 49, 24, 15, 56, 1}，
首先选取20作为标准，然后比较标准20跟最后一位1，20>1，交换位置：1, 9, 17, 33, 49, 24, 15, 56, 20；
然后20从左往右找出第一个比它大的值33交换位置：
1, 9, 17, 20,49, 24, 15, 56, 33；
然后20从右往左找出第一个比它小的值15交换位置：
1, 9, 17, 15,49, 24, 20, 56, 33；
然后20从左往右找出第一个比它大的值49交换位置：
1, 9, 17, 15,20, 24, 49, 56, 33；
然后20从右往左找出比它小的值,此时没有了，从左往右找比它大的值也没有了，此时第一趟结束，然后以此对1, 9, 17, 15和24, 49, 56, 33重复该过程，知道最后有序！

5.冒泡排序

5.1 基本思想

冒泡排序是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。

5.2 实例



5.3 算法实现

public class SortSeries {

static int[] data = {20, 9, 17, 33, 49, 24, 15, 56, 1};

public static void bubbleSort() {
int i, j, tmp = 0;
for (i = 0; i < data.length - 1; i++) {
for (j = data.length - 1; j > i; j--) {
if (data[j - 1] > data[j]) {
tmp = data[j - 1];
data[j - 1] = data[j];
data[j] = tmp;
}
}
}
}

static void print() {
for (int i = 0; i < data.length; i++) {
System.out.print(data[i] + " ");
}
}

public static void main(String[] args) {
bubbleSort();
print();
}
}

结果：1 9 15 17 20 24 33 49 56

6.希尔算法

6.1 基本思想

希尔排序(缩小增量法) 属于插入类排序，是将整个无序列分割成若干小的子序列分别进行插入排序。希尔排序是对直接插入排序算法的优化和升级。

6.2 实例

以数组{26, 53, 67, 48, 57, 13, 48, 32, 60, 50 }为例，步长序列为{5,2,1}



6.2 算法实现

public class SortSeries {

public static void shellsort(int[] data) {
int j, tmp = 0;
for (int increment = data.length / 2; increment > 0; increment /= 2) {
System.out.println("当前步长序列increment:" + increment);
for (int i = increment; i < data.length; i++) {
tmp = data[i];
for (j = i - increment; j >= 0; j -= increment) {
if (tmp < data[j]) {
data[j + increment] = data[j];
} else {
break;
}
}
//上面循环最后减去了increment,所以此时要加上
data[j + increment] = tmp;
}
for (int i = 0; i < data.length; i++) {
System.out.print(data[i] + " ");
}
System.out.println();
}
}

static void print(int[] data) {
System.out.println("-----最终排序结果-----");
for (int i = 0; i < data.length; i++) {
System.out.print(data[i] + " ");
}
}

public static void main(String[] args) {
int[] data = {26, 53, 67, 48, 57, 13, 48, 32, 60, 50};
shellsort(data);
print(data);
}
}

结果：

当前步长序列increment:5
13 48 32 48 50 26 53 67 60 57
当前步长序列increment:2
13 26 32 48 50 48 53 57 60 67
当前步长序列increment:1
13 26 32 48 48 50 53 57 60 67
-----最终排序结果-----
13 26 32 48 48 50 53 57 60 67

7.归并排序

7.1 基本思想

归并排序（Merge）是将两个（或两个以上）有序表合并成一个新的有序表，即把待排序序列分为若干个子序列，每个子序列是有序的。然后再把有序子序列合并为整体有序序列。

7.2 工作原理

（1）申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列；

（2）设定两个指针，最初位置分别为两个已经排序序列的起始位置；

（3）比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置；

（4）重复步骤3直到某一指针达到序列尾；

（5）将另一序列剩下的所有元素直接复制到合并序列尾；

7.3 算法实现

public class MergeSortTest {
/**
* 归并排序
*
* @param nums 待排序数组
* @param low
* @param high
* @return 输出有序数组
*/
public static int[] sort(int[] nums, int low, int high) {
int mid = (low + high) / 2;
if (low < high) {
// 左边
sort(nums, low, mid);
// 右边
sort(nums, mid + 1, high);
// 左右归并
merge(nums, low, mid, high);
//            System.out.println(Arrays.toString(nums));
}
return nums;
}

/**
* 将数组中low到high位置的数进行排序
*
* @param nums 待排序数组
* @param low  待排的开始位置
* @param mid  待排中间位置
* @param high 待排结束位置
*/
public static void merge(int[] nums, int low, int mid, int high) {
int[] temp = new int[high - low + 1];
int i = low;// 左指针
int j = mid + 1;// 右指针
int k = 0;

// 把较小的数先移到新数组中
while (i <= mid && j <= high) {
if (nums[i] < nums[j]) {
temp[k++] = nums[i++];
} else {
temp[k++] = nums[j++];
}
}

// 把左边剩余的数移入数组
while (i <= mid) {
temp[k++] = nums[i++];
}

// 把右边边剩余的数移入数组
while (j <= high) {
temp[k++] = nums[j++];
}

// 把新数组中的数覆盖nums数组
for (int k2 = 0; k2 < temp.length; k2++) {
nums[k2 + low] = temp[k2];
}
}

public static void main(String[] args) {
int a[] = {51, 46, 20, 18, 65, 97, 82, 30, 77, 50};
sort(a, 0, a.length - 1);
System.out.println("排序结果：" + Arrays.toString(a));
}
}

结果：

排序结果：[18, 20, 30, 46, 50, 51, 65, 77, 82, 97]

8.堆排序

深入解析堆排序的算法思想及Java代码的实现演示



参考文章：

Java之美[从菜鸟到高手演变]之常见的几种排序算法-插入、选择、冒泡、快排、堆排等

必须知道的八大种排序算法【java实现】（二） 选择排序，插入排序，希尔算法【详解】

【排序算法】希尔排序原理及Java实现