第二章 算法基础 思考题2-4（逆序对）

package chap02;

import static org.junit.Assert.*;

import java.util.Arrays;

import org.junit.Test;

public class ques2_4 {
    /**
     * 逆序对，将一个序列中的所有逆序对打印输出
     * 
     * @author xiaojintao
     * 
     */
    static void printReverseOrder(int[] n) {
        int i = 0;
        int j;
        while (i < n.length - 1) {
            for (j = i + 1; j < n.length; j++) {
                if (n[i] > n[j]) {
                    System.out.println("<" + n[i] + "," + n[j] + ">");
                }
            }
            i++;
        }
    }

    @Test
    public void testName() throws Exception {
        int[] a = { 2 };
        printReverseOrder(a);
    }

    /**
     * 修改归并排序，使之打印出序列中的所有逆序对数
     * 
     * @param n
     */
    static void printReverseByMergeSort(int[] n) {
        int start = 0;
        int end = n.length;
        mergeSort(n, start, end);
        ;
    }

    @Test
    public void test() throws Exception {
        int[] a = { 2, 3, 8, 6, 1, 5, 4, 0 };
        printReverseByMergeSort(a);
    }

    /**
     * 修改的归并排序算法用于逆序对输出
     * 
     * @param a
     * @return
     */
    protected static void mergeSort(int[] a, int start, int end) {
        if (start < end - 1) {
            int mid = (start + end) / 2;
            mergeSort(a, start, mid);
            mergeSort(a, mid, end);
            merge(a, start, mid, end);
        }
    }

    /**
     * 输出逆序对
     * 
     * @param a
     * @param b
     * @return
     */
    protected static void merge(int[] n, int start, int mid, int end) {
        int[] l = Arrays.copyOfRange(n, start, mid);
        int[] r = Arrays.copyOfRange(n, mid, end);
        int i = 0;
        int j = 0;// j<mid-start
        int k = 0;// k<end-mid
        while (i < end - start) {
            if (j < mid - start & k < end - mid) {
                if (l[j] < r[k]) {
                    n[i + start] = l[j];
                    j++;
                } else {
                    System.out.println("<" + l[j] + "," + r[k] + ">");
                    n[i + start] = r[k];
                    k++;
                }
            } else if (k < end - mid) {
                n[i + start] = r[k];
                k++;
            } else if (j < mid - start) {
                n[i + start] = l[j];
                j++;
            }
            i++;
        }
    }
}