一、排序算法说明
1、排序的定义
对一序列对象根据某个关键字进行排序。
2、术语说明
- 稳定： 如果a原本在b前面，而a=b，排序之后a仍然在b的前面；
- 不稳定： 如果a原本在b的前面，而a=b，排序之后a可能会出现在b的后面；
- 内排序： 所有排序操作都在内存中完成；
- 外排序： 由于数据太大，因此把数据放在磁盘中，而排序通过磁盘和内存的数据传输才能进行；
- 时间复杂度： 一个算法执行所耗费的时间。
- 空间复杂度： 运行完一个程序所需内存的大小。
3、算法分类
十种常见排序算法可以分为两大类：
- 比较类排序： 又称为内部排序，通过比较来决定元素间的相对次序，由于其时间复杂度不能突破O(nlogn)，因此也称为非线性时间比较类排序。
- 非比较类排序： 又称为外部排序，不通过比较来决定元素间的相对次序，它可以突破基于比较排序的时间下界，以线性时间运行，因此也称为线性时间非比较类排序。
4、算法总结
二、各大算法详解
1、冒泡排序（Bubble Sort）
- 冒泡排序算法是一种简单的、稳定的排序算法。
- 概述： 冒泡排序就是把小的元素往前调（或者把大的元素往后调）。
- 原理： 重复地走访过要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。走访数列的工作是重复地进行直到没有再需要交换。
- 由来： 这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。
- 注意： 相邻的两个元素进行比较，而且是否需要交换也发生在这两个元素之间。
1.1 算法描述
- 比较相邻的元素。 如果第一个比第二个大，就交换它们两个；
- 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；
- 针对所有的元素重复以上的步骤，除了最后一个；
- 重复步骤1~3，直到排序完成。
1.2 动图演示
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;
}
2、选择排序（Selection Sort）
- 选择排序算法是一种不稳定的排序算法。
- 概述： 选择排序角色给每个位置选择待排序元素中当前最小(大)的元素。
- 原理： 首先在 [0 ~ n-1] 区间的序列中找到最小(大)元素，存放到排序序列的起始位置，然后，再从 [1 ~ n-1] 范围的序列元素中继续寻找最小(大)元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。
- 注意： 排序算法主要是通过索引来对序列进行排序。
2.1 算法描述
选择排序法的第一层循环从起始元素开始选到倒数第二个元素，主要是在每次进入的第二层循环之前，将外层循环的下标赋值给临时变量，接下来的第二层循环中，如果发现有比这个最小位置处的元素更小的元素，则将那个更小的元素的下标赋给临时变量，最后，在二层循环退出后，如果临时变量改变，则说明，有比当前外层循环位置更小的元素，需要将这两个元素交换。
2.2 动图演示
2.3 代码实现
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;
}
3、插入排序（Insertion Sort）
- 插入排序算法是一种稳定的排序算法。
- 概述： 插入排序是在一个已经有序的小序列的基础上，一次插入一个元素。
- 原理： 通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。插入排序在实现上，通常采用in-place排序（即只需用到O(1)的额外空间的排序），因而在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间。
3.1 算法描述
- 1、从第一个元素开始，该元素可以认为已经被排序；
- 2、取出下一个元素，在已经排序的元素序列中从后向前扫描；
- 3、如果该元素（已排序）大于新元素，将该元素移到下一位置；
- 4、重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；
- 5、将新元素插入到该位置后；
- 6、重复步骤2~5。
3.2 动图演示
3.3 代码实现
public 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;
}
4、希尔排序（Shell Sort）
- 希尔排序法：又称缩小增量法，属于插入类排序，是一种不稳定的排序算法。
- 原理： 是将整个无序列按某一增量分割成若干小的子序列分别进行插入排序的方法。
4.1 算法描述
先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，具体算法描述：
- 选择一个增量序列t1，t2，…，tk，其中ti>tj，tk=1；
- 按增量序列个数k，对序列进行k 趟排序；
- 每趟排序，根据对应的增量ti，将待排序列分割成若干长度为m 的子序列，分别对各子表进行直接插入排序。仅增量因子为1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。
4.2 图形演示
4.3 代码实现
//交换法
public static void shellSort(int[] arr) {
int count = 0;
int temp = 0;
for(int gsp = arr.length / 2; gsp > 0; gsp /= 2) {
for(int i = gsp; i < arr.length; i++) {
for(int j = i - gsp; j > 0; j -= gsp) {
if(arr[j] > arr[j + gsp]) {
temp = arr[j];
arr[j] = arr[j + gsp];
arr[j + gsp] = temp;
}
}
}
}
}
//移位法
public static void shellSort2(int[] arr) {
for(int gap = arr.length / 2; gap > 0; gap /= 2) {
for(int i = gap; i < arr.length; i++) {
int j = i;
int temp = arr[j];
while(j - gap > 0 && temp < arr[j - gap]) {
arr[j] = arr[j - gap];
j -= gap;
}
arr[j] = temp;
}
}
}
5、归并排序（Merge Sort）
- 归并排序算法：采用分治法，是一种稳定的排序方法。
- 原理： 将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为2-路归并。
5.1 算法描述
- 把长度为n的输入序列分成两个长度为n/2的子序列；
- 对这两个子序列分别采用归并排序；
- 将两个排序好的子序列合并成一个最终的排序序列
5.2 动图演示
5.3 代码实现
//分： 提供分解数组的方法
public static void merge(int[] arr, int left, int right,int[] temp) {
if(left < right) {
int mid = (left + right) / 2;
//左分
merge(arr, left, mid, temp);
//右分
merge(arr, mid + 1, right, temp);
mergeSort(arr,left,right,mid,temp);
}
}
//治: 提供合数组的方法
public static void mergeSort(int arr[], int left, int right, int mid, int temp[]) {
if(left < right) {
int i = left;
int j = mid + 1;
//temp临时的索引
int t = 0;
//三大步骤进行合并
//1.先将两个部分的数组比较后放入临时数组中，直到其中一个数组放完
while(i <= mid && j <= right) {
if(arr[i] <= arr[j]) {
temp[t] = arr[i];
i += 1;
t += 1;
}else {
temp[t] = arr[j];
j += 1;
t += 1;
}
}
//2.再将另一个没放完的数组全部放入临时数组中
while(i <= mid) {
temp[t] = arr[i];
t += 1;
i += 1;
}
while(j <= right) {
temp[t] = arr[j];
j += 1;
t += 1;
}
//3.将临时数组放入原数组中
int index = left;
int k = 0;
while(k < t) {
arr[index] = temp[k];
k += 1;
index += 1;
}
}
}
6、快速排序（Quick Sort）
- 快速排序算法是一种不稳定的排序算法。
- 原理： 通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。
6.1 算法描述
快速排序使用分治法来把一个串（list）分为两个子串（sub-lists）。具体算法描述如下：
- 从数列中挑出一个元素，称为 “基准”（pivot）；
- 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；
- 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。
6.2 动图演示
6.3 代码实现
public static void quick(int[] arr,int lift,int right) {
if(lift < right) {
int l = lift;
int r = right;
int key = arr[l];
while(l < r) {
while(l < r && arr[r] >= key) {
r -= 1;
}
arr[l] = arr[r];
while(l < r && arr[l] <= key) {
l += 1;
}
arr[r] = arr[l];
//这里可能已经完成，因此赋值需要移位**
if(l < r) {
arr[r--] = arr[l];
}
}
arr[l] = key;
//左向递归
quick(arr,lift,l - 1);
//右向递归
quick(arr,l + 1,right);
}
}
7、堆排序（Heap Sort）
- 堆排序算法是一种不稳定的排序算法。
- 堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。
7.1 算法描述
- 将初始待排序关键字序列(R1,R2….Rn)构建成大顶堆，此堆为初始的无序区；
- 将堆顶元素R[1]与最后一个元素R[n]交换，此时得到新的无序区(R1,R2,……Rn-1)和新的有序区(Rn),且满足R[1,2…n-1]<=R[n]；
- 由于交换后新的堆顶R[1]可能违反堆的性质，因此需要对当前无序区(R1,R2,……Rn-1)调整为新堆，然后再次将R[1]与无序区最后一个元素交换，得到新的无序区(R1,R2….Rn-2)和新的有序区(Rn-1,Rn)。不断重复此过程直到有序区的元素个数为n-1，则整个排序过程完成。
7.2 动图演示
7.3 代码实现
//编写一个堆排序
public static void heapSort(int[] arr) {
System.out.println("堆排序！！");
int temp = 0;
//最终代码：
//1.先弄一个大顶堆，升序
for(int i = arr.length / 2 + 1; i >= 0; i--) {
adjustHeap(arr, i, arr.length);
}
//2,交换大顶堆和最后一个元素，长度减一
//3,在剩下的数组中调整大顶堆。
for(int j = arr.length - 1; j > 0; j--) {
temp = arr[j];
arr[j] = arr[0];
arr[0] = temp;
adjustHeap(arr, 0, j);
}
}
//将一个数组（二叉树），调整成一个大顶堆
/**
*
* @param arr[] 待调整的数组
* @param i 表示非叶子节点再数组中的索引
* @param length 表示当前数组中还有多少待调整的元素
*/
public static void adjustHeap(int arr[], int i, int length) {
//先取出当前元素的值
int temp = arr[i];
//开始调整
for(int k = i * 2 + 1; k < length; k = k * 2 + 1) {
//从左右子节点中找到最大的那个值的索引
if(k + 1 < length && arr[k] < arr[k + 1]) {
k++;
}
//如果子节点大于父节点，直接交换
if(arr[k] > temp) {
arr[i] = arr[k];
i = k;//i 指向最大的元素k，继续循环比较
}else {
break;//我们是从左到右，从下到上，不必判断左下层子节点
}
}
//当for循环结束后，已经将以i为父节点的局部的树变成大顶堆。
arr[i] = temp;//将temp值放到调整后的位置。
}
8、计数排序（Counting Sort）
- 计数排序算法是一种稳定的排序算法。
- 计数排序的核心在于将输入的数据值转化为键存储在额外开辟的数组空间中。作为一种线性时间复杂度的排序，计数排序要求输入的数据必须是有确定范围的整数。
- 原理： 计数排序使用一个额外的数组C，其中第i个元素是待排序数组A中值等于i的元素的个数。然后根据数组C来将A中的元素排到正确的位置。它只能对整数进行排序。
8.1 算法描述
- 找出待排序的数组中最大和最小的元素；
- 统计数组中每个值为i的元素出现的次数，存入数组C的第i项；
- 对所有的计数累加（从C中的第一个元素开始，每一项和前一项相加）；
- 反向填充目标数组：将每个元素i放在新数组的第C(i)项，每放一个元素就将C(i)减去1。
8.2 动图演示
8.3 代码实现
public static int[] countSort(int[]a){
int b[] = new int[a.length];
int max = a[0],min = a[0];
for(int i:a){
if(i>max){
max=i;
}
if(i<min){
min=i;
}
}//这里k的大小是要排序的数组中，元素大小的极值差+1
int k=max-min+1;
int c[]=new int[k];
for(int i=0;i<a.length;++i){
c[a[i]-min]+=1;//优化过的地方，减小了数组c的大小
}
for(int i=1;i<c.length;++i){
c[i]=c[i]+c[i-1];
}
for(int i=a.length-1;i>=0;--i){
b[--c[a[i]-min]]=a[i];//按存取的方式取出c的元素
}
return b;
}
9、桶排序（Bucket Sort）
- 桶排序是一种稳定的排序算法。
- 桶排序是计数排序的升级版。它利用了函数的映射关系，高效与否的关键就在于这个映射函数的确定。
- 原理： 假设输入数据服从均匀分布，将数据分到有限数量的桶里，每个桶再分别排序（有可能再使用别的排序算法或是以递归方式继续使用桶排序进行排
9.1 算法描述
- 人为设置一个BucketSize，作为每个桶所能放置多少个不同数值（例如当BucketSize==5时，该桶可以存放｛1,2,3,4,5｝这几种数字，但是容量不限，即可以存放100个3）；
- 遍历输入数据，并且把数据一个一个放到对应的桶里去；
- 对每个不是空的桶进行排序，可以使用其它排序方法，也可以递归使用桶排序；
- 从不是空的桶里把排好序的数据拼接起来。
9.2 图形演示
9.3 代码实现
public static void basket(int data[]){//data为待排序数组
int n=data.length;
int bask[][]=new int[10][n];
int index[]=new int[10];
int max=Integer.MIN_VALUE;
for(int i=0;i<n;i++){
max=max>(Integer.toString(data[i]).length())?max:(Integer.toString(data[i]).length());
}
String str;
for(int i=max-1;i>=0;i--){
for(int j=0;j<n;j++){
str="";
if(Integer.toString(data[j]).length()<max){
for(int k=0;k<max-Integer.toString(data[j]).length();k++)
str+="0";
}
str+=Integer.toString(data[j]);
bask[str.charAt(i)-'0'][index[str.charAt(i)-'0']++]=data[j];
}
int pos=0;
for(int j=0;j<10;j++){
for(int k=0;k<index[j];k++){
data[pos++]=bask[j][k];
}
}
for(int x=0;x<10;x++)
index[x]=0;
}
}
10、基数排序（Radix Sort）
- 基数排序算法是一种稳定的排序算法。
- 原理： 基数排序是按照低位先排序，然后收集；再按照高位排序，然后再收集；依次类推，直到最高位。有时候有些属性是有优先级顺序的，先按低优先级排序，再按高优先级排序。最后的次序就是高优先级高的在前，高优先级相同的低优先级高的在前。
10.1 算法描述
- 取得数组中的最大数，并取得位数；
- arr为原始数组，从最低位开始取每个位组成radix数组；
- 对radix进行计数排序（利用计数排序适用于小范围数的特点）；
10.2 动图演示
10.3 代码实现
public static void radixSort(int[] arr) {
//获取最大数的位数
int max = 0;
for(int i = 0;i < arr.length; i++) {
if(max < arr[i]) {
max = arr[i];
}
}
int maxLength = (max + "").length();
//建立桶子 二维数组
int [][] tong =new int[10][arr.length];
//建立每个桶子的数的个数
int[] inNumber = new int[10];
//执行操作
for(int i = 0,n = 1; i < maxLength; i++,n*=10) {
//入桶,求出每个元素的位值，然后入桶
for(int j = 0 ; j < arr.length; j++) {
int digOfElement = (arr[j] / n) % 10;
tong[digOfElement][inNumber[digOfElement]] = arr[j];
inNumber[digOfElement]++;//忘了移动索引
}
int index = 0;
//出桶
for(int k = 0; k < inNumber.length; k++) {
if(inNumber[k] != 0) {
//放值
for(int l = 0; l < inNumber[k]; l++) {
arr[index++] = tong[k][l];
}
}
inNumber[k] = 0;
}
}
)
扫一扫
2万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
