一、冒泡排序
冒泡排序（Bubble Sort），是一种计算机科学领域的较简单的排序算法。
排序原理：
- 比较相邻的元素。如果前一个元素比后一个元素大，就交换这两个元素的位置。
- 对每一对相邻元素做同样的工作，从开始第一对元素到结尾的最后一对元素。最终最后位置的元素就是最大
public class Bubble {
public static void bubbleSort(Comparable[] args){
boolean flag = true;
// 遍历 n - 1 次
for(int i = 0; i < args.length - 1; i++){
flag = true;
// 遍历 n - 1 - i 次
for(int j = 0; j < args.length - 1 - i; j++){
// 比较索引j和索引j+1处的值
if (greater(args[j], args[j+1])){
exch(args, j,j+1);
flag = false;
}
}
if (flag)
break;
}
}
/*
比较 v元素 是否大于 w元素
*/
private static boolean greater(Comparable v, Comparable w){
return v.compareTo(w) > 0;
}
/*
数组元素i和j交换位置
*/
private static void exch(Comparable[] args,int i,int j){
Comparable temp;
temp = args[i];
args[i] = args[j];
args[j] = temp;
}
}
二、选择排序
选择排序是一种简单直观的排序方法。
排序原理：
- 每一次遍历的过程中，都假定第一个索引处的元素是最小值，和其他索引处的值依次进行比较，如果当前索引处 的值大于其他某个索引处的值，则假定其他某个索引出的值为最小值，最后可以找到最小值所在的索引
- 交换第一个索引处和最小值所在的索引处的值
public class Select {
public static void selectSort(Comparable[] args){
for(int i = 0; i < args.length-1; i++){
//定义一个变量，记录最小元素所在的索引
int minIndex = i;
for(int j = i+1; j < args.length; j++){
//需要比较最小索引minIndex处的值和j索引处的值；
if (greater(args[minIndex], args[j])){
minIndex = j;
}
}
//交换最小元素所在索引minIndex处的值和索引i处的值
if (minIndex != i)
exch(args, i, minIndex);
}
}
/*
比较 v元素 是否大于 w元素
*/
private static boolean greater(Comparable v, Comparable w){
return v.compareTo(w) > 0;
}
/*
数组元素i和j交换位置
*/
private static void exch(Comparable[] args,int i,int j){
Comparable temp;
temp = args[i];
args[i] = args[j];
args[j] = temp;
}
}
三、插入排序
插入排序（Insertion sort）是一种简单直观且稳定的排序算法。
排序原理：
- 把所有的元素分为两组，已经排序的和未排序的；
- 找到未排序的组中的第一个元素，向已经排序的组中进行插入；
- 倒叙遍历已经排序的元素，依次和待插入的元素进行比较，直到找到一个元素小于等于待插入元素，那么就把待插入元素放到这个位置，其他的元素向后移动一位；
public class Insert {
public static void insertSort(Comparable[] args){
for(int i = 1; i < args.length; i++){
// 待插入的数
Comparable temp = args[i];
int j = i - 1;
for(; j >= 0; j --){
// 找到了比 temp 小的数，则该数后面一个位置就是待插入位置
if(greater(temp, args[j]))
break;
// 比 temp 大的数，通通往后移一位
args[j + 1] = args[j];
}
args[j + 1] = temp;
}
}
/*
比较 v元素 是否大于 w元素
*/
private static boolean greater(Comparable v, Comparable w){
return v.compareTo(w) > 0;
}
/*
数组元素i和j交换位置
*/
private static void exch(Comparable[] args,int i,int j){
Comparable temp;
temp = args[i];
args[i] = args[j];
args[j] = temp;
}
}
四、希尔排序
希尔排序是插入排序的一种，又称“缩小增量排序”，是插入排序算法的一种更高效的改进版本。
前面学习插入排序的时候，我们会发现一个很不友好的事儿，如果已排序的分组元素为{2,5,7,9,10}，未排序的分组元素为{1,8}，那么下一个待插入元素为1，我们需要拿着1从后往前，依次和10,9,7,5,2进行交换位置，才能完成真正的插入，每次交换只能和相邻的元素交换位置。那如果我们要提高效率，直观的想法就是一次交换，能把1放到
更前面的位置，比如一次交换就能把1插到2和5之间，这样一次交换1就向前走了5个位置，可以减少交换的次数，这样的需求如何实现呢？接下来我们来看看希尔排序的原理。
排序原理：
- 选定一个增长量h，按照增长量h作为数据分组的依据，对数据进行分组；
- 对分好组的每一组数据完成插入排序；
- 减小增长量，最小减为1，重复第二步操作。
public class Shell {
public static void shellSort(Comparable[] args){
// 根据数组长度确定 gap
int gap = args.length / 2;
while (gap >= 1){
// 将数组分成若干个子数组
/* 为什么是 [gap, args.length), 因为在此处就开始了插入排序
这就与插入排序的 i 是从 1 开始相同，此处是从 gap
*/
for (int i = gap; i < args.length; i ++){
// 待插入的数
Comparable temp = args[i];
int j = i - gap;
for (; j >= 0; j -= gap){
// 找到了比 temp 小的数，则该数后面第 gap 个位置就是待插入位置
if(greater(temp, args[j]))
break;
// 比 temp 大的数，通通往后移 gap 位
args[j + gap] = args[j];
}
args[j + gap] = temp;
}
gap /= 2;
}
}
/*
比较 v元素 是否大于 w元素
*/
private static boolean greater(Comparable v, Comparable w){
return v.compareTo(w) > 0;
}
/*
数组元素i和j交换位置
*/
private static void exch(Comparable[] args,int i,int j){
Comparable temp;
temp = args[i];
args[i] = args[j];
args[j] = temp;
}
}
五、归并排序
归并排序是建立在归并操作上的一种有效的排序算法，该算法是采用分治法的一个非常典型的应用。将已有序的子
序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序
表，称为二路归并。
排序原理：
- 尽可能的一组数据拆分成两个元素相等的子组，并对每一个子组继续拆分，直到拆分后的每个子组的元素个数是 1为止。
- 将相邻的两个子组进行合并成一个有序的大组；
- 不断的重复步骤2，直到最终只有一个组为止
public class Merge {
// 归并所需要的辅助数组
private static Comparable[] assistTemp;
/*
对数组 args 中的元素进行排序
*/
public static void mergeSort(Comparable[] args) {
// 初始化辅助数组 assistTemp
assistTemp = new Comparable[args.length];
mergeSort(args, 0, args.length - 1, assistTemp);
}
public static void mergeSort(Comparable[] args, int left, int right, Comparable[] assistTemp) {
// 分解
if (left < right) {
int mid = (left+right) / 2;
// 向左递归进行分解
mergeSort(args, left, mid, assistTemp);
// 向右递归进行分解
mergeSort(args, mid + 1, right, assistTemp);
// 每分解一次便合并一次
merge(args, left, right, mid, assistTemp);
}
}
/*
合并
*/
private static void merge(Comparable[] args, int left, int right, int mid, Comparable[] assistTemp) {
// 用于合并数组的下标，即操作 assistTemp 下标
int tempIndex = 0;
int i = left, j = mid + 1;
while(i <= mid && j <= right){
// 当 args[i] <= args[j] 时，将 args[i] 加入 assistTemp
if(greater(args[j], args[i])){
assistTemp[tempIndex ++] = args[i ++];
}
else{
assistTemp[tempIndex ++] = args[j ++];
}
}
// 将未遍历完的数组直接放入 assistTemp
while(i <= mid){
assistTemp[tempIndex ++] = args[i ++];
}
while(j <= right){
assistTemp[tempIndex ++] = args[j ++];
}
// 将 assistTemp 的元素赋值给 args
for(i = right; i >= left; --i){
args[i] = assistTemp[--tempIndex];
}
}
/*
比较 v元素 是否大于 w元素
*/
private static boolean greater(Comparable v, Comparable w){
return v.compareTo(w) > 0;
}
}
六、快速排序
快速排序是对冒泡排序的一种改进。它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。
排序原理：
- 首先设定一个分界值，通过该分界值将数组分成左右两部分；
- 将大于或等于分界值的数据放到到数组右边，小于分界值的数据放到数组的左边。此时左边部分中各元素都小于或等于分界值，而右边部分中各元素都大于或等于分界值；
- 然后，左边和右边的数据可以独立排序。对于左侧的数组数据，又可以取一个分界值，将该部分数据分成左右两部分，同样在左边放置较小值，右边放置较大值。右侧的数组数据也可以做类似处理
- 重复上述过程，可以看出，这是一个递归定义。通过递归将左侧部分排好序后，再递归排好右侧部分的顺序。当
左侧和右侧两个部分的数据排完序后，整个数组的排序也就完成了。
public class Quick {
/*
比较v元素是否大于等于w元素
*/
private static boolean greater(Comparable v, Comparable w){
return v.compareTo(w) >= 0;
}
/*
数组元素i和j交换位置
*/
private static void exch(Comparable[] args, int i,int j){
Comparable temp;
temp = args[i];
args[i] = args[j];
args[j] = temp;
}
// 对数组内的元素进行排序
public static void quickSort(Comparable[] args) {
quickSort(args, 0, args.length - 1);
}
public static void quickSort(Comparable[] args, int left, int right) {
// 安全性校验
if (right < left){
return;
}
// 取第一个数为基准值
Comparable key = args[left];
int i = left, j = right;
while (i < j){
// 先从右往左扫描，找到一个比基准值小的元素
while (greater(args[j], key) && j > i)
j --;
// 再从左往右扫描，找一个比基准值大的元素
while (greater(key, args[i]) && i < j)
i ++;
if (i < j)
exch(args, i, j);
}
// 交换基准值与i、j相遇位置的元素
exch(args, left, i);
// 对分成的左边部分进行排序
quickSort(args, left, i - 1);
// 对分成的右边部分进行排序
quickSort(args, i + 1, right);
}
}
快速排序和归并排序的区别：
快速排序是另外一种分治的排序算法，它将一个数组分成两个子数组，将两部分独立的排序。快速排序和归并排序是互补的：归并排序将数组分成两个子数组分别排序，并将有序的子数组归并从而将整个数组排序，而快速排序的方式则是当两个数组都有序时，整个数组自然就有序了。在归并排序中，一个数组被等分为两半，归并调用发生在
处理整个数组之前，在快速排序中，切分数组的位置取决于数组的内容，递归调用发生在处理整个数组之后。
七、计数排序
计数排序是一个基于非比较的排序算法，元素从未排序状态变成已排序状态的过程，是由额外空间的计数和元素本身的值决定的。
排序步骤：
- 找出待排序的数组array中最大的元素max
- 统计数组中每个值为 i 的元素出现的次数，存入数组 count 的第 i 项
- 对所有的计数累加（从 count中的第一个元素开始，每一项和前一项相加）
- 反向填充目标数组：将每个元素 i 放在新数组的第 count [i] 项，每放一个元素就将 count [i] 减去
public class Count {
public static void countSort(Comparable[] args) {
// 获取最大值，以便确定 countArray 大小
int countLen =(int) findMaxElement(args) + 1;
int[] countArray = new int[countLen];
// 开始计数
for (Comparable t: args)
countArray[(int) t] ++;
int idx = 0;
for (int i = 0; i < countLen; ++i){
while (countArray[i] > 0){
args[idx ++] = i;
countArray[i] --;
}
}
}
/*
比较v元素是否大于w元素
*/
private static boolean greater(Comparable v, Comparable w){
return v.compareTo(w) > 0;
}
/*
返回数组最大值
*/
private static Comparable findMaxElement(Comparable[] args) {
if (args.length == 0) return null;
Comparable max = args[0];
for (Comparable t: args){
if (greater(t, max))
max = t;
}
return max;
}
}
八、桶排序
桶排序可以看成是计数排序的升级版，它将要排的数据分到多个有序的桶里，每个桶里的数据再单独排序，再把每个桶的数据依次取出，即可完成排序。
排序步骤：
- 确定桶的大小与个数，一般根据要排序的元素的值域区间取定。
- 设计一种方式使元素能映射至对应值域的桶的索引。
- 遍历所有元素，将它们入桶。
- 每个桶内元素排序。
- 从桶内依次提取各元素重新排列。
public class Bucket {
public static void bucketSort(Integer[] args){
if (args.length == 0)
return;
Integer minValue = args[0];
Integer maxValue = args[0];
// 找到最值便于确定桶的数量
for (Integer t: args){
if (t < maxValue)
minValue = t;
else if (t > maxValue)
maxValue = t;
}
// 根据最值与数组长度确定桶的数量
int bucketNum = (maxValue - minValue) / args.length + 1;
ArrayList<ArrayList<Integer>> buckets = new ArrayList<>(bucketNum);
for (int i = 0; i < bucketNum; ++i)
buckets.add(new ArrayList<>());
// 元素入桶
for (Integer t: args){
int bucketIdx = (t - minValue) / args.length;
buckets.get(bucketIdx).add(t);
}
// 桶内元素排序
for (int i = 0; i < bucketNum; ++i)
Collections.sort(buckets.get(i));
// 从各个桶内去除元素重新拼接为数组
int idx = 0;
for (ArrayList<Integer> bucket: buckets){
for (Integer t: bucket)
args[idx ++] = t;
}
}
}
九、堆排序
排序思想：
首先将待排序的数组构造成一个大根堆，此时，整个数组的最大值就是堆结构的顶端
将顶端的数与末尾的数交换，此时，末尾的数为最大值，剩余待排序数组个数为n-1
将剩余的n-1个数再构造成大根堆，再将顶端数与n-1位置的数交换，如此反复执行，便能得到有序数组
public class Heap {
/*
堆排序
*/
public static void heapSort(Integer[] args) {
int len = args.length;
// 从最后一个不是叶子结点的节点开始调整
for(int i = len / 2 - 1; i >= 0; i --){
heapify(args, i, len);
}
for(int i = len - 1; i > 0; i --){
// 关键字移
exch(args, 0, i);
heapify(args, 0, i);
}
}
/*
调整为大根堆
*/
public static void heapify(Integer[] args, int cur, int len){
int child = 2 * cur + 1;
while(child < len){
if(child + 1 < len){
if(args[child + 1] > args[child])
child += 1;
}
if(args[cur] > args[child])
return;
exch(args, cur, child);
cur = child;
child = 2 * cur + 1;
}
}
/*
数组元素i和j交换位置
*/
private static void exch(Integer[] a, int i, int j) {
Integer t = a[i];
a[i] = a[j];
a[j] = t;
}
}
十、基数排序
基数排序是一种非比较算法，其原理是将整数按每个位数分别比较。他利用了桶的思想。
案例：
给定一个数组arr = [321，1，10，60，577，743，127]① 准备十个桶：0 ~ 9
② 第一轮按照元素的个位数排序 0~9的各个桶内分别存放数组中各元素的个位数，按照数组元素的顺序依次存放
再按照桶的顺序取出数据并放回原数组，arr = [10，60，321，1，743，577，127]
③ 第二轮按照元素的十位数排序 0~9的各个桶内分别存放数组中各元素的十位数，按照数组元素的顺序依次存放
再按照桶的顺序取出数据并放回原数组，
arr = [1，10，321，127，743，60，577]
④ 第三轮按照元素的百位数排序 0~9的各个桶内分别存放数组中各元素的百位数，按照数组元素的顺序依次存放
再按照桶的顺序取出数据并放回原数组，
arr = [1，10，60，127，321，577，743]
到这里，针对于以上数组的基数排序就结束了
public class Radix {
public static void radixSort(Integer[] args) {
// 得到数组中最大的数的位数
int maxNum = args[0];
for (int i = 1; i < args.length; i++) {
if (args[i] > maxNum) {
maxNum = args[i];
}
}
// 得到最大数是几位数
int maxLength = (maxNum + "").length();
// 定义一个二维数组，表示10个桶, 每个桶就是一个一维数组
// 为了防止放入数据的时候桶溢出，我们应该尽量将桶的容量设置得大一些
int[][] buckets = new int[10][args.length];
// 记录每个桶存放元素个数
int[] bucketElementCounts = new int[10];
/* n *= 10 的原因是
123取出个位数字是 123 % 10，即 123 / 1 % 10;
123 取出十位数字是123 / 10 % 10;
123 去除百位数字是123 / 100 % 10;
以此类推
*/
for (int i = 0, n = 1; i < maxLength; i++, n *= 10) {
for (int j = 0; j < args.length; j++) {
// 取出每个元素的对应位的值
int bit = args[j] / n % 10;
// 放入到对应的桶中
buckets[bit][bucketElementCounts[bit]] = args[j];
// 该桶对应元素数量 + 1
bucketElementCounts[bit]++;
}
// 按照桶的顺序取出数据并放回原数组
int index = 0;
// 遍历每一桶，并将桶中是数据，放入到原数组
for (int k = 0; k < bucketElementCounts.length; k++) {
if (bucketElementCounts[k] != 0) {
for (int l = 0; l < bucketElementCounts[k]; l++) {
args[index++] = buckets[k][l];
}
}
// 放回原数组后，需要将每个 everyBucketNum[k] = 0
bucketElementCounts[k] = 0;
}
}
}
}
1628
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
