排序合集

/*======================================
冒泡排序，快速排序
直接插入排序，折半插入排序，希尔排序
简单选择排序，堆排序
归并排序
2013-08-10 By Mei
=======================================*/

#include <iostream>
#define True 1
#define False 0
#define min(x, y) ((x)>(y)?(y):(x))
using namespace std;

void print(int a[], int n)
{
    for(int i=0; i<n; ++i)
        cout<<a[i]<<" ";
    cout<<endl;
}

// ==========================冒泡排序
void BubbleSort(int a[], int n)
{
  for(int i=n-1; i>=0; --i)
  {
    bool change = True;
    for(int j=0; j<i; ++j)
    {
        if(a[j]>a[j+1])
        {
            change = False;
            int temp = a[j];
            a[j] = a[j+1];
            a[j+1] = temp;
        } 
    }
    if(change)
        break;
  }
  print(a, n);
}

// ==========================快速排序
int partition(int a[], int low, int high)
{
    int temp = a[low];
    while(low<high)
    {
        while(low<high && a[high]>=temp)
        //等号必须写 ，否则会陷入无限循环之中
            high--;
        a[low] = a[high];
        while(low<high && a[low]<=temp)
            low++;
        a[high] = a[low];
    }
    a[low] = temp;
    return low;
}
void qsort(int a[], int low, int high)
{
    if(low < high)
    {
        int s = partition(a, low, high);
        qsort(a, low, s-1);
        qsort(a, s+1, high);
    }
}

void quicksort(int a[], int n)
{
    qsort(a, 0, n-1);
    print(a, n);
}

//==========================直接插入排序
int InsertSort(int a[], int n)
{
    int i, j;
    // for(i=1; i<n; ++i)
    // {
    //     int temp = a[i];
    //     for(j=i-1; j>=0; --j)
    //     {
    //         if(a[j]<=temp)
    //         {
    //             break;  
    //         }
    //     }
    //     if(j != i-1)
    //     {
    //         for(int k=i-1; k>j; --k)
    //         {
    //             a[k+1]=a[k];
    //         }
    //         a[j+1]=temp;
    //     }
    // }
    //后移与比较操作放在一起进行
    for(i=1; i<n; ++i)
    {
        if(a[i]<a[i-1])
        {
            int temp = a[i];
            for(j=i-1; j>=0 && a[j]>temp; --j)
            {
                a[j+1] = a[j];
            }
            a[j+1] = temp;
        }
    }
    print(a, n);
}

//==========================折半插入排序
int find_position(int a[], int low, int high, int value)
{
    while(low<=high)
    {
        int middle = (low + high)/2;
        if(a[middle]<value)
            low = middle + 1;
        else
            high = middle - 1;
    }
    return low;
}

void BInsertSort(int a[], int n)
{
   for(int i=1; i<n; ++i)
   {
        int temp = a[i];
        int pos = find_position(a, 0, i-1, a[i]);
        for(int j=i-1; j>=pos; j--)
            a[j+1] = a[j];
        a[pos] = temp;
   }
   print(a, n);
}

//========================希尔排序
void Shell(int a[], int n, int t)
{
   int i, j;
   for(i=t; i<n; ++i)
   {
        if(a[i]<a[i-t])
        {
            int temp = a[i];
            for(j=i-t; j>=0&&a[j]>temp; j-=t)
                a[j+t] = a[j];
            a[j+t] = temp;
        }
   }
}

void ShellSort(int a[], int n)
{
    for(int i=4;i>=1;--i)
    {
        Shell(a, n, i);
    }
    print(a, n);
}

//===================简单选择排序
void swap( int &x, int &y)
{
    int temp = x;
    x = y;
    y = temp;
}

int select_min_num(int a[], int begin, int end)
{
    int min = a[begin];
    int flag = begin;
    for(int i=begin; i<=end; ++i)
    {
        if(a[i]<min)
        {
            min = a[i];
            flag = i;
        }
    }
    return flag;
}

void SimpleSelectSort(int a[], int n)
{
    for(int i=0;i<n;++i)
    {
        int x = a[i];
        int y = select_min_num(a,i,n-1);
        swap(a[i], a[y]);
    }
    print(a, 10);
}

//====================堆排序
void Adjust_Heap(int a[], int n, int i)
{
    for(int j=2*i+1; j<=n; j=2*j+1)
    {
        if(j+1<n && a[j]>a[j+1])
            j++;
        if(j<n &&a[j]<a[i])
            swap(a[j], a[i]);
        i = j;
    }
}

void HeapSort(int a[], int n)
{
    int i;
    // for(i=n/2;i>0;i--)
    // {
    //     cout<<i<<endl;
    //     Adjust_Heap(a, n, i);
    //     print(a, 10);
    // }
    // for(i=n;i>1;i--)
    // {    
    //     swap(a[1], a[i]);
    //     Adjust_Heap(a, i-1, 1);
    // }
    // print(a, 10);
    //从数组0开始
    for(i=n/2-1; i>=0; i--)
    {
        Adjust_Heap(a, n, i);
        print(a, 10);
    }
    for(i=n-1;i>0;i--)
    {
        swap(a[0], a[i]);
        Adjust_Heap(a, i, 0);
    }
    print(a, 10);
}

int Merge(int a[], int begin, int middle, int end, int temp[])
{
    int i, j ,k;
    for(i=begin,j= middle,k = begin; i<middle&&j<end; k++)
    {
        if(a[i]<=a[j])
            temp[k] = a[i++];
        else
            temp[k] = a[j++];
    }
    while(j<end)
        temp[k++] = a[j++];
    while(i<middle)
        temp[k++] = a[i++];
    for(i=begin; i<end; ++i)
        a[i] = temp[i];
}

void MSort(int a[], int begin, int end, int temp[])
{
    if(begin<end-1)
    {
        int middle = (begin + end)/2;
        MSort(a, begin, middle, temp);
        MSort(a, middle, end, temp);
        Merge(a, begin, middle, end, temp);
    }
}

void MergeSort(int a[], int n)
{
    int *b = new int[n];// 临时变量放在这里可以减少操作内存的时间
    MSort(a, 0, n, b);
    print(a,10);
    delete [] b;
}


int main()
{
    int a[] = {1,2,4,5,7,9,0,1,3,8};
    BubbleSort(a, 10);
    quicksort(a, 10);
    InsertSort(a, 10);
    BInsertSort(a, 10);
    ShellSort(a, 10);
    SimpleSelectSort(a, 10);
    HeapSort(a, 10);
    MergeSort(a, 10);
    return 0;
}