目录
简单排序
冒泡排序
原理
- 比较相邻的元素。如果前一个元素比后一个元素大，就交换两个元素的位置。
- 对每一对相邻元素做相同的工作，从开始第一对元素到结尾的最后一对元素。最终最后位置的元素就是最大值。
代码
int main(){
int a[10] = {1,3,2,6,4,7,5,8,9,50};
int i,j,k;
for(i=0;i<9;i++){ //0-9十个数字需要9次冒泡
for(j=0;j<9-i;j++){ //j能到达的最大索引为9-i
if(a[j]>=a[j+1]){
k = a[j+1];
a[j+1] = a[j];
a[j] = k;
}
}
}
for(i=0;i<10;i++){
printf("%d,",a[i]);
}
return 0;
}时间复杂度分析
冒泡排序使用了双层for循环，其中内层循环的循环体是真正完成排序的代码，所以，我们分析冒泡排序的时间复杂度，主要分析内层循环体的执行次数即可。
在最坏的情况下，就是要从小到大排序的元素为{6，5，4，3，2，1}，那么：
元素比较的次数为：
(N+1)+(N+2)+(N+3)+...+2+1=((N-1)+1)*(N-1)/2=N^2/2-N/2;
元素交换的次数为：
(N-1)+(N-2)+(N-3)+...+2+1=(((N-1)+1)*(N-1)/2=N^2/2-N/2;
总执行次数为：
(N^2/2-N/2)+(N^2/2-N/2)=N^2-N;
按照大O推导法则，保留函数中的最高阶项，那么最终冒泡排序的时间复杂度为O(N^2)。
选择排序
原理
- 每一次遍历的过程中，都假定第一个索引处的元素是最小值，和其他索引处的值依次进行比较，如果当前索引处的值大于其他某个索引处的值，则假定其他某个索引处的值为最小值，最后可以找到最小值所在的索引
- 交换第一个索引处和最小值所在的索引处的值
代码
int main(){
int a[8] = {4,6,8,7,9,2,1,10};
for(int i = 0;i<=6;i++){ //8-2
//定义一个变量，记录最小元素所在的索引，默认为参与选择排序的第一个元素所在的位置。
int minIndex = i;
for(int j = i+1;j<=7;j++){ //8
//需要比较最小索引minIndex处的值和索引处的值
if(a[minIndex]>a[j]) {
minIndex = j;
}
}
//交换最小元素所在索引minIndex处的值和索引i处的值
int m;
m = a[i];
a[i] = a[minIndex];
a[minIndex] = m;
}
for(int i = 0;i<8;i++){
printf("%d,",a[i]);
}
return 0;
} 时间复杂度分析
选择排序使用了双层for循环，其中外层循环完成了数据交换，内层循环完成了数据比较，所以我们分别统计数据交换次数和数据比较次数:
数据比较次数:
(N-1)+(N-2)+(N-3)+...+2+1=((N-1)+1)*(N-1)/2=N^2/2-N/2；
数据交换次数:
N-1
时间复杂度:N^2/2-N/2+ ( N-1 )=N^2/2+N/2-1;
根据大O推导法则，保留最高阶项，去除常数因子，时间复杂度为O(N^2);
插入排序
原理
- 把所有元素分为两组，已排序和未排序的；
- 找到未排序的组中的第一个元素，向已经排序的组中进行插入；
- 倒叙遍历已经排序的元素，依次和待插入元素进行比较，知道找到一个元素小于等于待插入元素，那么就把待插入元素放到这个位置，其他元素向后移动一位。
代码
int main(){
int a[8] = {4,3,2,10,12,1,5,6};
for(int i =1;i<8;i++){//遍历待排序元素
for(int j = i;j>0;j--){//倒叙遍历待排序第一个元素和已排序元素 倒叙原因是为了将待排序的第一个元素加上去
if(a[j-1]>a[j]){
int m;
m = a[j];
a[j] = a[j-1];
a[j-1] = m;
}else{
break;
}
}
}
//打印数组元素
for(int i = 0;i<8;i++){
printf("%d,",a[i]);
}
return 0;
}时间复杂度分析
插入排序使里了双层for循环，其中内层循环的循环体是真正完成排序的代码，所以，我们分析插入排序的时间复杂度，主要分析一下内层循环体的执行次数即可。
最坏情况，也就是待排序的数组元素为{12,10,6,5,4,3,2,1}，那么:
比较的次数为:
(N-1)+(N-2)+(N-3)+...+2+1=((N-1)+1)*(N-1)/2=N^2/2-N/2;
交换的次数为:
(N-1)+(N-2)+(N-3)+...+2+1=((N-1)+1)*(N-1)/2=N^2/2-N/2;
总执行次数为:
(N^2/2-N/2)+(N^2/2-N/2)=N^2-N;
按照大O推导法则，保留函数中的最高阶项那么最终插入排序的时间复杂度为O(N^2).
高级排序
希尔排序（插入排序plus）
原理
- 选定一个增长量h，按照增长量h作为数据分组的依据，对数据进行分组；
- 对分好组的每一组数据完成插入排序；
- 减小增长量，最小减为1，重复第二步操作。
增长量h的确定：增长量h的值遵循一个固定的规则，我们这里采用以下规则：
int h = 1;
while(h<数组长度/2){
h = 2h+1;
}
//循环结束后我们就可以确定h的最大值。
h的减小规则为：
h = h/2;代码
int main(){
//1.根据数组a的长度，确定增长量h的初始值。
int h = 1;
int a[10] = {9,1,2,5,7,4,8,6,3,5};
while(h<10/2){
h = 2 * h + 1;
}
//2.希尔排序
while(h>=1){
//排序
//1.找到待插入的元素(所有！)
for(int i = h;i<10;i++){
//2.把待插入的元素插入到有序数列中
for(int j = i;j>=h;j-=h){//（这里插入到相应的组中）
//待插入的元素是a[j],比较a[j]和a[j-h]
if(a[j-h]>a[j]){
//交换元素
int m;
m = a[j-h];
a[j-h] = a[j];
a[j] = m;
} else{
//待插入元素已经找到合适的位置，结束循环。
break;
}
}
}
//减小h的值
h = h/2;
}
for(int i = 0;i<10;i++){
printf("%d,",a[i]);
}
return 0;
} 时间复杂度分析
在希尔排序中，增长量h并没有固定的规则，有很多论文研究了各种不同的递增序列，但都无法证明某个序列是最好的，因此对于希尔排序的时间复杂度，这里就不做分析了。
归并排序
递归
在学习归并排序之前，我们先了解一下什么是递归。
定义
定义方法时，在方法内部调用方法本身，称之为递归。
作用
它通常把一个大型复杂的问题，层层转换为一个与原问题相似的，规模较小的问题来求解。递归策略只需要少量的程序就可以描述出解题过程所需要的多次重复计算，大大减少了程序的代码量。
注意事项
在递归中，不能无限制的调用自己，必须要有边界条件，能够让递归结束，因为每一次递归调用都会在栈内存开辟新的空间，重新执行新方法，如果递归的层级太深，很容易造成栈内存溢出。
举例
int jc(int n){
if(n == 1){
return 1;
}
return n*jc(n-1);
}
int main(){
int n;
scanf("%d",&n);
int m = jc(n);
printf("%d",m);
} 原理
- 尽可能的一组数据拆分成两个元素相等的子组，并对每一个子组继续拆分，直到拆分后的每个子组的元素个数是1为止；
- 将相邻的两个子组进行合并成一个有序的大组；
- 不断的重复步骤2，直到最终只有一个组为止。
代码
void merge(int a[],int lo,int mid,int hi){
int b[8] ;//辅助数组
//定义三个指针
int i = lo;
int p1 = lo;
int p2 = mid + 1;
//遍历移动p1,p2指针，比较对应索引处的值，找出小的那个放到辅助数组的对应索引处
while(p1<=mid && p2<=hi){
//比较对应索引处的值
if(a[p1]<a[p2]){
b[i++] = a[p1++];//b[i] = a[p1];i++;p1++;
} else{
b[i++] = a[p2++];//b[i] = a[p2];i++;p2++;
}
}
//遍历如果p1的指针没有走完，那么顺序移动p1指针，把对应的元素放到辅助数组的对应索引处
while(p1<=mid){
b[i++] = a[p1++];
}
//遍历如果p2的指针没有走完，那么顺序移动p2指针，把对应的元素放到辅助数组的对应索引处
while(p2<=hi){
b[i++] = a[p2++];
}
//把辅助数组中的元素拷贝到原数组中
for(int k = lo;k<=hi;k++){
//!!!注意：这里不能写输入语句，必须要把b数组的值赋值给a数组再在主函数中输出！！！
//因为这个函数嵌套在sort函数内，而sort函数会递归执行，导致此函数也执行多次
//printf("%d,",b[k]);
a[k] = b[k];
}
}
void sort(int a[],int lo,int hi){
//安全性校验
if(hi<=lo){
return ;
}
//对lo到hi之间的数据进行分为两个组
int mid = lo + ((hi - lo)/2);
//分别对每一组数据进行排序
sort(a,lo,mid);
sort(a,mid+1,hi);
// 再把两个组中的数据进行归并
merge(a,lo,mid,hi);
}
int main(){
int a[8] = {8,4,5,7,1,3,6,2};
//定义一个lo和hi变量，分别记录数组中最小的索引和最大的索引；
int lo = 0;
int hi = sizeof(a) / sizeof(a[0]) - 1;
sort(a,lo,hi);
printf("\n");
for(int i = 0;i<8;i++){
printf("%d,",a[i]);
}
} 时间复杂度分析
归并排序是分治思想的最典型的例子，上面的算法中，对a[lo...hi]进行排序，先将它分为a[lo..mid]和a[mid+1...hi]两部分，分别通过递归调用将他们单种排序，最后将有序的子数组归并为最终的排序结。该递归的出口在于如果一个数组不能再被分为两个子数组，那么就会执行merge进行归并，在归并的时候判断元素的大小进行排序。
用树状图来描述归并，如果一个数组有8个元素，那么它将每次除以2找最小的子数组，共拆1og8次，值为3，所以树共有3层,那么自顶向下第k层有2^k个子数组，每个数组的长度为2^(3-k),归并最多需要2^(3-k)次比较。因此每层的比较次数为 2^k* 2^(3-K)=2^3,那么3层总共为 3*2^3。
假设元素的个数为n，那么使用归并排序拆分的次数为log2(n),所以共log2(n)层，那么使用log2(n)替换上面3*2^3中的3这个层数，最终得出的归并排序的时间复杂度为 : log2(n)* 2^log2(n)=lg2(n)*n,根据大O推导法则，忽略底数，最终归并排序的时间复杂度为O(nlogn);
归并排序的缺点
需要申请额外的数组空间，导致空间复杂度提升，是典型的以空间换取时间的操作。
快速排序
原理
- 首先设定一个分界值，通过该分界值将数组分成左右两部分
- 将大于或等于分界值的数据放到到数组右边，小于分界值的数据放到数组的左边。此时左边部分中各元素都小于或等于分界值，而右边部分中各元素都大于或等于分界值;
- 然后，左边和右边的数据可以独立排序。对于左侧的数组数据，又可以取一个分界值，将该部分数据分成左右两部分，同样在左边放置较小值，右边放置较大值。右侧的数组数据也可以做类似处理。
- 重复上述过程，可以看出，这是一个递归定义。通过递归将左侧部分排好序后，再递归排好右侧部分的顺序。当左侧和右侧两个部分的数据排完序后，整个数组的排序也就完成了。
切分原理
把一个数组切分成两个子数组的基本思想：
- 找一个基准值，用两个指针分别指向数组的头部和尾部；
- 先从尾部向头部开始搜索一个比基准值小的元素，搜索到即停止，并记录指针的位置；
- 再从头部向尾部开始搜索一个比基准值大的元素，搜索到即停止，并记录指针的位置；
- 交换当前左边指针位置和右边指针位置的元素；
- 重复2,3,4步骤，直到左边指针的值大于右边指针的值停止。
代码
int partition(int a[],int lo,int hi){
//确定分界值
int key = a[lo];
//定义两个指针，分别指向带切分元素的最小索引处和最大索引处的下一个位置
int left = lo;
int right = hi + 1;
//切分
while(1){
//先从右往左扫描，移动right指针，找到一个比分界值小的元素，停止
while(key < a[--right]){
if(right == lo){
break;
}
}
//先从左往右扫描，移动left指针，找到一个比分界值大的元素，停止
while(a[++left] < key){
if(left == hi){
break;
}
}
//判断left>=right，如果是，则证明元素扫描完毕，结束循环，如果不是，交换元素即可
if(left >= right){
break;
}else{
//交换值
int m;
m = a[right];
a[right] = a[left];
a[left] = m;
}
}
//交换分界值
int n;
n = a[lo];
a[lo] = a[right];
a[right] = n;
return right;
}
//对数组a中从索引lo到索引hi之间的元素进行排序
void sort(int a[],int lo,int hi){
//安全性校验
if(hi<=lo){
return ;
}
// 需要对数组中lo索引到hi索引处的元素进行分组（左子组和右子组）
int partitionn = partition(a,lo,hi);//返回的是分组的分界值所在的索引，分界值位置变化后的索引
//让左子组有序
sort(a,lo,partitionn-1);
//让右子组有序
sort(a,partitionn+1,hi);
}
int main(){
int a[9] = {6,1,2,7,9,3,4,5,8};
int lo = 0;
int hi = sizeof(a) / sizeof(a[0]) - 1;
sort(a,lo,hi);
for(int i =0;i<9;i++){
printf("%d,",a[i]);
}
}时间复杂度分析
快速排序的一次切分从两头开始交替搜索，直到left和right重合，因此，一次切分算法的时间复杂度为(On),但整个快速排序的时间复杂度和切分的次数相关。
最优情况: 每一次切分选择的基准数字刚好将当前序列等分。
如果我们把数组的切分看做是一个树，那么上图就是它的最优情况的图示，共切分了logn次，所以，最优情况下快速排序的时间复杂
度为O(nlogn);
最坏情况:每一次切分选择的基准数字是当前序列中最大数或者最小数，这使得每次切分都会有一个子组，那么总共就得切分n次，所以，最坏情况下，快速排序的时间复杂度为O(n^2);
平均情况:每一次切分选择的基准数字不是最大值和最小值，也不是中值，这种情况我们也可以用数学归纳法证明，快速排序的时间复杂度为O(nlogn),由于数学归纳法有很多数学相关的知识，容易使我们混乱，所以这里就不对平均情况的时间复杂度做证明了。
快速排序和归并排序的区别：
快速排序是另外一种分治的排序算法，它将一个数组分成两个子数组，将两部分独立的排序。快速排序和归并排序是互补的:归并排序将数组分成两个子数组分别排序，并将有序的子数组归并从而将整个数组排序，而快速排序的方式则是当两个数组都有序时，整个数组自然就有序了。在归并排序中，一个数组被等分为两半，归并调用发生在处理整个数组之前，在快速排序中，切分数组的位置取决于数组的内容，递归调用发生在处理整个数组之后。
排序的稳定性
稳定性的定义：
数组arr中有若干元素，其中A元素和B元素相等，并且A元素在B元素前面，如果使用某种排序算法排序后，能够保证A元素依然在B元素的前面，可以说这个算法是稳定的。
稳定性的意义：
如果一组数据只需要一次排序，则稳定性一般是没有意义的，如果一组数据需要多次排序，稳定性是有意义的。例如要排序的内容是一组商品对象，第一次排席按照价格由低到高排席，第二次排席按照销量由高到低排席，如果第二次排序使用稳定性算法，就可以使得相同销量的对象依旧保持着价格高低的顺序展现，只有销量不同的对象才需要重新排序。这样既可以保持第一次排序的原有意义，而且可以减少系统开销。
常见排序算法的稳定性：
冒泡排序 :
只有当arr[i]>arr[it1]的时候，才会交换元素的位置，而相等的时候并不交换位置，所以冒泡排序是一种稳定排序算法。
选择排序：
选择排序是给每个位置选择当前元素最小的,例如有数据{5(1)，8，5(2)，2，9 },第一遍选择到的最小元素为2，所以5(1)会和5(2)行交换位置，此时5(1)到了5(2)后面，破坏了稳定性，所以选择排序是一种不稳定的排序算法。
插入排序:
比较是从有席席列的未尾开始，也就是想要插入的元素和已经有序的最大者开始比起，如果比它大则直接插入在其后面，否则一直往前找直到找到它该插入的位置。如果碰见一个和插入元素相等的，那么把要插入的元素放在相等元素的后面。所以，相等元素的前后顺序没有改变，从原无序序列出去的顺序就是排好序后的顺序，所以插入排序是稳定的。
希尔排序 :
希尔排序是按照不同步长对元素进行插入排序,虽然一次插入排序是稳定的，不会改变相同元素的相对顺序，但在不同的插入排序过程中，相同的元素可能在各自的插入排序中移动，最后其稳定性就会被打乱，所以希尔排序是不稳定的。
归并排序:
归并排房在归并的过程中，只有arr[i]<arr[i+1]的时候才会交位置，如果两个元素相等则不会交换位置，所以它并不会破坏稳定性，归并排序是稳定的。
快速排序：
快速排序需要一个基准值，在基准值的右侧找一个比基准值小的元素，在基准值的左侧找一个比基准值大的元素，然后交换这两个元素，此时会破坏稳定性，所以快速排序是一种不稳定的算法。
3712
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
