常见排序算法大全

声明：本节全称利用一维数组展开讨论，排列后结果均为由小到大
1、直接插入排序
思想：数据r[0]到r[i-1]是有序的，r[i]到r[n-1]是任意次序的。将r[i]插入到r[0]到r[i-1]中并使得r[0]到r[i]有序。i从1开始到结束进行n-1次。

//直接插入排序
//时间复杂度O(n^2),空间复杂度O(1)，稳定
void InsertSort(int *a,int n)
{
    int i,j;
    for(i=1;i<n;i++)//控制次数
    {
        int key = a[i];//挖坑
        for(j=i-1;j>=0;j--) //找插入位置
        {
            if(key<a[j])
            {
              a[j+1] = a[j];
            }
            else
            {
                break;
            }

        }
        //上面出循环是j--
        a[j+1] = key;
    }
}

2.折半插入排序
思想：在有序部分使用二叉查找方法确定插入位置，其他同上

//折半插入排序
//时间复杂度O(n^2),空间复杂度O(1)，稳定
void BinSort(int *a,int n)
{
    int low ;
    int high ;
    int mid;
    int i,j,key;
    for(i=1;i<n;i++)//控制次数
    {
        key = a[i];
        low = 0;
        high = i-1;
        while(low<=high)
        {
          mid = (low+high)/2;
          if(key<a[mid])
          {
             high = mid-1;
          }
          else
              low = mid+1;
        }
        for(j = i-1;j>=low;j--)
        {
          a[j+1] = a[j];
        }
        a[low] = key;
    }
}

