排序算法汇总

冒泡排序
基本思想：两两比较待排序的数，发现反序时交换，直到没有反序为止。

public static void BubbleSort(int[] R)
{
    for (int i = 0; i < R.Length - 1; i++)
    {
        bool noswap = true;
        for (int j = 0; j < R.Length - 1-i; j++)
        {
            if (R[j] > R[j + 1])
            {
                int temp = R[j];
                R[j] = R[j + 1];
                R[j + 1] = temp;
                noswap = false;
            }
        }
        if (noswap)
        {
            break;
        }
    }
}

快速排序

基本思想：在待排序数列中任选出一个数作为基准，用这个基准将数列划分为左右两个子区，使得左子区的数都不大于基准数，而右子区的数都不小于基准数,称为完成第一次划分。如果左子区或右子区不为空，则对它进行同样的划分，直至为空为止。  

public static void QUICKSORT(int[] N,int left,int right)
{
    //数组元素如果不大于一个就无需排序。
    if (left < right)
    {
        int p = PARTITION(N, left, right);  //第一次划分
        QUICKSORT(N, left, p-1);    //递归处理左子区
        QUICKSORT(N, p+1, right);   //递归处理右子区
    }     
}
//划分
public static int PARTITION(int[] R, int left,int right)
{
    int i = left;
    int j = right;
    int temp = R[i];
    while (i != j)
    {
        //从左往右扫描，查找第一个比基准数小的数
        while ((R[j] >= temp) && (i<j))
        { 
            j--; 
        }
        if (i < j)                
        { 
            //交换找到的数和基准数，由于基准数还需交换多次，所以暂时不用将temp->R[j]
            R[i] = R[j];
            i++;
        }

        while ((R[i] <= temp) && (i < j))
        { 
            i++; 
        }
        if (i< j)
        { 
            R[j] = R[i];
            j--;
        }
    }
    //定位基准数
    R[i] = temp;
    return i;    
}

直接选择排序

基本思想：每次从无序数组中选出一个最小的出来，放到已排好序的数组的最后。

public static void SELECTSORT(int[] R)
{   
    for (int i = 0; i < R.Length-1; i++)
    {
        int index = i;
        for (int j = i + 1; j < R.Length; j++)
        {
            if (R[j] < R[index])
            {
                index = j;
            }
        }
        //交换R[i]和R[index]
         if (index != i)
        {
            int t = R[i]; R[i] = R[index]; R[index] = t;
        }
    }    
}

插入排序

基本思想：首先将数组的第一个数sortArray[0]看成是有序的，然后从第二个元素开始和它前面的元素进行比较，如果比前面的某一个数大，就交换。由于前面的元素是有序的，所以就使有序元素的个数逐渐增大，直到等于n。

public void Sort(int[] sortArray)
{
    int j = 0;
    int key = 0;   // key为哨兵
    for (int i = 1; i < sortArray.Length; i++)     //[0..i-1]已经排好的有序列
    {
        if (sortArray[i] < sortArray[i - 1])
        {
            key = sortArray[i];
            j = i - 1;
            while (j >= 0 && key < sortArray[j]) //当sortArray[i] ≥sortArray[j] 时终止
            { 
                sortArray[j + 1] = sortArray[j];
                j--;
            }    
            sortArray[j + 1] = key;  //插入到j的后面
        }
    }
}

希尔排序

基本思想：通过一个逐渐减小的增量使一个数组逐渐趋近于有序从而达到排序的目的。

public void SortShell(int [] list)
 {
     int i;
     for(i=1;i<=list.Length/9;i=3*i+1);
     for(;i>0;i/=3)
     {
         for(int i=i+1;i<=list.Length;i+=inc)
        {
            int t=list[i-1];
            int j=i;
            while((j>inc)&&(list[j-inc-1]>t))
            {
                list[j-1]=list[j-inc-1];
                j-=inc;
            }
            list[j-1]=t;
        }
    }
}

堆排序

基本思想：记录区的分为无序区和有序区前后两部分；用无序区的数建大根堆，得到的根（最大的数）和无序区的最后一个数交换，也就是将该根归入有序区的最前端；如此重复下去，直至有序区扩展至整个记录区。

堆排序步骤：
第一步，根据初始输入数据，利用堆的调整算法形成初始堆。
第二步，通过一系列的记录交换和重新调整堆进行排序。
最大堆的向下调整算法：
调用了O(n)次Adjust()算法，堆排序的时间复杂性为O(nlog2n)。
该算法的附加存储主要是执行记录交换时所用的一个临时记录。
因此，该算法的空间复杂性为O(1)。
堆排序是一个不稳定的排序方法。

#include <stdio.h>
void swap(int &x, int &y)
{
    int temp = x;
    x = y;
    y = temp;
}
void Adjust(int *a, int parent, int high)
{
    int l = 2 * parent + 1;
    int r = l + 1;
    int flag = parent;
 
    if (l<=high && a[l]>a[flag]) 
    {
        flag = l;
    }
    if (r<=high && a[r]>a[flag]) 
    {
        flag = r;
    }
    if (flag != parent)
    {
        swap(a[parent], a[flag]);
        Adjust(a, flag, high);
    }
} 
void HeapSort(int *a, int n)
{
    int i;
 
    for (i=n-1; i>=0; i--) 
    {
        Adjust(a, i, n - 1);
    }
    for (i=n-1; i>=0; i--) 
    {
        swap(a[0], a[i]);
        Adjust(a, 0, i - 1);
    }
}
void Output(int *a, int n)
{
    int i;
    for (i=0; i<n; i++) 
    {
        printf("\t%d", a[i]);
    }
    printf("\n");
}
int main()
{
    int a[] = { 49, 38, 65, 97, 76, 13, 27, 49 };
    int n = 8;
 
    Output(a, n);
    HeapSort(a, n);
    Output(a, n);
 
    return 0;
}
 
/*
        49      38      65      97      76      13      27      49
        13      27      38      49      49      65      76      97
*/