排序算法------归并排序-1 非递归方法

/** 
 * 有问题
 * 归并排序---非递归
 * 基本排序：归并（Merge）排序法是将两个（或两个以上）有序表合并成一个新的有序表，即把待排序序列分为若干个子序列，每个子序列是有序的。
 * 然后再把有序子序列合并为整体有序序列。
 * 归并排序是建立在归并操作上的一种有效的排序算法。
 * 该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。
 * 归并排序是一种稳定的排
 * 步骤：
 * 1、Divide: 把长度为n的输入序列分成两个长度为n/2的子序列。
 * 2、Conquer: 对这两个子序列分别采用归并排序。
 * 3、Combine: 将两个排序好的子序列合并成一个最终的排序序列。
 */

public class MergeSort {


    /**
     * 将数组合并,这个过程也是排序的过程
     * @param array
     * @param low
     * @param mid
     * @param high
     */
        public static void merge(int[] array, int low, int mid, int high) {
            int i = low; // i是第一段序列的下标
            int j = mid + 1; // j是第二段序列的下标
            int k = 0; // k是临时存放合并序列的下标
            int[] array2 = new int[high - low + 1]; // array2是临时合并序列
            // 扫描第一段和第二段序列，直到有一个扫描结束
            while (i <= mid && j <= high) {
                // 判断第一段和第二段取出的数哪个更小，将其存入合并序列，并继续向下扫描
                if (array[i] <= array[j]) {
                    array2[k] = array[i];
                    i++;
                    k++;
                } else {
                    array2[k] = array[j];
                    j++;
                    k++;
                }
            }
            // 若第一段序列还没扫描完，将其全部复制到合并序列
            while (i <= mid) {
                array2[k] = array[i];
                i++;
                k++;
            }

            // 若第二段序列还没扫描完，将其全部复制到合并序列
            while (j <= high) {
                array2[k] = array[j];
                j++;
                k++;
            }
            // 将合并序列复制到原始序列中
            for (k = 0, i = low; i <= high; i++, k++) {
                array[i] = array2[k];
            }
        }

        public static void MergePass(int[] array, int gap, int length) {

            int i = 0;
            // 归并gap长度的两个相邻子表,判断条件不能变为i-1，因为需要判断一组数组数据，i为开头，i + 2 * gap - 1为改组数据的结尾
            //一个for循环完成了全部的局部排序
            for (i = 0; i + 2 * gap - 1 < length; i = i + 2 * gap) {
                // 0,1,
                //merge(int[] array, int low, int mid, int high)
                merge(array, i, i + gap - 1, i + 2 * gap - 1);//gap=1 (arr,0,0,1)
            }

            // 余下两个子表，后者长度小于gap
            if (i + gap - 1 < length) {
                merge(array, i, i + gap - 1, length - 1);
            }
        }
        /**
         *      排序前:        9   1   5   3   4   2   6   8   7   
                gap = 1:    1   9   3   5   2   4   6   8   7   
                gap = 2:    1   3   5   9   2   4   6   8   7   
                gap = 4:    1   2   3   4   5   6   8   9   7   
                gap = 8:    1   2   3   4   5   6   7   8   9   
                排序后:        1   2   3   4   5   6   7   8   9   
         * @param list
         * @return
         */

        public static int[] sort(int[] list) {
            for (int gap = 1; gap < list.length; gap = 2 * gap) {
                MergePass(list, gap, list.length);
                /*
                System.out.print("gap = " + gap + ":\t");
                this.printAll(list);*/
            }
            return list;
        }

        // 打印完整序列
        public static void printAll(int[] list) {
            for (int value : list) {
                System.out.print(value + "\t");
            }
            System.out.println();
        }

        public static void main(String[] args) {
            int[] array = {
                    9, 1, 5, 3, 4, 2, 6, 8, 7
            };

            MergeSort merge = new MergeSort();
            System.out.print("排序前:\t\t");
            merge.printAll(array);
            merge.sort(array);
            System.out.print("排序后:\t\t");
            merge.printAll(array);
        }


}