目录
排序
排序算法的稳定性：假设在待排序的序列中，有多个相同的关键字，经过排序后，这些关键字的先后顺序不发生改变，我们称这种排序算法是稳定的，否则是不稳定的。
把数据元素全部放在内存中进行排序我们称为内部排序。
元素太多无法全部同时放在内存中，内存和外存相互结合使用的排序我们称为外部排序。
根据排序算法是否基于排序，可以将算法分为两种，而在基于排序的算法中最常见的算法有七种，分别是：直接插入排序，希尔排序，选择排序，堆排序，冒泡排序，快速排序，归并排序。
其中某些排序方法的实现思想相似，我们可进行如下分类：
插入排序： 1.直接插入排序 2.希尔排序
选择排序： 1.选择排序 2.堆排序
交换排序： 1.冒泡排序 2.快速排序
归并排序： 归并排序
1.直接插入排序
直接插入排序是一种简单的插入排序法，其基本思想是：
把待排序的记录按其关键码值的大小逐个插入到一个已经排好序的有序序列中，直到所有的记录插入完为止，得到一个新的有序序列 。
//1.插入排序
public void insort(int[] arr){
for(int i=1;i<arr.length;i++){
int ret=arr[i];
int j=i-1;
for(;j>=0;j--){
if(arr[j]>ret){
arr[j+1]=arr[j];
}else{
break;
}
}
arr[j+1]=ret;
}
}直接插入排序的特性总结：
1. 元素集合越接近有序，直接插入排序算法的时间效率越高
2. 时间复杂度：O(N^2)
3. 空间复杂度：O(1)，它是一种稳定的排序算法
4. 稳定性：稳定
2.希尔排序
因为直接插入排序对于越有序的数组，时间复杂度越低，所以就有大佬发明了希尔排序，希尔排序的作用就是通过分组调整将无序的数组一步一步变得接近有序，最后组数为1时，数组有序。
希尔排序法又称缩小增量法。希尔排序法的基本思想是：
先选定一个整数，把待排序文件中所有记录分成多个组，所有距离为gap的记录分在同一组内，并对每一组内的记录进行排序。然后，取，重复上述分组和排序的工作。当gap=1时，所有记录在统一组内排好序。
//2.希尔排序
public void shellSort(int[] arr){
//gap表示每组元素之间间隔的位置。
int gap= arr.length;
while(gap>1){
gap/=2;
shell(arr,gap);
}
}
private void shell(int[] arr, int gap) {
for(int i=gap;i<arr.length;i++){
int ret=arr[i];
int j=i-gap;
for(;j>=0;j-=gap){
if(arr[j]>ret){
arr[j+gap]=arr[j];
}else{
break;
}
}
arr[j+gap]=ret;
}
}希尔排序的特性总结：
1. 希尔排序是对直接插入排序的优化。
2. 当gap > 1时都是预排序，目的是让数组更接近于有序。当gap == 1时，数组已经接近有序的了，这样就会很快。这样整体而言，可以达到优化的效果。
3. 希尔排序的时间复杂度与gap的取值有关，很难直接计算，根据Knuth在《计算机程序设计技巧》中的说明，当n很大时，时间复杂度可按O(N^1.25)到O(1.6*N^1.25)来计算。
4.稳定性：不稳定。
3.直接选择排序
基本思想：
每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完 。
//3.直接选择排序
public void chooseSort(int[] arr){
for(int i=0;i<arr.length;i++){
for(int j=i+1;j<arr.length;j++){
if(arr[j]<arr[i]){
int ret=arr[i];
arr[i]=arr[j];
arr[j]=ret;
}
}
}
}
特性总结：
1. 直接选择排序思考非常好理解，但是效率不是很好。实际中很少使用
2. 时间复杂度：O(N^2)
3. 空间复杂度：O(1)
4. 稳定性：不稳定
4.堆排序
堆排序(Heapsort)是指：
利用堆积树（堆）这种数据结构所设计的一种排序算法，它是选择排序的一种。它是通过堆来进行选择数据。需要注意的是排升序要建大堆，排降序建小堆。
详细代码实现过程请看我的上一篇文章对堆进行了详细讲解：【数据结构七】堆与PriorityQueue详解
特性总结：
1. 与直接选择排序相比，堆排序使用堆来选数，效率就高了很多。
2. 时间复杂度：O(N*logN)
3. 空间复杂度：O(1)
4. 稳定性：不稳定
5.冒泡排序
基本思想：
冒泡排序是一种典型的交换排序，根据序列中两个相邻记录键值的比较结果来对换这两个记录在序列中的位置 。交换排序的特点是：将键值较大的记录向序列的尾部移动，键值较小的记录向序列的前部移动。
//5.冒泡排序
public void bubbleSort(int[] arr){
for(int i=arr.length-1;i>0;i--){
for(int j=0;j<i;j++){
if(arr[j+1]<arr[j]){
int tmp=arr[j+1];
arr[j+1]=arr[j];
arr[j]=tmp;
}
}
}
}冒泡排序的特性总结：
1. 冒泡排序是一种非常容易理解的排序
2. 时间复杂度：O(N^2)
3. 空间复杂度：O(1)
4. 稳定性：稳定
6.快速排序
快速排序是在二叉树的前序遍历的基础上改进的一个算法，取基准值时要尽量保证左右两个区间的大小相等，这样的时间复杂度最低，在构建代码的时候我们尽量依据这一点来优化代码。
基本思想：
任取待排序元素序列中的某元素作为基准值，按照该排序码将待排序集合分割成两子序列，左子序列中所有元素均小于基准值，右子序列中所有元素均大于基准值，然后最左右子序列重复该过程，直到所有元素都排列在相应位置上为止。
//6.快速排序
public void quickSort(int[] arr){
quick(arr,0,arr.length-1);
}
//快速排序的主要实现
private void quick(int[] arr, int left, int right) {
if(right-left<1){
return;
}
int prev=midnum(arr,left,right);
int tmp=arr[prev];
int cur1=left;
int cur2=right;
while(cur1<cur2){
while (cur1<cur2&&arr[cur2]>=tmp){
cur2--;
}
while (cur1<cur2&&arr[cur1]<=tmp){
cur1++;
}
swap(arr, cur1, cur2);
}
swap(arr,left,cur1);
quick(arr,left,cur1);
quick(arr,cur1+1,right);
}
//交换两个元素位置
private static void swap(int[] arr, int cur1, int cur2) {
int tmp= arr[cur1];
arr[cur1]= arr[cur2];
arr[cur2]=tmp;
}
//创建一个方法求三个值的中间值，为了优化算法。
private int midnum(int[] arr,int left,int right){
int mid=(left+right)/2;
if(arr[left]<arr[right]){
if(arr[mid]<arr[left]){
return left;
}else if(arr[mid]>arr[right]){
return right;
}else{
return mid;
}
}else{
if(arr[mid]<arr[right]){
return right;
}else if(arr[mid]>arr[left]){
return left;
}else{
return mid;
}
}
}特性总结：
1.快速排序整体的综合性能和使用场景都是比较好的。
2. 时间复杂度：O(N*logN)
3. 空间复杂度：O(logN)
4. 稳定性：不稳定
7.归并排序
归并排序是建立在归并操作上的一种有效的排序算法,该算法是采用分治法的一个非常典型的应用。
基本思想：
将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。
//7.归并排序
public void mergeSort(int[] arr){
mergeSortFun(arr,0,arr.length-1);
}
private void mergeSortFun(int[] arr, int left, int right) {
if(left>=right){
return;
}
int mid=(left+right)/2;
mergeSortFun(arr,left,mid);
mergeSortFun(arr,mid+1,right);
merge(arr,left,mid,right);
}
private void merge(int[] arr, int left, int mid, int right) {
int s1=left;
int e1=mid;
int s2=mid+1;
int e2=right;
int[] tmpArr=new int[right-left+1];
int k=0;
while(s1<=e1&&s2<=e2){
if(arr[s1]<=arr[s2]){
tmpArr[k]=arr[s1];
s1++;
k++;
}else{
tmpArr[k]=arr[s2];
s2++;
k++;
}
}
while(s1<=e1){
tmpArr[k]=arr[s1];
s1++;
k++;
}
while(s2<=e2){
tmpArr[k]=arr[s2];
s2++;
k++;
}
for(int i=0;i< tmpArr.length;i++){
arr[i+left]=tmpArr[i];
}
}
特性总结：
1. 归并的缺点在于需要O(N)的空间复杂度，归并排序的思考更多的是解决在磁盘中的外排序问题。
2. 时间复杂度：O(N*logN)
3. 空间复杂度：O(N)
4. 稳定性：稳定
欢迎大家点赞加关注啊！！！，随后会更新非基于比较的算法，基数排序，桶排序和计数排序。
8658
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
