算法-归并排序演示

归并排序

排序原理：
1、尽可能的一组数据拆分成两个元素相等的子组，并对每一个子组继续拆分，直到拆分后的每个子组的元素个数是1为止。
2、将相邻的两个子组进行合并成一个有序的大组；
3、不断的重复步骤2，直到最终只有一个组为止。

源码

 public class Merge
    {
        private static int[] result;


        public static List<int[]> res=new List<int[]>();

        public static void sort(int[] a)
        {
            result=new int[a.Length];
            res.Clear();
            res.Add((int[])a.Clone());
            int low = 0;
            int high = a.Length - 1;
            sort(a,low,high);
        }

        /// <summary>
        /// 根据low到high之间的距离交换数组a的值
        /// </summary>
        /// <param name="a"></param>
        /// <param name="low"></param>
        /// <param name="high"></param>
        private static void sort(int[] a, int low, int high)
        {
            if (low >= high)
                return;
            int mid = low + (high - low) / 2;
            sort(a,low,mid);
            sort(a,mid+1,high);
            merge(a,low,mid,high);
        }

       /// <summary>
       /// 合并元素
       /// </summary>
       /// <param name="a"></param>
       /// <param name="low"></param>
       /// <param name="mid"></param>
       /// <param name="high"></param>
        private static void merge(int[] a, int low,int mid, int high)
       {
           int i = low;
           int p1 = low;
           int p2 = mid + 1;
           while (p1 <= mid && p2 <= high)
           {
               if (less(a[p1], a[p2]))
               {
                   result[i++] = a[p1++];
               }
               else
               {
                   result[i++] = a[p2++];
               }
           }

           while (p1 <= mid)
           {
               result[i++] = a[p1++];
           }

           while (p2 <= high)
           {
               result[i++] = a[p2++];
           }

           for (int index = low; index <= high; index++)
           {
               a[index] = result[index];
           }

           res.Add((int[])a.Clone());
       }

        /// <summary>
        /// 判断两个变量之间的大小
        /// </summary>
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// <returns></returns>
        private static bool less(int a, int b)
        {
            return a.CompareTo(b) < 0;
        }

        /// <summary>
        /// 交换两个元素
        /// </summary>
        /// <param name="a"></param>
        /// <param name="i"></param>
        /// <param name="j"></param>
        private static void exch(int[] a, int i, int j)
        {
            int temp = a[i];
            a[i] = a[j];
            a[j] = temp;
        }
    }

归并排序使用了递归来实现，比较难理解。
主要实现思想是分治思想。先分离 再合并。

演示

缺点：
需要申请额外的数组空间，导致空间复杂度提升，是典型的以空间换时间的操作。