一种离散化方法

   离散化是一种常用的技巧，有时数据范围太大，可以用来放缩到我们能处理的范围。

比如：数的范围0---999 999 999，而数的个数N不大于500000,故给出的数一定可以与1.。。。N建立一个一一映射；

例: int a[] = {10000000, 10, 2000, 20, 300};
那么离散化后a[] = {5, 1, 4, 2, 3},是一个一一对应关系，而且满足原来的大小关系，
有些情况下它们可以互相替代。

下面是代码：

Java代码

1. import java.util.Scanner;
2. import java.util.Arrays;
3. import java.util.Comparator;
5. class Node implements Comparable{
6. int val;
7. int no;
9. public int compareTo(Object o) {
10. return this.val - ((Node) o).val;
11. }
15. }
17. public class Test{
18. public static void main(String args[]){
19. Node[] p=new Node[5];
21. int[] a=new int[5];
22. //int a[] = {10000000, 10, 2000, 20, 300};//那么离散化后a[] = {5, 1, 4, 2, 3}
24. Scanner in=new Scanner(System.in);
25. for(int i=0;i<5;i++)
27. {
28. p[i]=new Node();
29. p[i].val=in.nextInt();
30. p[i].no=i;
31. }
33. Arrays.sort(p);
34. for(int i=0;i<5;i++){
35. a[p[i].no]=i+1;
36. }//以上是使其离散化
38. for(int i=0;i<5;i++)
39. System.out.print(a[i]+" ");
40. }
41. }

import java.util.Scanner;
import java.util.Arrays;
import java.util.Comparator;

class Node implements Comparable{
  int val;
  int no;

   public int compareTo(Object o) {
    return this.val - ((Node) o).val;
  }



 }

 public class Test{
  public static void main(String args[]){  
   Node[] p=new Node[5];
             
     int[] a=new int[5];
     //int a[] = {10000000, 10, 2000, 20, 300};//那么离散化后a[] = {5, 1, 4, 2, 3}

     Scanner in=new Scanner(System.in);
      for(int i=0;i<5;i++)
         
        {   
            p[i]=new Node();
            p[i].val=in.nextInt();   
            p[i].no=i;   
        }
        
        Arrays.sort(p);
        for(int i=0;i<5;i++){
            a[p[i].no]=i+1;
        }//以上是使其离散化

        for(int i=0;i<5;i++)
          System.out.print(a[i]+"  ");
   }
}