Hashtable排序的几种方法

àì夳堔傛蜴生んèń 2022-04-08 12:17 322阅读 0赞

## Hashtable排序的几种方法 ##

Hashtable 利于用键值快速查找，却没有提供排序的方法，所以它的排序需要借住数组或其它集合来实现。

*  排序方法一：  
    **将hash表中的值放入entrySet，利用Comparator中的compare方法实现排序**
    
        import java.util.Arrays;
          import java.util.Comparator;
          import java.util.Hashtable;
          import java.util.Map;
          import java.util.Set;     
          public class demo5 {
          		 
          	public static void main(String[] args) {
          		 Hashtable ht = new Hashtable();
          		 ht.put(1, 5);
          		 ht.put(2, 7);
          		 ht.put(3, 3); 
          	    //将哈希表ht的键值对放入entrySet进行遍历
          	    Map.Entry[] set = SortByKey(ht);
          	    //Map.Entry[] set = SortByValue(ht);
          	    for (int i = 0; i < set.length; i++) {
          	      System.out.println(set[i].getKey().toString()+":"+set[i].getValue().toString());
          	    }
          	}      
          	     //hashtable按键排序
          		  public static Map.Entry[] SortByKey(Hashtable ht) {
          			long  start = System. currentTimeMillis();
          		    Set set = ht.entrySet();
          		    Map.Entry[] entries = (Map.Entry[]) set.toArray(new Map.Entry[set.size()]);
          		    Arrays.sort(entries, new Comparator() {
          		      public int compare(Object arg0, Object arg1) {
          		        Object key1 = ((Map.Entry) arg0).getKey();
          		        Object key2 = ((Map.Entry) arg1).getKey();
          		        return ((Comparable) key1).compareTo(key2);
          		      }
          
          		    });
          		    Long end = System. currentTimeMillis();
          	        System. out.println( "耗时：" + (end - start) + " ms" );
          		    return entries;
          		  }
          		//hashtable按值排序
          		  public static Map.Entry[] SortByValue(Hashtable ht) {
          			long  start = System. currentTimeMillis();
          		    Set set = ht.entrySet();
          		    Map.Entry[] entries = (Map.Entry[]) set.toArray(new Map.Entry[set
          		        .size()]);
          
          		    Arrays.sort(entries, new Comparator() {
          		      public int compare(Object arg0, Object arg1) {
          		        int key1 = Integer.parseInt(((Map.Entry) arg0).getValue()
          		            .toString());
          		        int key2 = Integer.parseInt(((Map.Entry) arg1).getValue()
          		            .toString());
          		        return ((Comparable) key1).compareTo(key2);
          		      }
          		    });
          		    Long end = System. currentTimeMillis();
          	        System. out.println( "耗时：" + (end - start) + " ms" );
          		    return entries;
          		  }	
          	 }
    
     *  排序方法二：  
        **利用两个数组，一个装键，一个装值，然后重写快速排序的方法**
        
            import java.util.Hashtable;
            
            public class demo4 {
               public static void main(String[] args) {
            	 Hashtable ht = new Hashtable();
            	 ht.put(1, 5);
            	 ht.put(2, 7);
            	 ht.put(3, 3); 
            	 int[] arrKey = new int[ht.size()];//暂存 Hashtable 的值
            	 int[] arrValue = new int[ht.size()];//暂存 Hashtable 的值
                for (int i = 0; i < arrValue.length; i++) {
                	arrKey[i]=i+1;
                	arrValue[i]=(int) ht.get(i+1);
            	 }
                QuickSort(arrValue,arrKey,0,arrValue.length-1);
                for (int i = 0; i < arrValue.length; i++) {
            	System.out.println(arrKey[i]+":"+arrValue[i]);
                 }	
               `在这里插入代码片`}  
               //重写快速排序：同时将键值进行排序
               public static void QuickSort(int arr[],int arr1[],int _left,int _right){
            	long  start = System. currentTimeMillis();
               	int right=_right;
               	int left=_left;
               	int temp=0,temp1=0;
               	if(left<=right){
               		temp1=arr1[left];
               		temp=arr[left];
               		while(left!=right){
               			while(right>left&&arr[right]>temp)
               				right--;
               			    arr1[left]=arr1[right];
               				arr[left]=arr[right];    				
               				while(left<right&&temp>arr[left])
               	 				left++;
               					arr1[right]=arr1[left];
               					arr[right]=arr[left]; 
               				}
               		        arr1[right]=temp1; 
               				arr[right]=temp;
               				QuickSort(arr,arr1,_left,left-1);
               				QuickSort(arr,arr1,right+1,_right);   				   			  			
               		  }
               	Long end = System. currentTimeMillis();
                System. out.println( "耗时：" + (end - start) + " ms" );
            	   }
            }