1. 插入排序
步骤：
1.从第一个元素开始，该元素可以认为已经被排序
2.取下一个元素tem，从已排序的元素序列从后往前扫描
3.如果该元素大于tem，则将该元素移到下一位
4.重复步骤3，直到找到已排序元素中小于等于tem的元素
5.tem插入到该元素的后面，如果已排序所有元素都大于tem，则将tem插入到下标为0的位置
6.重复步骤2~5
思路：
在待排序的元素中，假设前n-1个元素已有序，现将第n个元素插入到前面已经排好的序列中，使得前n个元素有序。按照此法对所有元素进行插入，直到整个序列有序。
但我们并不能确定待排元素中究竟哪一部分是有序的，所以我们一开始只能认为第一个元素是有序的，依次将其后面的元素插入到这个有序序列中来，直到整个序列有序为止。
代码如下：
public static void insertSort(int[] array){
for (int i = 1; i < array.length; i++) {
int tmp=array[i];
int j = i-1;
for (; j >= 0; j--) {
if (array[j] < tmp) {
array[j + 1] = array[j];
} else {
break;
}
}
array[j+1]=tmp;
}
}时间复杂度：最坏情况下为O(N*N)，此时待排序列为逆序，或者说接近逆序
最好情况下为O(N)，此时待排序列为升序，或者说接近升序。
空间复杂度：O(1)
2.希尔排序
步骤：
1.先选定一个小于N的整数gap作为第一增量，然后将所有距离为gap的元素分在同一组，并对每一组的元素进行直接插入排序。然后再取一个比第一增量小的整数作为第二增量，重复上述操作…
2.当增量的大小减到1时，就相当于整个序列被分到一组，进行一次直接插入排序，排序完成。
思路：
希尔排序，先将待排序列进行预排序，使待排序列接近有序，然后再对该序列进行一次插入排序，此时插入排序的时间复杂度为O(N)
代码如下：
public static void shellSort(int[] array){
int gap= array.length;
while (gap>1){
gap/=2;
shell(array,gap);
}
}
private static void shell(int[] array,int gap){
for (int i = 1; i < array.length; i++) {
int tmp=array[i];
int j = i-gap;
for (; j < array.length; j--) {
if (array[j] < tmp) {
array[j + gap] = array[j];
} else {
break;
}
}
array[j+gap]=tmp;
}
}时间复杂度平均：O(N^1.3)
空间复杂度：O(1)
3.选择排序
思路：
每次从待排序列中选出一个最小值，然后放在序列的起始位置，直到全部待排数据排完即可。
实际上，我们可以一趟选出两个值，一个最大值一个最小值，然后将其放在序列开头和末尾，这样可以使选择排序的效率快一倍。
代码如下：
public static void selecSort2(int[] array){
int left=0;
int right= array.length-1;
while (left<right){
int min=left;
int max=right;
for (int i = left+1; i <=right; i++) {
if (array[i]<array[min]){
min=i;
}
if (array[i]>array[max]){
max=i;
}
}
swap(array,left,min);
if (max==left){
max=min;
}
swap(array,right,max);
}
}时间复杂度：最坏情况：O(N^2)
最好情况：O(N^2)
空间复杂度：O(1)
4.冒泡排序
思路：
左边大于右边交换一趟排下来最大的在右边
代码如下：
public static void bubbleSort(int[] array){
for (int i = 0; i < array.length-1; i++) {
boolean ret=false;
for (int j = 0; j < array.length-1-i; j++) {
if (array[j]>array[j+1]){
swap(array,j,i);
ret=true;
}
}
if (!ret){
break;
}
}
}时间复杂度：最坏情况：O(N^2)
最好情况：O(N)
空间复杂度：O(1)
5.快速排序
5.1 hoare版本(左右指针法)
思路：
1、选出一个key，一般是最左边或是最右边的。
2、定义一个begin和一个end，begin从左向右走，end从右向左走。（需要注意的是：若选择最左边的数据作为key，则需要end先走；若选择最右边的数据作为key，则需要bengin先走）。
3、在走的过程中，若end遇到小于key的数，则停下，begin开始走，直到begin遇到一个大于key的数时，将begin和right的内容交换，end再次开始走，如此进行下去，直到begin和end最终相遇，此时将相遇点的内容与key交换即可。（选取最左边的值作为key）
4.此时key的左边都是小于key的数，key的右边都是大于key的数
5.将key的左序列和右序列再次进行这种单趟排序，如此反复操作下去，直到左右序列只有一个数据，或是左右序列不存在时，便停止操作，此时此部分已有序
代码如下：
private static int partition1(int[] array,int start,int end){
int i=start;
int pivot=array[start];
while (start<end){
while (start<end&&array[end]>=pivot){
end--;
}
while (start<end&&array[end]<=pivot){
start++;
}
swap(array,start,end);
}
swap(array,i,start);
return start;
}时间复杂度:
5.2 挖坑法
5.2.1 递归
思路：
挖坑法思路与hoare版本(左右指针法)思路类似
1.选出一个数据（一般是最左边或是最右边的）存放在key变量中，在该数据位置形成一个坑
2、还是定义一个L和一个R，L从左向右走，R从右向左走。（若在最左边挖坑，则需要R先走；若在最右边挖坑，则需要L先走）
private static int partition(int[] array,int start,int end){
int pivot=array[start];
while (start<end){
while (start<end&&array[end]>=pivot){
end--;
}
array[start]=array[end];
while (start<end&&array[start]<=pivot){
start++;
}
array[end]=array[start];
}
array[start]=pivot;
return start;
}5.2.2 非递归
private static int midThreeNum(int[] array,int start,int end){
int mid=(start+end)/2;
if (array[start]<array[end]){
if (array[mid]<array[start]){
return start;
} else if (array[mid]>array[end]) {
return end;
}else {
return mid;
}
}else {
if (array[start]<array[mid]){
return start;
} else if (array[end]>array[mid]) {
return end;
}else {
return mid;
}
}
}5.3 前后指针法
思路：
1、选出一个key，一般是最左边或是最右边的。
2、起始时，prev指针指向序列开头，cur指针指向prev+1。
3、若cur指向的内容小于key，则prev先向后移动一位，然后交换prev和cur指针指向的内容，然后cur指针++；若cur指向的内容大于key，则cur指针直接++。如此进行下去，直到cur到达end位置，此时将key和++prev指针指向的内容交换即可。
经过一次单趟排序，最终也能使得key左边的数据全部都小于key，key右边的数据全部都大于key。
然后也还是将key的左序列和右序列再次进行这种单趟排序，如此反复操作下去，直到左右序列只有一个数据，或是左右序列不存在时，便停止操作
private static int partition2(int[] array,int left,int right){
int prev=left;
int cur=left+1;
while (cur<=right){
if (array[cur]<array[left]&&array[++prev]!=array[cur]){
swap(array,cur,prev);
}
cur++;
}
swap(array,prev,left);
return prev;
}
public static void quickSort1(int[] array){
int left=0;
int right=array.length-1;
int par=partition(array,left,right);
Stack<Integer> stack=new Stack<>();
if (par>left+1){
stack.push(left);
stack.push(par-1);
}
if (par<right-1){
stack.push(par+1);
stack.push(right);
}
while (!stack.isEmpty()){
right=stack.pop();
left=stack.pop();
par=partition(array,left,right);
if (par>left+1){
stack.push(left);
stack.push(par-1);
}
if (par<right-1){
stack.push(par+1);
stack.push(right);
}
}
}6.归并排序
归并排序，是创建在归并操作上的一种有效的排序算法。算法是采用分治法（Divide and Conquer）的一个非常典型的应用，且各层分治递归可以同时进行。归并排序思路简单，速度仅次于快速排序，为稳定排序算法，一般用于对总体无序，但是各子项相对有序的数列。
1. 基本思想
归并排序是用分治思想，分治模式在每一层递归上有三个步骤：
分解（Divide）：将n个元素分成个含n/2个元素的子序列。
解决（Conquer）：用合并排序法对两个子序列递归的排序。
合并（Combine）：合并两个已排序的子序列已得到排序结果。
2. 实现逻辑
2.1 迭代法
① 申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列
② 设定两个指针，最初位置分别为两个已经排序序列的起始位置
③ 比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置
④ 重复步骤③直到某一指针到达序列尾
⑤ 将另一序列剩下的所有元素直接复制到合并序列尾
2.2 递归法
① 将序列每相邻两个数字进行归并操作，形成floor(n/2)个序列，排序后每个序列包含两个元素
② 将上述序列再次归并，形成floor(n/4)个序列，每个序列包含四个元素
③ 重复步骤②，直到所有元素排序完毕
3. 复杂度分析
平均时间复杂度：O(nlogn)
最佳时间复杂度：O(n)
最差时间复杂度：O(nlogn)
空间复杂度：O(n)
排序方式：In-place
稳定性：稳定
不管元素在什么情况下都要做这些步骤，所以花销的时间是不变的，所以该算法的最优时间复杂度和最差时间复杂度及平均时间复杂度都是一样的为：O( nlogn )
归并的空间复杂度就是那个临时的数组和递归时压入栈的数据占用的空间：n + logn；所以空间复杂度为: O(n)。
归并排序算法中，归并最后到底都是相邻元素之间的比较交换，并不会发生相同元素的相对位置发生变化，故是稳定性算法。
4.代码实现
public static void mergeSort(int[] array){
mergeSortFunc(array,0,array.length-1);
}
public static void mergeSortFunc(int[] array,int left,int right){
if (left==right){
return;
}
int mid=(left+right);
//分解
mergeSortFunc(array,left,mid);
mergeSortFunc(array,mid+1,right);
//合并操作
merge(array,left,right,mid);
}
private static void merge(int[] array,int left,int right,int mid){
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 (array[s1]<=array[s2]){
tmpArr[k++]=array[s1++];
}else {
tmpArr[k++]=array[s2++];
}
}
while (s1<=e1){
tmpArr[k++]=array[s1++];
}
while (s2<=e2){
tmpArr[k++]=array[s2++];
}
}
扫一扫
706
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
