数组离散化（Java版）（数组中元素可重复）

本来是想用树状数组求逆序数的，结果在数组离散化时卡了好久，蓝瘦。。。

于是乎实现了一个Java版的，加深印象。

我的思路就是自己定义一个类保存当前的index和value，然后用Collection.sort()对它进行排序（只需重写一个方法即可）

最后对重复的元素进行判断，相同的值在离散后也是相同的值。

代码如下：

class Node implements Comparable{
	public int index;
	public int value;
	Node(int index,int value){
		this.index=index;
		this.value=value;
	}
	@Override
	public int compareTo(Object o) {
		// TODO Auto-generated method stub
		return this.value-((Node) o).value ;
	}
}
public class LiSan {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int[] array= {20,11,17,12,11,14,15};
		LiSanFunc(array);
	}
	public static int[] LiSanFunc(int[] array) {
		
		int i;
		Node[]  nodeArray=new Node[array.length];
		int[]  returnArray=new int[array.length];
		for(i=0;i<array.length;i++) {
			Node node=new Node(i,array[i]);
			nodeArray[i]=node;
		}
		Arrays.sort(nodeArray);
		for(i=0;i<array.length;i++) {
			System.out.println("index:" +nodeArray[i].index+"    value:" +nodeArray[i].value);
		}
		returnArray[nodeArray[0].index]=0;
		for(i=1;i<array.length;i++) {
			if(nodeArray[i].value!=nodeArray[i-1].value)      //如果前后两个数不等，则编号为下标
				returnArray[nodeArray[i].index]=i;
			else
				returnArray[nodeArray[i].index]=returnArray[nodeArray[i-1].index]; 
		}
		for(i=0;i<array.length;i++) {
			System.out.println(returnArray[i]);
		}
		return returnArray;
	}
}

对应关系如下：

nodeArray数组的下标     ：6   0    5   2   1   3   4；

nodeArray元素    域index：0   1    2   3   4   5   6；

nodeArray元素    域value：20 11 17 12 11 14 15；

returnArray得到的结果     ：6   0   5    2  0   3    4；