一、排序算法

/// 

/// 选择排序
/// 
/// 
/// 
void SelectSort(int[] array, int n)
{
    int i, j, k;
    int temp;
    for (i = 0; i < n - 1; i++)//i取到倒数第二个元素
    {  
        k = i;
        for (j = i + 1; j < n; j++)//查找最小元素位置k
        {
            if (array[j] < array[k])
            {
                k = j;
            }
        }
        if (k != i)//如果与原位置不等，则交换位置
        { 
            temp = array[i];
            array[i] = array[k];
            array[k] = temp;
        }
    }
}

/// 

/// 插入排序
/// 
/// 
/// 
void InsertSort(int[] array, int n)
{
    int i, j;
    int temp;
    for (i = 1; i < n; i++)//默认第一个元素有序，需n-1次插入
    {
        if (array[i] < array[i - 1])
        {
            temp = array[i];
            j = i - 1;
            while (j >= 0 && array[j] > temp)//查找插入位置且元素后移
            {
                array[j + 1] = array[j];
                j--;
            }
            array[j + 1] = temp;//插入元素
        }
    }
}

/// 

/// 冒泡排序
/// 
/// 
/// 
void BubbleSort(int[] array, int n)
{
    int i, j;
    int temp, flag;
    for (i = 1; i < n; i++)//需n-1次冒泡
    {
        flag = 0;
        for (j = n - 1; j > i - 1; j--)//从后往前
        {
            if (array[j] < array[j - 1])
            {
                temp = array[j];
                array[j] = array[j - 1];
                array[j - 1] = temp;
                flag = 1;
            }
        }
        if (flag == 0)//如果没有交换，则说明剩下元素有序排序
        {
            return;
        }
    }
}

/// 

/// 双向冒泡排序
/// 
/// 
/// 
void BubbleSortBoth(int[] array, int n)
{
    int low, high;
    int j;
    int temp;
    low = 0;
    high = n - 1;
    while (low < high)
    {
        for (j = low; j < high; j++)
        {
            if (array[j] > array[j + 1])
            {
                temp = array[j];
                array[j] = array[j + 1];
                array[j + 1] = temp;
            }
        }
        high--;

        for (j = high; j > low; j--)
        {
            if (array[j] < array[j - 1])
            {
                temp = array[j];
                array[j] = array[j - 1];
                array[j - 1] = temp;
            }
        }
        low++;
    }
}

/// 

/// 快速排序
/// 
/// 
/// 
void QuickSort(int[] array, int n)
{
    QuickSort(array, 0, n - 1);
}
        
/// 

/// 快速排序
/// 
/// 
/// 
/// 
void QuickSort(int[] array, int low, int high)
{
    int p;
    if (low < high)
    {
        p = partition(array, low, high);
        QuickSort(array, 0, p - 1);//对左区间进行递归快速排序
        QuickSort(array, p + 1, high);//对右区间进行递归快速排序
    }
}

/// 

/// 第i趟排序，返回基准元素位置
/// 
/// 
/// 
/// 
/// 
   
   
int partition(int[] array, int low, int high)
{
    int privotKey = array[low];//基准元素  
    while (low < high)//从表的两端low、high交替地向中间扫描，直到low=high退出循环  
    {                                   
        while (low < high && array[high] >= privotKey)
        {
            high--;
        } 
        if (low < high)
        {
            array[low] = array[high];
            low++;
        }
        while (low < high && array[low] <= privotKey)
        {
            low++;
        }
        if (low < high)
        {
            array[high] = array[low];
            high--;
        }
    }
    array[low] = privotKey;
    return low;
}

/// 

/// 希尔排序
/// 
/// 
/// 
void ShellSort(int[] array, int n)
{
    int i, j;
    int temp;
    int dk;//增量
    for (dk = n / 2; dk >= 1; dk /= 2)//n/2、n/4、n/8、1增量
    {
        for (i = dk; i < n; i++)
        {
            if (array[i] < array[i - dk])
            {
                temp = array[i];
                j = i-dk;
                while (j >= 0 && array[j] > temp)
                {
                    array[j + dk] = array[j];
                    j -= dk;
                }
                array[j + dk] = temp;
            }             
        }
    }
}