Day21

排序

Wikipedia 排序算法

冒泡

void BubbleSort(int[] a)
{
    if(a == null || a.Length == 0)
    {
        return;
    }
    for(int i = 0; i < a.Length; i++)
    {
        for(int j = a.Length - 1; j >= 0; j--)
        {
            if(a[i] > a[j])
            {
                a[i] = a[i] ^ a[j];
                a[j] = a[i] ^ a[j];
                a[i] = a[i] ^ a[j];
            }   
        }
    }
}

选择

void SelectSort(int[] a)
{
    if(a == null || a.Length == 0)
    {
        return;
    }
    int min = 0;
    for(int i = 0; i < a.Length; a++)
    {
        min = a[i];
        for(int j = i + 1; j < a.Length; a++)
        {
            if(a[j] < min)
            {
                min = a[j];
            }
        }
        if(min != a[i])
        {
            min = min ^ a[i];
            a[i] = min ^ a[i];
            min = min ^ a[i];
        }
    }
}

插入
以前面的数为基准，比前面的数大，留在原位，比前面的数小，则比起大的数统一后移一位，将该数插入到大数之前

void InserSort(int[] a)
{
    if(a == null || a.Length == 0)
    {
        return;
    }
    for(int i = 0; i < a.Length; i++)
    {
        int j = i;
        int tmp = a[i];
        while(j > 0 && a[j] < a[j-1])
        {
            a[j] = a[j - 1];
            j--;
        }
        a[j] = tmp;
    }
}

快排

void QuickSort(int[] a, int lo, int hi)
{
    int i = lo;
    int j = hi;
    int tmp = a[lo];
    while(lo < hi)
    {
        while((lo < hi) && (a[hi] > tmp))
        {
            hi--;
        }
        a[lo] = a[hi]
        while((lo < hi) && (a[lo] < tmp))
        {
            lo++;
        }
        a[hi] = a[lo];
        hi--;
    }
    a[lo] = tmp;
    if(i < lo - 1)
    {
        QuickSort(a, i, lo - 1);
    }
    if(j > low + 1)
    {
        QuickSort(a, low + 1; j);
    }
}

堆排序

//建堆
void CreatHeap(int[] a, int lo, int hi)
{
    int tmp = a[lo];
    for(int i = 2*lo + 1; i <= hi; i *= 2)  //堆的左右孩子为2i+1和2i+2
    {
        if(i < hi && a[i] < a[i+1])
        {
            i++;
        }
        if(tmp >= a[i]
        {
            break;  
        }
        a[lo] = a[i];
        lo = i;
    }
    a[lo] = tmp;
}
void HeapSort(int[] a)
{
    int tmp = 0;
    CreatHeap(a, 0, a.Length -1);
    for(int i = 0; i < a.Length; i++)
    {
        a[0] = a[0] ^ a[i];
        a[i] = a[0] ^ a[i];
        a[0] = a[0] ^ a[i];
        CreateHeap(a, 0, i-1);
    }
}

希尔排序

void ShellInsert(int[] a, int step)
{
    for(int i = step; i < a.Length; i++)
    {
        int j = i - step;
        int tmp = a[i];
        while(j >= 0 && tmp < a[j])
        {
            a[j+d] = a[j];
            j--;
        }
        if(j != i - step)
        {
            a[j+d] = tmp;
        }
    }
}
void ShellSort(int[] a)
{
    int step = a.Length / 2;
    while(step >= 1)
    {
        ShellInsert(a, step);
        step /= 2;
    }
}

归并

void Merge(int[] a, int len)
{
    int m = 0;           //临时顺序表的起始位置
    int lo1 = 0;         //第一个顺序表的起始位置
    int hi1;             //第一个顺序表的结束位置
    int lo2;             //第二个顺序表的起始位置
    int hi2;             //第二个顺序表的结束位置
    int[] tmp = new int[a.Length];     //临时顺序表
    while(lo1 + len < a.Length)
    {
        lo2 = lo1 + len;
        hi1 = lo2 - 1;
        if(lo2 + len - 1 < a.Length)
        {
            hi2 = lo2 + len - 1;
        }
        else
        {
            hi2 = a.Length - 1;
        }
        j = lo2;
        i = lo1;
        while((i <= hi1) && (j <= hi2))
        {
            if(a[i] < a[j])
            {
                tmp[m++] = a[i++];
            }
            else
            {
                tmp[m++] = a[j++];
            }
        }
        while(i <= hi1)
        {
            tmp[m++] = a[i++];
        }
        while(j < hi2)
        {
            tmp[m++] = a[j++];
        }
        lo1 = hi2 + 1;
        i = lo1;
        while(i < a.Length)
        {
            tmp[m++] = a[i++];
        }
        for(int i = 0; i < a.Length; i++)
        {
            a[i] = tmp[i];
        }
    }
}
void MergeSort(int[] a)
{
    int k = 1;
    while(k < a.Length)
    {
        Merge(a, k);
        k *= 2;
    }
}

c#中的List.Sort实际上调用的是ArryList的Sort方法，该方法在元素少于16个的时候应用插入排序，在元素超过2logN的时候用堆排序，否则应用快排。