基本排序算法

      没有过多的说明，只为将来可能会用到的日子，能拿来做参考。

1、冒泡（Bubble）

        7 5 2 1 5 9
        5 7 2 1 5 9
        5 2 7 1 5 9
        5 2 1 7 5 9
        5 2 1 5 7 9

        2 5 1 5 7 9
        2 1 5 5 7 9
        2 1 5 5 7 9

        1 2 5 5 7 9

        public static void BubbleSort(int[] a)
        {
            int n = a.Length - 1;//个数
            int i, j;//用于控制循环
            int tmp;//中间变量
            bool isChange;//记录冒泡一轮下来是否发生交换（如果没有发生交换证明已排好序）
            for (i = 0; i < n; i++)
            {
                isChange = false;
                for (j = 0; j < n - i; j++)//每轮冒泡过后要对比的数就少一个
                {
                    if (a[j] > a[j + 1])//大的数向上冒
                    {
                        tmp = a[j];
                        a[j] = a[j + 1];
                        a[j + 1] = tmp;
                        isChange = true;
                    }
                }
                if (!isChange)
                {
                    return;
                }

            }
            return;
        }

2、直接插入（Insert）

        7 5 2 1 5 9
        5 7 2 1 5 9
        2 5 7 1 5 9
        1 2 5 7 5 9
        1 2 5 5 7 9

        public static void InsertSort(int[] a)
        {
            int n = a.Length;
            for (int i = 1; i < n; i++)//循环从第二个数组元素开始，因为arr[0]作为最初已排序部分
            {
                int temp = a[i];//temp标记为未排序第一个元素
                int j = i - 1;
                while (j >= 0 && a[j] > temp)//将temp与已排序元素从小到大比较，寻找temp应插入的位置
                {
                    a[j + 1] = a[j];
                    j--;
                }
                a[j + 1] = temp;
            }
        }

3、直接选择（Select）

        7 5 2 1 5 9
        1 5 2 7 5 9
        1 2 5 7 5 9
        1 2 5 7 5 9
        1 2 5 5 7 9

        public static void SelectSort(int[] a)
        {
            int n = a.Length;//个数
            int i, j;
            int tmp;
            int b;
            for (i = 0; i < n - 1; i++)
            {
                tmp = i;
                for (j = i + 1; j < n; j++)
                {
                    if (a[tmp] > a[j])//每轮找到最小的元素
                        tmp = j;
                }
                if (i != tmp)
                {
                    b = a[tmp];
                    a[tmp] = a[i];
                    a[i] = b;
                }
            }
        }

4、快速（Quick）

        7       5 2 1 5 9
        5   2 1 5     7 9
        2 1 5   5     7 9
        1 2 5   5     7 9

        public static void QuickSort(int[] a, int low, int high)
        {
            if (low < high)
            {                                     // ↓                     ↓
                int point = MovePart(a, low, high);// 5 6 2 1 4 9      4 1 2 5 6 9
                QuickSort(a, low, point);
                QuickSort(a, point + 1, high);
            }
        }

        public static int MovePart(int[] a, int partLow, int partHigh)
        {
            int pivotP = partLow;//记住枢纽位置
            while (partLow < partHigh)
            {
                while (partLow < partHigh && a[partHigh] >= a[pivotP])//右往左找第一个小于pivot的数
                {
                    partHigh--;
                }
                Swap(a, pivotP, partHigh);
                pivotP = partHigh;
                while (partLow < partHigh && a[partLow] <= a[pivotP])//左往右找第一个大于prvot的数
                {
                    partLow++;
                }
                Swap(a, partLow, pivotP);
                pivotP = partLow;
            }
            return pivotP;//返回分割点
        }

        public static void Swap(int[] a, int pivotP, int swapP)
        {
            int t;
            t = a[pivotP];
            a[pivotP] = a[swapP];
            a[swapP] = t;
        }

5、希尔（Shell）

        7 5 2 1 5 9
        7 5 2   1 5 9
        7 5   2   1 5  9
        5 7   2   1 5  9
        2 5   7   1 5  9
        2 5 7   1 5 9
        1 2 5 7 5 9
        1 2 5 5 7 9

        public static void ShellSort(int[] a)
        {
            int n = a.Length;
            for (int incr = 3; incr > 0; incr--)//增量递减，增量据说以9 5 3 1最优（各种大牛到现在都没有定论），此处为3 2 1
            {
                for (int L = 0; L < (n - 1) / incr; L++)//重复分成的每个子列表
                {
                    for (int i = L + incr; i < n; i += incr)//对每个子列表应用插入排序
                    {
                        int temp = a[i];
                        int j = i - incr;
                        while (j >= 0 && a[j] > temp)
                        {
                            a[j + incr] = a[j];
                            j -= incr;
                        }
                        a[j + incr] = temp;
                    }
                }
            }
        }

