算法-排序算法

排序算法

最近在学习《算法导论》一书，随手做一下笔记。

插入排序（insertion sort）

输入：{5, 4, 6, 9, 1, 15,2}

        for (int i = 1; i < numbers.length; i++) {
            int temp = numbers[i];
            for (int j = i - 1; j >= 0; j--) {
                if (numbers[j] > temp) {
                    numbers[j + 1] = numbers[j];
                    numbers[j] = temp;
                    for (int number : numbers) {
                        System.out.print(number + ",");
                    }
                    System.out.println();
                }
            }
        }
        return numbers;

输出：

归并排序（Merge Sort）

分冶法

为了一个给定的问题，算法一次或多次递归地调用其自身以解决紧密相关的若干子问题。

• a)分解：将原问题为若干个子问题，这些子问题是原问题的规模较小的实例。
• b)解决：解决这些子问题，递归地求解各子问题。递归地求解各子问题。然而，若子问题的规模足够小，则直接求解。
• c)合并：将这些子问题的解合并成原问题的解

归并排序

归并排序，完全遵循分治模式。直观上其操作如下：

1. 将待排序的n 个元素分解成各具 n/2的元素的两个子序列。
2. 使用归并排序递归地排序两个子序列。
3. 合并两个已经排序的子序列。

假设现在有一个序列，那如果按归并排序的思想来操作的话，操作步骤如下：

现假设有已经排序好的两组数组 A[left…mid],B[mid…right]。现只要将 A 与 B 中软小的数字取出，依次存入
C 中，那么排序就完成了。则这个实现过程如下：

	/**
     * 
     * @param A 待排序数组
     * @param left 起始下标
     * @param mid 中间下标
     * @param right 右边界下标
     */
    public static void merge(int[] A, int left, int mid, int right) {
        int[] temp = new int[right - left + 1];
        //将原数组认为是两个数组
        //其中左数组为 A[left,mid]，右数组为 A[mid +1 ,right]
        //假设这两个数组已经为有序数组（从小到大）。那么取出两个数组中的第一个较小 数，放到1，第二个
        int i = left;
        int j = mid + 1;
        int tempIndex = 0;
        //从左右两个 【数组】 中，拿到较小的数，并放到临时数组里
        while (i <= mid && j <= right) {
            if (A[i] < A[j]) {
                temp[tempIndex] = A[i];
                i++;
                tempIndex++;
            } else {
                temp[tempIndex] = A[j];
                j++;
                tempIndex++;

            }
        }
        //有可能左右两边的数组没拿完，上面的循环就已经结束了。这里就把没拿完的数组放到临时数组里。
        //举个例子，原数组为 【1，5，4，3】，则可分为 [1,5],[4,3],mid = 1;left = 0,right = 3;
        //第一循环，取出1，则 temp  = [1,0,0,0],此时，i = 0; j = 2; , i++;
        //第二循环，取出3，则 temp = [1,3,0,0]，些时，i = 1,j = 2; j ++
        //第三个循环，取出 4，则此时 temp = [1,3,4,0],此时 i = 1,j = 3,j++;
        //由于 j = 4.不符合循环条件。则此时，将左边数组中的 【5】（剩下的元素）放到临时数组中。
        while (i <= mid) {
            temp[tempIndex] = A[i];
            i++;
            tempIndex++;
        }
        while (j <= right) {
            temp[tempIndex] = A[j];
            j++;
            tempIndex++;
        }
        //将临时数组按原来数组中的下标，放入原数姐中。
        for (int k = 0; k < temp.length; k++) {
            A[k + left] = temp[k];
        }
    }

上述代码其实就是实现了图中的 7 - 8的步骤。
接下来，我们需要实现上图中的 1-6的步骤。
现给定的一个数组A [left…right]，其中，left 与 right 分别为数组的下标。
1、如果 left >= right ，则该数组中至多只有一个元素，已排序。
2、若 left < right ,将原数组分为前后两部分。计算中间坐标的位置 mid，简单可设置为 (left + right) /2 ;
则原数组分为 A[left …mid],A[mid +1, right]。
3、如果 A[left …mid],A[mid +1, right] 中的元素大于1（也就是不满足一，继续 2 ，3）。
则实现如下：

    /**
     * 
     * @param A 数组
     * @param left 起始下标
     * @param right 终止下标
     */
    public static void mergeSort(int[] A, int left, int right) {
        //简单计算一个中间的坐标
        int tempMid = (left + right) / 2;
        if (left < right) {
        	//对左边的数组进行分冶
            mergeSort(A, left, tempMid);
            //对右边边的数组进行分冶
            mergeSort(A, tempMid + 1, right);
            //将最终的结果合并
            merge(A, left, tempMid, right);
        }
    }

测试代码：

 int[] A = {5, 1, 7, 2, 5, 78, 11, 1234, 11111, 9, 6, 1, 10, 56, 131, 4, 13, 234, 7, 8, 20, 4, 24, 7, 8, 18, 66};
  mergeSort(A, 0, A.length - 1);

输出：

1,1,2,4,4,5,5,6,7,7,7,8,8,9,10,11,13,18,20,24,56,66,78,131,234,1234,11111,