递归实现分治法

在计算机科学中，分治法是一种很重要的算法。字面上的解释是“分而治之”，就是把一个复杂的问题分成两个或更多的相同或相似的子问题，再把子问题分成更小的子问题……直到最后子问题可以简单的直接求解，原问题的解即子问题的解的合并。这个技巧是很多高效算法的基础，如排序算法(快速排序，归并排序)。

分解：把数组从中间分解为2个子数组

解决：递归解决子数组

合并：合并数据

 

        static void Main(string[] args)
        {
            int[] ints = { 3, 1, 5, 2, 4,9,-4 };

            ArrayList arr = new ArrayList(ints);
            Sort(arr);
            for (int i = 0; i < arr.Count; i++)
            {
                Console.WriteLine(arr[i]);
            }
            Console.ReadLine();
        }
        /// <summary>
        /// 分组排序
        /// </summary>
        /// <param name="arr"></param>
        /// <returns></returns>
        public static ArrayList Sort(ArrayList arr)
        {
            ArrayList arr_l = new ArrayList();
            ArrayList arr_r = new ArrayList();
            if (arr.Count > 1)
            {
                for (int i = 0; i < arr.Count; i++)
                {
                    int num = arr.Count / 2;

                    if (i < num)
                        arr_l.Add(arr[i]);
                    else
                        arr_r.Add(arr[i]);
                }

                ArrayList part1 = Sort(arr_l);//分组1
                ArrayList part2 = Sort(arr_r);//分组2
                Merger(part1, part2, arr);
            }

            return arr;
        }
        /// <summary>
        /// 合并
        /// </summary>
        /// <param name="arr_l">左</param>
        /// <param name="arr_r">右</param>
        /// <param name="arr">数据集</param>
        public static void Merger(ArrayList arr_l, ArrayList arr_r, ArrayList arr)
        {
            int l = 0;//左索引
            int r = 0;//右索引
            int index = 0;//数据集索引

            while (l < arr_l.Count && r < arr_r.Count)
            {
                if ((int)arr_l[l] <= (int)arr_r[r])
                {
                    arr[index] = (int)arr_l[l];
                    l++;
                }
                else
                {
                    arr[index] = (int)arr_r[r];
                    r++;
                }
                index++;
            }
            while (l < arr_l.Count)
            {
                arr[index] = (int)arr_l[l];
                index++;
                l++;
            }

            while (r < arr_r.Count)
            {
                arr[index] = (int)arr_r[r];
                index++;
                r++;
            }

        }

 

分解图

时间分析

分解：把数组从中间分解为2个子数组需要常量c

解决：递归解决规模n/2子数组需要lgn+1

合并：合并数据需要常量n

每一层运算时间为cn，总时间为cn(lgn+1);忽略常量c得到结果nlgn

 

效果图

 

 

结束语

程序存在着一些不足，操作比较复杂，时间解释一块自己也无法完美表达，也可能存在理解误差，希望给出指导意见

请多多指教！