6、归并（Merge）

        7 5 2 1 5 9
        7 5 2    1 5 9
        7   5 2   1   5 9
        7   2 5   1   5 9
        2 5 7    1 5 9
        1 2 5 5 7 9

        public static void Merge(int[] a, int low, int center, int high)
        {
            if (low >= high) return;
            int m = center - low + 1;
            int n = high - center;
            int[] L = new int[m];
            int[] R = new int[n];
            int i, j, k;
            for (i = 0; i < m; ++i) L[i] = a[low + i];//取得左边数
            for (i = 0; i < n; ++i) R[i] = a[low + i + m];//取得右边数

            for (i = 0, j = 0, k = low; i < m && j < n; ++k)
            {
                if (L[i] > R[j])//从L、R两边选比较小的数放进a，直到一边放完
                {
                    a[k] = R[j];
                    j++;
                }
                else
                {
                    a[k] = L[i];
                    i++;
                }
            }
            while (i < m)//如果是L没放完，把L剩余的数放进a
            {
                a[k] = L[i];
                k++;
                i++;
            }
            while (j < n)//如果是R没放完，把R剩余的数放进a
            {
                a[k] = R[j];
                k++;
                j++;
            }
        }

        public static void MergeSort(int[] a, int low, int high)
        {
            int center;
            if (low < high)
            {
                center = (low + high) / 2;
                MergeSort(a, low, center);
                MergeSort(a, center + 1, high);
                Merge(a, low, center, high);
            }
        }

7、堆（Heap）

        7 5 2 1 5 9
            7
           / \
          5   2
         / \ / \
         1 5 9

            9
           / \
          5   7
         / \ / \
         1 5 2

        /// <summary>
        /// 堆排序，此处为倒序，要升序，请使用大二叉堆，或对数组进行首尾交换
        /// </summary>
        /// <param name="a"></param>
        /// <param name="n"></param>
        public static void HeapSort(int[] a, int n)
        {
            MakeMinHeap(a, n);//将数组建立成最小堆
            for (int i = n - 1; i >= 1; i--)
            {
                Swap(a, i, 0);//把该论得到的最小数排到末尾已拍好序的的数前
                MinHeapFixDown(a, 0, i);//排除末尾拍好序的的数得出子二叉堆，在作调整得出新的二叉堆，root又为最小的数
            }

        }

        /// <summary>
        /// 新加入叶子结点 
        /// </summary>
        /// <param name="a"></param>
        /// <param name="leafPoint">叶子结点所在位置</param>
        public static void MinHeapAddPoint(int[] a, int leafPoint)//以叶子结点,叶子结点的父结点，叶子结点的爷结点...为一组进行直接插入
        {
            int fartherPoint, temp,currentPornt;
            temp = a[leafPoint];
            currentPornt = leafPoint;//记录当前节点位置
            fartherPoint = (leafPoint - 1) / 2;      //父结点  
            while (a[fartherPoint] > a[currentPornt]&& currentPornt!=0)
            {
                a[currentPornt] = a[fartherPoint];
                currentPornt = fartherPoint;
                fartherPoint = (currentPornt - 1) / 2;//父结点为的位置为 (currentPoint - 1) / 2
            }
            a[currentPornt] = temp;
        }

        /// <summary>
        /// 在最小堆中加入新的数据num  （从叶子结点（数组尾）插入）
        /// </summary>
        /// <param name="a"></param>
        /// <param name="n">新增结点位置（数组结尾位置+1 即 数组长度）</param>
        /// <param name="num">新增结点值</param>
        public static void MinHeapAddNumber(int[] a, int n, int num)
        {
            a[n] = num;
            MinHeapAddPoint(a, n);
        }

        /// <summary>
        /// 删除跟结点（将最后的结点a[n]放到根节点a[0]的位置）后的堆调整
        /// 从i整节点向下开始调整,n为节点总数, 从0开始计算 i节点的子节点为 2*i+1, 2*i+2  
        /// </summary>
        /// <param name="a">数组</param>
        /// <param name="fatherPoint">要调整的位置</param>
        /// <param name="n">二叉堆的长度（要调整到数组的那个位置）</param>
        public static void MinHeapFixDown(int[] a, int fatherPoint, int n)
        {
            int sonPoint, temp;
            temp = a[fatherPoint];
            sonPoint = 2 * fatherPoint + 1;//左子结点，右子节点为sonPoint+1 子节点为 2*i+1, 2*i+2
            while (sonPoint <n)
            {
                if (sonPoint + 1 < n && a[sonPoint + 1] < a[sonPoint]) //存在右子结点的话,在左右孩子中找较小数  
                    sonPoint++;

                if (a[sonPoint] >= temp)//再和父结点对比，如果父结点比较大不用做交换
                    break;
                else
                {//否则把较小的子结点往上移动,替换它的父结点  
                    a[fatherPoint] = a[sonPoint];     
                    fatherPoint = sonPoint;
                    sonPoint = 2 * fatherPoint + 1;
                }
            }
            a[fatherPoint] = temp;
        }

        /// <summary>
        /// 在最小堆中删除数（删除根节点）
        /// </summary>
        /// <param name="a"></param>
        /// <param name="n">结点个数</param>
        public static void MinHeapDeleteNumber(int[] a, int n)
        {
            Swap(a, 0, n - 1); //互换根节点和叶子结点后
            MinHeapFixDown(a, 0, n - 1);//向下调整
        }
   
        /// <summary>
        /// 建立最小堆 n为结点总数
        /// </summary>
        /// <param name="a">数组</param>
        /// <param name="n">结点总数</param>
        public static void MakeMinHeap(int[] a, int n)
        {
            for (int i = (n-1-1)/ 2 ; i >= 0; i--)//由最后一个结点的父结点开始向下调整
                MinHeapFixDown(a, i, n);
        }