• Kendall tau距离的定义

以下定义取自wiki百科Kendall tau distance：

The Kendall tau rank distance is a metric that counts the number of pairwise disagreements between two ranking lists. The larger the distance, the more dissimilar the two lists are.

也就是说，Kendall tau距离就是两个排列之间的逆序数，它反映了两个排列的相似程度。例如两个在区间[ 0 , 6 ]的排列：

a = { 0, 3, 1, 6, 2, 5, 4 } 
b = { 1, 0, 3, 6, 4, 2, 5 }

求a，b的Kendall tau距离，就是求两个排列之间的逆序{ 0，1 }，{ 3，1 }，{ 2，4 }，{ 5，4 }，一共为4对，故Kendall tau距离为4。

• Kendall tau距离的求法

从上面的例子可以看出，两个排列之间的逆序数可以看作是以a为排列的标准，b排列自身的逆序数。要以a为排列标准，首先需要将a排列的索引提取出来放到新排列aIndex中，即aIndex[ a[ i ] ] = i 。接着要以a排列的索引去确定b的索引，即bIndex[ i ] = aIndex[ b[ i ] ] 。从而bIndex中索引的逆序数就是a，b之间的逆序数了。 
一种特殊情况就是：a[ i ] = i 自然数序，则aIndex[ i ] = i ，bIndex[ i ] = b[ i ] ，则以a为排列的标准，b排列的逆序数就是b排列自身的逆序数。

• 求一个排列的逆序数

首先考虑简单的平方量级的算法。在插入排序或者冒泡排序中，元素交换的次数等于该排列的逆序数，因此在排序过程中统计交换次数即可。但是这种方法效率比较低。 
更高效的方法启发自高效的排序算法，比如归并排序，它可以使得算法变成线性对数量级。在将两个有序的排列归并在一起时，前子数组首元素如果小于后子数组首元素，则逆序数为0，反之，逆序数为前子数组当前的元素个数。

• 求Kendall tau距离的实现

public class KendallTau {
         private static long counter = 0;    public static long distance(int[] a, int[] b) {        if (a.length != b.length) {            throw new IllegalArgumentException("Array dimensions disagree");        }        int N = a.length;        int[] aIndex = new int[N];// 记录a数组的索引        for (int i = 0; i < N; i++) {            aIndex[a[i]] = i;        }        int[] bIndex = new int[N];// b数组引用a数组的索引        for (int i = 0; i < N; i++) {            bIndex[i] = aIndex[b[i]];        }        return mergeCount(bIndex);    }    // 使用插入排序方法求逆序数    public static long insertionCount(int[] a) {        for (int i = 1; i < a.length; i++) {            for (int j = i; j > 0 && a[j] < a[j - 1]; j--) {                int temp = a[j];                a[j] = a[j - 1];                a[j - 1] = temp;                counter++;// 插入排序每交换一次，就存在一对逆序数            }        }        return counter;    }    // 使用归并排序方法求逆序数    private static int[] aux;    public static long mergeCount(int[] a) {        aux = new int[a.length];        mergeSort(a, 0, a.length-1);        return counter;    }    private static void mergeSort(int[] a, int lo, int hi) {        if (hi <= lo) {            return;        }        int mid = lo + (hi - lo) / 2;        mergeSort(a, lo, mid);        mergeSort(a, mid + 1, hi);        merge(a, lo, mid, hi);    }    public static void merge(int[] a, int lo, int mid, int hi) {        int i = lo, j = mid + 1;        for (int k = lo; k <= hi; k++) {            aux[k] = a[k];        }        for (int k = lo; k <= hi; k++) {            if (i > mid) {                a[k] = aux[j++];            } else if (j > hi) {                a[k] = aux[i++];            } else if (aux[j] < aux[i]) {                a[k] = aux[j++];                counter += mid - i + 1;// 每个比前子数组小的后子数组元素，逆序数为前子数组现有的长度            } else {                a[k] = aux[i++];            }        }    }    public static void main(String[] args) {        int[] a = new int[] { 0, 3, 1, 6, 2, 5, 4 };        int[] b = new int[] { 1, 0, 3, 6, 4, 2, 5 };        for (int i = 0; i < a.length; i++) {            System.out.println(a[i] + " " + b[i]);        }        System.out.println("Inversions:" + distance(a, b));    }}