3.Shell排序
思想：比较每组两端的元素，后面的大则进行交换，依次进行
1) 选定记录间的距离为d1在整个待排序记录序列中将所有间隔为d1的记录
分成一组，进行组内直接插入排序；
2) 取记录间的距离为d2(d2

//shell排序
//时间复杂度O(n^1.5),空间复杂度O(1)，不稳定
void shell(int *a,int n,int d)
{
    int i,j,key;
    while(d>0)
    {
        for(i=d;i<n;i++)
        {
            int key = a[i];
            for(j=i-d;j>=0;j-=d) //找插入位置
            {
                if(key<a[j])
                {
                    a[j+d] = a[j];
                }
                else
                {
                    break;
                }

            }
            a[j+d] = key;
        }
        d-=2;
    }
}

4.起(冒）泡排序
思想：
依次比较相邻两个元素，如果后面的数大，则进行交换，每一趟都将最大的数下沉到最低端，共进行n-1趟

//冒泡排序
//时间复杂度O(n^2),空间复杂度O(1)
void bubblesort(int *r,int length)
{                int i,j,temp;
    for(i=0;i<length-1;i++)
        for(j=0;j<length-1-i;j++)
        {
            if(r[j]>r[j+1])
            {
                temp = r[j];
                r[j] = r[j+1];
                r[j+1] =  temp;
            }
        }
}

5.快速排序
思想：若序列中有n个元素，将第一个数据作为支点，将它放在表中合适的位置。以支点为界，序列分成两部分。其中左边数据小于等于支点，右半部分数据大于等于支点。然后，对左右两部分分别进行递归处理，直至排好序为止。

//快速排序
//时间复杂度O(nlog2(n)),空间复杂度：需栈空间以实现递归,最坏情况：S(n)=O(n),一般情况：S(n)=O(log2n)
void QSort(int *a,int low,int high)
{
   int i = low;
   int j = high;
   int temp;
   if(i<j)
   {
       int x = a[i];
       while(i<j)
       {
           //支点为i
         while(i<j&&x<=a[j])
         {
           j--;
         }
         if(i<j)
         {
             //交换
        //   temp = a[i];
        //   a[i] = a[j];
        //   a[j] = temp;
             a[i] = a[j];
             i++;
         }
         //支点为j
         while(i<j&&a[i]<=x)
         {
            i++;
         }
         if(i<j)
         {
            //交换
            // temp = a[i];
            // a[i] = a[j];
            // a[j] = temp;
             a[j] = a[i];
             j--;
         }

       }
        a[i] = x;
       QSort(a,low,i-1);
       QSort(a,i+1,high);
   }
}

6.选择排序
思想：每一趟在n-i+1(i=1,2,3,…,n-1)个记录中选取关键字最小的记录作为有序序列中第i个记录。

//简单选择
//时间复杂度O(n^2),空间复杂度O(1)
void Select(int *a,int n)
{
    int i,j,k,min,temp;
    for(i=0;i<n-1;i++)
    {
        //选最小
        min = a[i];
        k = i;
        for(j=i;j<n;j++)
        {
          if(min>a[j])
          {
              min = a[j];
              k = j;
          }
        }
        //交换
        temp = a[i];
        a[i] = a[k];
        a[k] = temp;
    }
}

7.堆排
思想：把待排序记录的关键字存放在数组r中，将r看成一棵完全二叉树的顺序表示，每个结点表示一个记录，第一个记录r[1]作为二叉树的根，以下各记录依次逐层从左到右顺序排列，任意结点r[i]的左孩子是r[2i]，右孩子是r[2i+1]，双亲是r[i/2]。对这棵完全二叉树进行调整建堆。
堆的定义：
n 元素的序列 { k1， k2 ，…… ， kn }，当且仅当对任一ki满足以下关系时，称之为堆：
ki <= k2i ki >= k2i
ki <= k2i+1 ki >= k2i+1
且分别称之为最小化堆和最大化堆。

算法：
a.将待排序记录按照堆的定义建初堆；
b.将堆顶元素与堆中最后一位元素交换。调整剩余的记录序列，将前n-i个元素重新建成为一个新堆；
c.重复步骤b，进行n-1次。

//堆排
//时间复杂度O(nlog2n)，空间复杂度O(1),不稳定，n越大越好
void Adjust(int *a,int n)
{
    int i,j,temp;
    for(i=(n-1)/2;i>0;i--)
    {
      j = 2*i;
      if(j+1<n)  //左右都有
      {
          if(a[j+1]>a[j])
          {
             j = j+1;
          }
      }
      if(a[i]<a[j])
      {
          //交换
          temp = a[i];
          a[i] = a[j];
          a[j] = temp;
      }
    }

}
void HeapSort(int *a,int n)
{
    int i,temp;
    for(i=0;i<n-1;i++)
    {
      Adjust(a,n-i);
     //交换
     temp = a[1];
     a[1] = a[n-1-i];
     a[n-1-i] = temp;
    }

}

8.归并排序
思想：将已排序的若干个表合并成一个有序表。当将两个有序表归并为一个时称为2-路归并。
排序：开始将数据看成长度为1的有序表，两两归并为长度为2的表，依次类推直到长度为n的有序表

//归并排序
//时间复杂度O(nlogn)，空间复杂度O(n)
void Merge(int *a,int low,int mid,int high,int *temp)
{
    int i = low;
    int j = mid;
    int m = mid+1;
    int n = high;
    int k = 0;
    while(i<=j&&m<=n)
    {
       if(a[i]<a[m])
       {
          temp[k++] = a[i];
          i++;
       }
       else
       {
         temp[k++] = a[m];
          m++;
       }
    }
    while(m<=n)
    {
       temp[k++] = a[m++];
    }
    while(i<=j)
    {
      temp[k++] = a[i++];
    }
    for(i=0;i<k;i++)
    {
      a[low+i] = temp[i];
    }
}
void MSort(int *a,int first,int last,int *temp)
{
    int mid;
    if(first<last)
    {
      mid = (first+last)/2;
      MSort(a,first,mid,temp);
      MSort(a,mid+1,last,temp);
      Merge(a,first,mid,last,temp);
    }

}