排序算法
1.直接排序算法
直接对数组进行排序
（1）算法步骤
将数组的元素挨个从第一个与后面所有的元素比较大小找到最小的，然后在比较第二个，直至遍历完整个数组
（2）代码实现
import java.util.Arrays;
public class 直接排序 {
public static void main(String[] args) {
int[] array = {1,4,8,3,69,26,14,36,7,9};
directSort(array);
System.out.println(Arrays.toString(array));
}
public static void directSort(int[]array) {
for(int i=0;i<array.length;i++) {
for(int j= i+1;j<array.length;j++) {
if(array[i]>array[j]) {
int temp = array[i];
array[i] = array[j];
array[j] = temp;
}
}
}
}
}
2.选择排序算法
选择排序是一种简单直观的排序算法，无论什么数据进去都是 O(n²) 的时间复杂度。所以用到它的时候，数据规模越小越好。唯一的好处可能就是不占用额外的内存空间了吧。
（1）算法步骤
首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置。
再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。
重复第二步，直到所有元素均排序完毕。
（2）代码实现
import java.util.Arrays;
public class 选择排序 {
public static void main(String[] args) {
int[] array = { 1, 82, 15, 2, 51, 6, 3, 61, 5, 11 };
selectionSort(array);
System.out.println(Arrays.toString(array));
}
public static void selectionSort(int[] array) {
for (int i = 0; i < array.length; i++) {
int minIndex = i;
for (int j = i + 1; j < array.length; j++) {
if (array[minIndex] > array[j])
minIndex = j;
}
int temp = array[minIndex];
array[minIndex] = array[i];
array[i] = temp;
}
}
}
3.插入排序算法
插入排序的代码实现虽然没有冒泡排序和选择排序那么简单粗暴，但它的原理应该是最容易理解的了，因为只要打过扑克牌的人都应该能够秒懂。插入排序是一种最简单直观的排序算法，它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。
插入排序和冒泡排序一样，也有一种优化算法，叫做拆半插入。
（1）算法步骤
将第一待排序序列第一个元素看做一个有序序列，把第二个元素到最后一个元素当成是未排序序列。
从头到尾依次扫描未排序序列，将扫描到的每个元素插入有序序列的适当位置。（如果待插入的元素与有序序列中的某个元素相等，则将待插入元素插入到相等元素的后面。）
（2）代码实现
import java.util.Arrays;
public class 插入排序 {
public static void main(String[] args) {
int[] array = { 1, 82, 15, 2, 51, 6, 3, 61, 5, 11 };
insertionSort(array);
System.out.println(Arrays.toString(array));
}
public static void insertionSort(int[] arr) {
for (int i = 1; i < arr.length; i++) {
for (int j = i; j > 0; j--) {
if (arr[j] < arr[j - 1]) {
int temp = arr[j];
arr[j] = arr[j - 1];
arr[j - 1] = temp;
}
}
}
}
}
4.冒泡排序算法
冒泡排序（Bubble Sort）也是一种简单直观的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢"浮"到数列的顶端。
（1）算法步骤
比较相邻的元素。如果第一个比第二个大，就交换他们两个。
对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
针对所有的元素重复以上的步骤，除了最后一个。
持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
（2）代码实现
import java.util.Arrays;
public class 冒泡排序 {
public static void main(String[] args) {
int[] array = { 1, 82, 15, 2, 51, 6, 3, 61, 5, 11 };
for (int i = 0; i < array.length; i++) {
for (int j = 0; j < array.length - i - 1; j++) {
if (array[j] > array[j + 1]) {
int temp = array[j];
array[j] = array[j + 1];
array[j + 1] = temp;
}
}
}
System.out.println(Arrays.toString(array));
}
}
5.快速排序算法
快速排序是由东尼·霍尔所发展的一种排序算法。在平均状况下，排序 n 个项目要 Ο(nlogn) 次比较。在最坏状况下则需要 Ο(n2) 次比较，但这种状况并不常见。事实上，快速排序通常明显比其他 Ο(nlogn) 算法更快，因为它的内部循环（inner loop）可以在大部分的架构上很有效率地被实现出来。
快速排序使用分治法（Divide and conquer）策略来把一个串行（list）分为两个子串行（sub-lists）。
快速排序又是一种分而治之思想在排序算法上的典型应用。本质上来看，快速排序应该算是在冒泡排序基础上的递归分治法。
快速排序的名字起的是简单粗暴，因为一听到这个名字你就知道它存在的意义，就是快，而且效率高！它是处理大数据最快的排序算法之一了
（1）算法步骤
- 从数列中挑出一个元素，称为 “基准”（pivot）;
- 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；
- 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序；
（2）代码实现
public class 快速排序 {
public static void main(String[] args) {
int arr[]= {12,2,8,7,9,12,8};
quickSort(arr, 0, arr.length-1);
for(int i=0;i<arr.length;i++) {
System.out.print(arr[i]+" ");
}
}
public static void quickSort(int[]arr,int left,int right) {
//进行判断，如果左边索引比右边索引 大，是不合法的，直接return结束这个方法
if(left>right)
return;
//定义变量保存基准数
int base = arr[left];
//定义变量i指向最左边
int i = left;
//定义变量j指向最右边
int j = right;
//当i和j不相遇时。在循环中检索
while(i!=j) {
//由j从右往左检索比基准数小的，如果检索到比基准数小的就停下
//检索到比基准数大的或者相等的，就继续检索
while(arr[j]>=base&&i<j) {
j--;
}
//i从左往右
while(arr[i]<=base&&i<j) {
i++;
}
//代码走到这里，i和j都停下，交换
int temp =arr[i];
arr[i] = arr[j];
arr[j] = temp;
//如果上面while循环的条件不成立，会跳出这个循环，往下执行
//如果这个条件不成立说明i和j就相遇了
//交换基准数和i和j相遇位置的数
}
arr[left] = arr[i];
arr[i] = base;
//交换完成后，基准数归位，左边数字都比他小，右边数字都比他大
//排左边
quickSort(arr, left, i-1);
//排右边
quickSort(arr, i+1, right);
}
}
6.希尔排序算法
希尔排序，也称递减增量排序算法，是插入排序的一种更高效的改进版本。但希尔排序是非稳定排序算法。
希尔排序是基于插入排序的以下两点性质而提出改进方法的：
- 插入排序在对几乎已经排好序的数据操作时，效率高，即可以达到线性排序的效率；
- 但插入排序一般来说是低效的，因为插入排序每次只能将数据移动一位；
希尔排序的基本思想是：先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，待整个序列中的记录"基本有序"时，再对全体记录进行依次直接插入排序。
（1）算法步骤
选择一个增量序列 t1，t2，……，tk，其中 ti > tj, tk = 1；
按增量序列个数 k，对序列进行 k 趟排序；
每趟排序，根据对应的增量 ti，将待排序列分割成若干长度为 m 的子序列，分别对各子表进行直接插入排序。仅增量因子为 1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。
（2）代码实现
public class 希尔排序 {
public static void main(String[] args) {
int[] arr = {0,8,7,9,6,5,3,2,1};
shellSort(arr);
for(int i=0;i<arr.length;i++) {
System.out.print(arr[i]+" ");
}
}
public static void shellSort(int[] arr) {
int temp = 0;
for(int gap = arr.length/2;gap>0;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;
}
}
}
}
}
}
7.计数排序算法
计数排序的核心在于将输入的数据值转化为键存储在额外开辟的数组空间中。作为一种线性时间复杂度的排序，计数排序要求输入的数据必须是有确定范围的整数。
- 计数排序的特征
当输入的元素是 n 个 0 到 k 之间的整数时，它的运行时间是 Θ(n + k)。计数排序不是比较排序，排序的速度快于任何比较排序算法。
由于用来计数的数组C的长度取决于待排序数组中数据的范围（等于待排序数组的最大值与最小值的差加上1），这使得计数排序对于数据范围很大的数组，需要大量时间和内存。例如：计数排序是用来排序0到100之间的数字的最好的算法，但是它不适合按字母顺序排序人名。但是，计数排序可以用在基数排序中的算法来排序数据范围很大的数组。
通俗地理解，例如有 10 个年龄不同的人，统计出有 8 个人的年龄比 A 小，那 A 的年龄就排在第 9 位,用这个方法可以得到其他每个人的位置,也就排好了序。当然，年龄有重复时需要特殊处理（保证稳定性），这就是为什么最后要反向填充目标数组，以及将每个数字的统计减去 1 的原因。
（1）算法步骤
- 1）找出待排序的数组中最大和最小的元素
- （2）统计数组中每个值为i的元素出现的次数，存入数组C的第i项
- （3）对所有的计数累加（从C中的第一个元素开始，每一项和前一项相加）
- （4）反向填充目标数组：将每个元素i放在新数组的第C(i)项，每放一个元素就将C(i)减去1
（2）代码实现
import java.util.Arrays;
public class 计数排序 {
public static void main(String[] args) {
int[] arr = {1,2,54,48,96,21,15,256,2,1544,2};
countingSort(arr);
System.out.println(Arrays.toString(arr));
}
public static void countingSort(int[]arr) {
int min = 0;
int max = 0;
//找出最大最小值
for(int i=0;i<arr.length;i++) {
if(arr[i]>max) {
max = arr[i];
}
if(arr[i]<min) {
min = arr[i];
}
}
//定义一个新数组用来记录次数
int offset = min-0;
int[] temp = new int[max-min+1];
//遍历原数组记录每个元素出现的次数
for(int i=0;i<arr.length;i++) {
temp[arr[i]-offset]++;
}
//将最后按顺序统计的元素出现的次数返回给原数组
int index = 0;
for(int i=0;i<temp.length;i++) {
if(temp[i]!=0) {
for(int j=0;j<temp[i];j++) {
arr[index++]=i+offset;
}
}
}
}
}
8.桶排序算法
桶排序是计数排序的升级版。它利用了函数的映射关系，高效与否的关键就在于这个映射函数的确定。为了使桶排序更加高效，我们需要做到这两点：
- 在额外空间充足的情况下，尽量增大桶的数量
- 使用的映射函数能够将输入的 N 个数据均匀的分配到 K 个桶中
同时，对于桶中元素的排序，选择何种比较排序算法对于性能的影响至关重要。
1.什么时候最快
当输入的数据可以均匀的分配到每一个桶中。
2.什么时候最慢
当输入的数据被分配到了同一个桶中。
代码实现
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.Random;
public class 桶排序 {
public static void main(String[] args) {
int[] arr = new int[50];
Random r = new Random();
for (int i = 0; i < arr.length; i++) {
arr[i] = r.nextInt(100) + 1;
}
bucketSort(arr);
System.out.println(Arrays.toString(arr));
}
public static void bucketSort(int[] arr) {
// 1.获取最大最小值
int min = 0;
int max = 0;
for (int i = 0; i < arr.length; i++) {
if (max < arr[i]) {
max = arr[i];
}
if (arr[i] < min) {
min = arr[i];
}
}
// 2.计算桶的数量
int bucketNum = (max - min) / arr.length + 1;
// 3.创建所有的桶
ArrayList<Integer>[] buckets = new ArrayList[bucketNum];
for(int i=0;i<buckets.length;i++) {
buckets[i] = new ArrayList<>();
}
// 4.遍历元素分别进桶
for (int i = 0; i < arr.length; i++) {
buckets[(arr[i] - min) / arr.length].add(arr[i]);
}
// 5.对每个桶进行排序
for (int i = 0; i < buckets.length; i++) {
buckets[i].sort(new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
return o1.compareTo(o2);
}
});
}
// 6.将桶中的数据放置到原数组中
int index = 0;
for (int i = 0; i < buckets.length; i++) {
for (int j = 0; j < buckets[i].size(); j++) {
arr[index++] = buckets[i].get(j);
}
}
}
}
9.堆排序算法
堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。堆排序可以说是一种利用堆的概念来排序的选择排序。分为两种方法：
- 大顶堆：每个节点的值都大于或等于其子节点的值，在堆排序算法中用于升序排列；
- 小顶堆：每个节点的值都小于或等于其子节点的值，在堆排序算法中用于降序排列；
堆排序的平均时间复杂度为 Ο(nlogn)。
（1）算法步骤
- 创建一个堆 H[0……n-1]；
- 把堆首（最大值）和堆尾互换；
- 把堆的尺寸缩小 1，并调用 shift_down(0)，目的是把新的数组顶端数据调整到相应位置；
- 重复步骤 2，直到堆的尺寸为 1。
（2）代码实现
import java.util.Arrays;
public class 堆排序 {
public static void main(String[] args) {
int[] arr = { 1, 2, 5, 48, 15, 36, 14, 56, 144, 86, 96, 72 };
heapSort(arr);
System.out.println(Arrays.toString(arr));
}
public static int len;
public static void heapSort(int[] arr) {
len = arr.length;
// 1.将传入的数组堆化 heapify
heapify(arr);
// 2将最大值与最后一个元素交换 在堆化 heapify
for (int i = arr.length - 1; i >= 0; i--) {
swap(arr, 0, i);
len--;
heapify(arr);
}
}
public static void heapify(int[] arr) {
for (int i = len - 1; i >= 0; i--) {
siftDown(arr, i);
}
}
public static void siftDown(int[] arr, int k) {
while (leftchild(k) < len) {
int j = leftchild(k);
if (j + 1 < len && arr[j + 1] > arr[j]) {
j = rightchild(k);
}
if (arr[k] < arr[j]) {
swap(arr, j, k);
k = j;
} else {
break;
}
}
}
public static void swap(int[] arr, int i, int j) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
public static int leftchild(int i) {
return i * 2 + 1;
}
public static int rightchild(int i) {
return i * 2 + 2;
}
public static int parent(int i) {
return (i - 1) / 2;
}
}
10归并排序算法
归并排序（Merge sort）是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。
作为一种典型的分而治之思想的算法应用，归并排序的实现由两种方法：
- 自上而下的递归（所有递归的方法都可以用迭代重写，所以就有了第 2 种方法）；
- 自下而上的迭代；
（1）算法步骤
- 申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列；
- 设定两个指针，最初位置分别为两个已经排序序列的起始位置；
- 比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置；
- 重复步骤 3 直到某一指针达到序列尾；
- 将另一序列剩下的所有元素直接复制到合并序列尾。
（2）代码实现
import java.util.Arrays;
public class 归并排序 {
public static void main(String[] args) {
int[] arr = { 8, 4, 5, 7, 1, 3, 6, 2, 9, 5 };
int[] temp = new int[arr.length];
mergeSort(arr, 0, arr.length - 1, temp);
System.out.println(Arrays.toString(arr));
}
// 分+合
public static void mergeSort(int[] arr, int left, int right, int[] temp) {
if (left < right) {
int mid = (left + right) / 2;
mergeSort(arr, left, mid, temp);
mergeSort(arr, mid + 1, right, temp);
// 合并
merge(arr, left, mid, right, temp);
}
}
// 合并
/**
*
* @param arr 排序的原始数组
* @param left 左边有序序列的初始索引
* @param mid 中间索引
* @param right 右边索引
* @param temp 中转数组
*/
public static void merge(int[] arr, int left, int mid, int right, int[] temp) {
if (left >= right) {
return;
}
int i = left;// 初始化i,左边有序序列的初始索引
int j = mid + 1;// 初始化j,右边有序序列的初始索引
int t = 0; // 中转数组的初始索引
// （一）
// 先把左右两边（有序）的数据按照规则填充到中转数组中
// 直到左右两边的有序序列，有一边处理完毕
while (i <= mid && j <= right) {
// 如果左边的有序序列的当前元素，小于等于右边有序序列的当前元素
// 即当前左边的当前元素，填充到temp中
// 然后t++,i++
if (arr[i] <= arr[j]) {
temp[t] = arr[i];
i++;
t++;
} else {
temp[t] = arr[j];
j++;
t++;
}
}
// （二）
// 把有剩余数据的一边剩余的数据依次填充到temp中
while (i <= mid) {// 左边有序序列还有剩余的元素，就全部填充到temp
temp[t] = arr[i];
t++;
i++;
}
while (j <= right) {// 右边有序序列还有剩余的元素，就全部填充到temp
temp[t] = arr[j];
j++;
t++;
}
// （三）
// 将temp拷贝到arr中
// 并不是每次都拷贝所有
t = 0;
while (left <= right) {
arr[left] = temp[t];
t++;
left++;
}
}
}
2243
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
