草根逆袭之排序算法

排序算法

选择排序

基本思想：
每一次循环，找出比要比较的数据大（小）的数据进行交换，使得一次结束后前半部分为有序
完整代码：

#include<iostream>
using namespace std;
int main()
{
    int a[6]={0,6,7,5,3,9};
    int i,j,t;
    for(i=0;i<6;i++)
    {
        for(j=i+1;j<6;j++)
        {
            if(a[i]>a[j])//由排序顺序确定
            {
                t=a[i];
                a[i]=a[j];
                a[j]=t;
            }
        }
    }
    for(i=0;i<6;i++)
        cout<<a[i]<<" ";
    return 0;
}

稳定性：
此过程中元素的相对位置发生了改变，为不稳定排序
时间复杂度：O(n*n);
空间复杂度：O(1);

计数排序(桶排序)

基本思想：
桶是有序号有顺序的，让相应数据对号入座，再将桶按顺序倒出
完整代码：

#include<iostream>
using namespace std;
int main()
{
    int a[20]={0};
    int n,m;
    cin>>n;
    for(int i=0;i<n;i++)
    {
        cin>>m;
        a[m]++;
    } 
    for(int i=0;i<20;i++)
    {
        while(a[i]>0)
        {
            cout<<i;
            a[i]--;
        }
    } 
    return 0;
}

计数排序的优点：
速度快，时间复杂度为O(n);
计数排序的缺点：
若待排序列中元素范围跨度较大时，空间占用很大(数组下标开的很大)。且不能直接排负数。

插入排序

完整代码：

#include<iostream>
using namespace std;
int main()
{
    int a[6]={5,6,8,3,6,9};
    int n=6;
    int i,j;
    for(i=1;i<n;i++)
    {
        for(j=i;j>0;j--)
        {
            if(a[j]<a[j-1])
            swap(a[j],a[j-1]);
            else break;
        }
    }
    for(i=0;i<n;i++)
        cout<<a[i]<<" ";
    return 0;
}

特性：
稳定排序
时间复杂度：O(n*n);
空间复杂度：O(1);

冒泡排序

要点：
前后两个进行比较，符合条件进行交换。
完整代码：

#include<iostream>
using namespace std;
int main()
{
    int a[5]={9,2,5,7,5};
    int n=5;
    for(int i=0;i<n;i++)
    {
        int c=0;
        for(int j=0;j<n-i-1;j++)
        {
            if(a[j]<a[j+1])
            {
                swap(a[j+1],a[j]);
                c=1;
            }
        }
        if(c==0) break;
    }
    for(int i=0;i<n;i++)
    cout<<a[i]<<" ";
    return 0;
}

特性：
稳定排序
时间复杂度：O(n*n);
空间复杂度：O(1);

归并排序

基本思路：
通过分块治理，现将分开的部分变得有序，在进行合并比并。
完整代码：

#include<iostream>
using namespace std;
int a[8]={1,3,6,5,9,8,47,85};
int b[8]={0};
void msort(int l,int r)
{
   if(l==r)  return;
   int mid=(l+r)>>1;
   msort(l,mid);  msort(mid+1,r);
   int i=l,j=mid+1,k=0;
   while(i<=mid&&j<=r)
   {
       if(a[i]<=a[j])
       {
           b[k]=a[i];
           i++;
       }
       else
       {
           b[k]=a[j];
           j++;
       }
       k++;
   }
   while(i<=mid) b[k++]=a[i++];
   while(j<=r)   b[k++]=a[j++];
   for(i=1;i<r;i++)
       b[i]=a[i];
}
int main()
{
   int n=8;
   msort(0,n-1);
   for(int i=0;i<n;i++)
       cout<<a[i]<<" ";
   return 0;
}

归并排序的特征：
稳定排序
时间复杂度：O(nlogn);
时间复杂度：O(n)，因采用递归，还需要占用栈空间。
经典用例 逆序对

快速排序

#include<iostream>
using namespace std;
int a[8]={1,2,5,6,4,8,7,5};
void qsort(int l,int r)
{
 int i=l,j=r;
 int mid=a[(l+r)>>1];
 do{
 	while(a[i]<mid) i++;
 	while(a[j]>mid) j--;
 	if(i<=j)
 	{
 		swap(a[i],a[j]);
 		i++;
 		j--;
 	}
 }while(i<=j);
 if(j>l)  qsort(l,j);
 if(i<r)  qsort(i,r);
}
int main()
{
 int n=8;
 qsort(0,n-1);
 for(int i=0;i<n;i++)
     cout<<a[i]<<" ";
 return 0;
}