排序
排序是将一组数据，依指定的顺序进行排列的过程。
排序的分类：
- 内部排序，将需要处理的所有数据都加载到内部存储器中进行排序
- 外部排序，数据量过大，无法全部加载到内存中，需要借助外部存储进行排序。
内部排序分类：
- 插入排序：直接插入排序和希尔排序
- 选择排序：简单选择排序和堆排序
- 交换排序：冒泡排序和快速排序
- 归并排序
- 基数排序
算法的时间复杂度
时间频度：一个算法中的语句执行次数称为语句频度或时间频度。记为 T(n)。
int result = 0;
for(int i = 1; i <= n; i++) {
result += i;
}
时间频度：T(n) = n
int result = (1 + n) * n / 2;
时间频度：T(n) = 1
时间复杂度：
- 一般情况下，算法中的基本操作语法的重复执行次数是问题规模 n 的某个函数，记为 T(n)。若有某个辅助函数f(n)，使得 T(n) / f(n) 的极限值为不等于零的常数，则称 f(n) 是 T(n) 的同数量级函数。记作 T(n) = O(f(n))，称 O(f(n)) 为算法的渐进时间复杂度，简称时间复杂度。
- T(n) 不同，但时间复杂度可能相同
平均时间复杂度：指所有可能的输入实例均以等概率出现的情况下，该算法的运行时间。
最坏时间复杂度：指在最坏的情况下，算法的时间复杂度
冒泡排序
基本思想：通过对待排序序列从前向后，依次比较相邻元素的值，若发现逆序则交换，使值较大的元素逐渐从前移向后部，就像水底下的气泡一样逐渐往上冒。
代码实现：
public void bubbleSort(int[] arr) {
boolean flag;
for(int k = 0; k < arr.length()-1; k++){
// 标志位flag用来显示序列是否经过交换
flag = false;
for(int i = 1; i < arr.length()-k; i++) {
if(arr[i] < arr[i-1]) {
flag= true;
int temp = arr[i];
arr[i] = arr[i-1];
arr[i-1] = temp;
}
}
// 没有经过交换，说明序列已经有序
if(flag == false) break;
}
}
选择排序算法
基本思想：第一次从数组中选出最小的数，与 arr[0] 进行交换。第二次在除了 arr[0] 的范围内选出最小的，与arr[1] 进行交换。重复 n-1 此即可（n为序列长度）。
代码实现：
public static chooseSort(int[] arr) {
for(int i = 0; i < arr.length-1; i++) {
int min = arr[i];
int min_index = i;
for(int j = i + 1; j < arr.length; j++) {
if(min > arr[j]) {
min = arr[j]
min_index = j;
}
}
if(min_index != i) {
arr[min_index] = arr[i];
arr[i] = min;
}
}
}
插入排序
基本思想：把 n 个待排序的元素看成为一个有序表和一个无序表，开始时有序表中只包含一个元素，无序表中包含 n-1 个元素，排序过程中每次从无序表中取出第一个元素，插入到有序表中，要求插入后有序表依然有序。
代码实现：
public static void insertSort(int[] arr) {
int insertVal;
int insertIndex;
for(int i = 0; i < arr.length; i++) {
int insertVal = arr[i];
int insertIndex = i;
while(insertIndex >= 1 && insertVal < arr[insertIndex-1]){
arr[insertIndex] = arr[insertIndex-1];
insertIndex--;
}
if(i != insertIndex) arr[insertIndex] = insertVal;
System.out.printf("第%d次的排序结果为：" + Arrays.toString(arr) + "\n", i+1);
}
}
希尔排序
插入排序存在的问题：当要插入的数较小时，将会后移数据很多次！
希尔排序介绍：希尔排序是希尔（Donald Shell）于1959年提出的一种排序算法。希尔排序也是一种插入排序，它是简单插入排序经过改进之后的一个更高效的版本，也称为缩小增量排序。
基本思想：希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至 1 时，整个序列被分为一组，等同于简单插入排序，只是这时序列比较有序，这样移动数据的次数就变少了。
代码实现1：组内交换式希尔排序
public static void shellSort1(int[] arr) {
int temp;
for (int gap = arr.length / 2; gap >= 1; gap /= 2) {
for (int i = gap; i < arr.length; i++) {
for (int j = i - gap; j >= 0; j -= gap) {
// 如果当前元素大于加上步长后的那个元素，则交换
if (arr[j] > arr[j + gap]) {
temp = arr[j];
arr[j] = arr[j + gap];
arr[j + gap] = temp;
} else {
break;
}
}
}
}
}
代码实现2：组内插入式希尔排序
// 移位法(插入法)希尔排序
public static void shellSort2(int[] arr) {
for(int gap = arr.length / 2; gap >= 1; gap /=2) {
for(int i = gap; i < arr.length; i++) {
int insertVal = arr[i];
int insertIndex = i;
while(insertIndex >= gap && insertVal < arr[insertIndex - gap]) {
arr[insertIndex] = arr[insertIndex-gap];
insertIndex -= gap;
}
if(insertIndex != i) arr[insertIndex] = insertVal;
}
}
}
快速排序
快速排序介绍：快速排序是对冒泡排序的一种改进。基本思想是：通过一趟排序，将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行。
思路分析：描述起来太复杂，直接看代码吧（有机会把图补上！！！）
代码实现：
public static void quickSort(int[] arr, int left, int right) {
int l = left;
int r = right;
int key = arr[left];
while(l < r) {
for(; l < r; r--) {
if(arr[r] < key) {
swap(arr, l, r);
break;
}
}
for(; l < r; l++) {
if(arr[l] > key) {
swap(arr, l, r);
break;
}
}
}
if(left != l) quickSort(arr, left, l-1);
if(right != r) quickSort(arr, r+1, right);
}
归并排序
归并排序介绍：归并排序（MergeSort）是利用归并的思想实现的排序问题，该算法采用经典的分治（divide and conquer）策略，“分”将问题分解成小的问题然后递归求解，“治”是将分的阶段得到的答案补在一起。
基本思想：（欠个图！！！）
代码实现：
package com.atguigu.sort;
import java.util.Arrays;
public class MergeSort {
public static void main(String[] args) {
int[] arr = {8, 4, 5, 7, 1, 3, 6, 2, -1, 10};
arr = mergeSort(arr);
System.out.println(Arrays.toString(arr));
}
public static int[] mergeSort(int[] arr) {
if(arr.length > 1) {
int len = arr.length / 2;
int[] arr1 = mergeSort(Arrays.copyOfRange(arr, 0, len));
int[] arr2 = mergeSort(Arrays.copyOfRange(arr, len, arr.length));
return merge(arr1, arr2);
} else {
return arr;
}
}
public static int[] merge(int[] arr1, int[] arr2) {
System.out.println(Arrays.toString(arr1) + ", " + Arrays.toString(arr2));
int len1 = arr1.length;
int len2 = arr2.length;
int[] arr = new int[len1+len2];
int k = 0, i = 0, j = 0;
while(i < len1 && j < len2) {
if(arr1[i] < arr2[j]) {
arr[k++] = arr1[i];
i++;
} else {
arr[k++] = arr2[j];
j++;
}
}
while(i < len1) arr[k++] = arr1[i++];
while(j < len2) arr[k++] = arr2[j++];
return arr;
}
}
基数排序
基数排序介绍：基数（radix sort）排序属于“分配式排序”，又称“桶子法”，顾名思义，它是通过键值的各个位的值，将要排序的元素分配至某些“桶”中，达到排序的作用。
基数排序思想：将所有待比较数值统一为同样的数位长度，数位较短的数前面补零。然后，从最低位开始，依次进行一次排序。这样从最低位排序一直到最高位排序完成后，数列就变成一个有序序列。
图示：
代码实现：
public static void radixSort(int[] arr) {
//定义一个二维数组，表示10个桶，每个桶就是一个一维数组
//说明：
//1、二维数组包含10个一维数组
//2、为了防止在放入数的时候，数据溢出，则每个一维数组大小定义为arr.length
int[][] bucket = new int[10][arr.length];
//为了记录每个桶中实际存放了多少个数据，我们定义一个一维数组来记录各个桶的有效数据个数
int[] eleCounts = new int[10];
// 得到数组中，最大数的位数
int max = arr[0];
for(int i = 1; i < arr.length; i++) {
if(arr[i] > max) max = arr[i];
}
int maxLength = ("" + max).length(); //得到位数的巧妙的办法
for(int i = 0; i < maxLength; i++){
// 第n轮，针对每个元素的个位进行排序
for(int j = 0; j < arr.length; j++) {
int ge = arr[j] / (int)(Math.pow(10, i)) % 10;
bucket[ge][eleCounts[ge]++] = arr[j];
}
// 按照桶的顺序
int index = 0;
// 遍历每一个桶
for(int k = 0; k < eleCounts.length; k++) {
if(eleCounts[k] > 0) {
for(int t = 0; t < eleCounts[k]; t++) {
arr[index++] = bucket[k][t];
}
eleCounts[k] = 0;
}
}
System.out.printf("第%d轮排序：" + Arrays.toString(arr) + "\n", i+1);
}
}
常见排序算法的比较
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
