排序算法

#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
#define MAX_N 1000000
int n;
int a[MAX_N];
void swap(int &a, int &b)
{
       int temp = a;
       a = b;
       b = temp;
}
void show()
{
       for (int i = 0; i < n; ++i)
              cout << a[i] << " ";
       cout << endl;
}
void selectSort()
{
       for (int i = 0; i < n; ++i)
       {
              for (int j = i+1; j < n; ++j)
              {
                     if (a[i] < a[j])
                     {
                           swap(a[i], a[j]);
                     }
              }
       }
       show();
}
void bubleSort()
{
       for (int i = 0; i < n; ++i)
       {
              for (int j = 0; j < n - i - 1; ++j)
              {
                     if (a[j] > a[j + 1])
                     {
                           swap(a[j], a[j + 1]);
                     }
              }
       }
}
void insertSort()
{
       int i = 0, j = 0;
       for (i = 1; i < n; i++)
       {
              int temp = a[i];
              for (j = i - 1; j >= 0; j--)
              {
                     if (temp < a[j])
                     {
                           a[j + 1] = a[j];
                     }
                     else
                     {
                           break;
                     }
              }
              a[j + 1] = temp;
       }
       show();
}
void shellSort()
{
       for(int gap = n/2; gap > 0; gap /= 2)
       {
              for(int d = gap; d < n; ++d)
              {
                     int temp = a[d];
                     int i = 0;
                     for (i = d; i >= gap && a[i - gap] > temp; i -= gap)
                           a[i] = a[i - gap];
                     a[i] = temp;
              }
       }
       show();
}
void quickSort(int a[], int l, int r)
{
       if (l < r)
       {
              int i = l;
              int j = r;
              int key = a[i];
              while (i < j)
              {
                     while (i < j && a[j] >= key)
                           j--;
                     if (i < j)
                           a[i++] = a[j];
                     while (i < j && a[i] <= key)
                           i++;
                     if (i < j)
                           a[j--] = a[i];
              }
              a[i] = key;
              quickSort(a, l, i - 1);
              quickSort(a, i + 1, r);
       }
}

void merge(int a[], int left, int mid, int right)
{
       int *pTemp = new int[right - left + 1]{ 0 };
       int left_first = left;
       int left_last = mid;
       int right_first = mid + 1;
       int right_last = right;
       int k = 0;
       for (k = 0; left_first <= left_last && right_first <= right_last; k++)
       {
              if (a[left_first] <= a[right_first])
              {
                     pTemp[k] = a[left_first++];
              }
              else
              {
                     pTemp[k] = a[right_first++];
              }
       }
       if (left_first <= left_last)
       {
              for (int j = left_first; j <= left_last; j++)
              {
                     pTemp[k] = a[j];
                     k++;
              }
       }
       if (right_first <= right_last)
       {
              for (int j = right_first; j <= right_last; j++)
              {
                     pTemp[k] = a[j];
                     k++;
              }
       }
       for (int i = 0; i <= right - left; i++)
       {
              a[left + i] = pTemp[i];
       }
       delete[] pTemp;
}
void merge_sort(int a[], int left, int right)
{
       if (left < right)
       {
              int mid = (left + right) / 2;
              merge_sort(a, left, mid);
              merge_sort(a, mid + 1, right);
              merge(a, left, mid, right);
       }
}


int Partition( int a[], int low, int high )
{
    //假设每次都以第一个元素作为枢轴值，进行一趟划分：
    int pivot = a[low];
     
    while( low<high )
    {
        while( low<high && a[high]>=pivot )
        --high;
        a[low] = a[high];  //停下来做交换
        while( low<high && a[low]<=pivot )
        ++low;
        a[high] = a[low];  //停下来做交换
    }
    
    a[low] = pivot;  //pivot的最终落点
    return low;
}
//非递归快排
void QuickSort(int a[], int left, int right)
{
    //手动利用栈来存储每次分块快排的起始点
    //栈非空时循环获取中轴入栈
    stack<int> s;
    if( left<right )
    {
        int boundary = Partition(a,left,right);
        
        if( boundary-1>left ) //确保左分区存在
        {
            //将左分区端点入栈
            s.push(left);
            s.push(boundary-1);
        }
        if( boundary+1<right ) //确保右分区存在
        {
            s.push(boundary+1);
            s.push(right);
        }
        
        while( !s.empty() )
        {
            //得到某分区的左右边界
            int r = s.top();
            s.pop();  
            int l = s.top();
            s.pop();
            
            boundary = Partition(a,l,r);
            if( boundary-1>l ) //确保左分区存在
            {
                //将左分区端点入栈
                s.push(l);
                s.push(boundary-1);
            }
            if( boundary+1<r ) //确保右分区存在
             {
                 s.push(boundary+1);
                s.push(r);
            }
        }
    }
}

int main()
{
       while(cin >> n && n > 0)
       {
              for(int i = 0; i < n; ++i)
              {
                     cin >> a[i];
              }
              //selectSort();
              insertSort();
              //shellSort();
              //bubleSort();
              //quickSort(a, 0, n-1);
       }
}