java 编写的最大优先级队列

1.  package com.priorityquence;  
2. /** 
3.  *  
4.  * @author kinglong1203 2011.2.20 
5.  * 
6.  */  
7. public class MaxPriorityQuence {  
8.       
9.     private int size ;  
10.     private int quenceSize;  
11.     private int[] array;  
12.     public MaxPriorityQuence(){  
13.         size = 50;  
14.         quenceSize = 0;  
15.         array = new int[size];  
16.     }  
17.        
18.     public MaxPriorityQuence(int size) {  
19.         super();  
20.         this.size = size;  
21.         this.quenceSize = 0;  
22.         array = new int[size];  
23.     }  
24.     public int getSize() {  
25.         return size;  
26.     }  
27.     public void setSize(int size) {  
28.         this.size = size;  
29.     }  
30.     public int getQuenceSize() {  
31.         return quenceSize;  
32.     }  
33.     public void setQuenceSize(int quenceSize) {  
34.         this.quenceSize = quenceSize;  
35.     }  
36.     public boolean isFull(){   
37.         if(quenceSize == size){  
38.             return true;  
39.         }  
40.         return false;  
41.     }  
42.       
43.     public boolean isEmpty(){   
44.         if(quenceSize < 1){  
45.             return true;  
46.         }  
47.         return false;  
48.     }  
49.       
50.     public void maxPriorityIncrease(int i,int x){  
51.         if(x < array[i-1]){  
52.             System.out.println("该值比现有值小，不能增加！");  
53.         }  
54.         i = i -1;  
55.         array[i] = x;  
56.         while(i>0 && array[(i-1)/2] < array[i]){  
57.             int temp = array[i];  
58.             array[i] = array[(i-1)/2];  
59.             array[(i-1)/2] = temp;  
60.             i = (i-1)/2;  
61.         }  
62.     }  
63.       
64.     public void maxPriorityInsert(int x){  
65.         if(!isFull()){  
66.             array[quenceSize] = Integer.MIN_VALUE;  
67.             quenceSize++;  
68.             maxPriorityIncrease(quenceSize,x);  
69.               
70.         } else {  
71.             System.out.println("队列已满！");  
72.         }  
73.     }  
74.     //获得优先级最大的元素，   
75.     public int maximum(){  
76.         buildMaxHeap();  
77.         return array[0];  
78.     }  
79.     //提取优先级最大的元素，队列中删除该元素   
80.     public int extractMax(){  
81.         if(quenceSize < 1){  
82.             System.err.println("队列为空！");  
83.             return -1;  
84.         }  
85.           
86.         quenceSize--;  
87.         int max = array[0];  
88.         array[0] = array[quenceSize];  
89.         maxPriority(1);  
90.         return max;  
91.     }  
92.       
93.     //创建最大堆   
94.     private void buildMaxHeap(){  
95.         for(int i = quenceSize/2; i >= 2;i--){  
96.             maxPriority(i);  
97.         }  
98.     }  
99.     //从i开始调整成最大堆   
100.     private void maxPriority(int i){  
101.         int s = i - 1;  
102.         for(int j = 2*s+1;j<quenceSize;j = j*2+1){  
103.             if(j < quenceSize-1 && array[j] < array[j+1])  
104.                 j++;  
105.             if(array[s] >= array[j])  
106.                 break;  
107.             int temp = array[s];  
108.             array[s] = array[j];  
109.             array[j] = temp;  
110.             s = j;  
111.         }  
112.           
113.     }  
114.     //打印队列   
115.     public void printQuence(){  
116.         for(int i = 0; i < quenceSize; i++){  
117.             System.out.print("  " + array[i]);  
118.         }  
119.         System.out.println(" ");  
120.     }  
121. }  

package com.priorityquence;/** * * @author kinglong1203 2011.2.20 * */public class MaxPriorityQuence {private int size ;private int quenceSize;private int[] array;public MaxPriorityQuence(){size = 50;quenceSize = 0;array = new int[size];} public MaxPriorityQuence(int size) {super();this.size = size;this.quenceSize = 0;array = new int[size];}public int getSize() {return size;}public void setSize(int size) {this.size = size;}public int getQuenceSize() {return quenceSize;}public void setQuenceSize(int quenceSize) {this.quenceSize = quenceSize;}public boolean isFull(){ if(quenceSize == size){return true;}return false;}public boolean isEmpty(){ if(quenceSize < 1){return true;}return false;}public void maxPriorityIncrease(int i,int x){if(x < array[i-1]){System.out.println("该值比现有值小，不能增加！");}i = i -1; array[i] = x;while(i>0 && array[(i-1)/2] < array[i]){int temp = array[i];array[i] = array[(i-1)/2];array[(i-1)/2] = temp;i = (i-1)/2;}}public void maxPriorityInsert(int x){if(!isFull()){array[quenceSize] = Integer.MIN_VALUE;quenceSize++;maxPriorityIncrease(quenceSize,x);} else {System.out.println("队列已满！");}}//获得优先级最大的元素，public int maximum(){buildMaxHeap();return array[0];}//提取优先级最大的元素，队列中删除该元素public int extractMax(){if(quenceSize < 1){System.err.println("队列为空！");return -1;}quenceSize--;int max = array[0];array[0] = array[quenceSize];maxPriority(1);return max;}//创建最大堆private void buildMaxHeap(){for(int i = quenceSize/2; i >= 2;i--){maxPriority(i);}}//从i开始调整成最大堆private void maxPriority(int i){int s = i - 1;for(int j = 2*s+1;j<quenceSize;j = j*2+1){if(j < quenceSize-1 && array[j] < array[j+1])j++;if(array[s] >= array[j])break;int temp = array[s];array[s] = array[j];array[j] = temp;s = j;}}//打印队列public void printQuence(){for(int i = 0; i < quenceSize; i++){System.out.print(" " + array[i]);}System.out.println(" ");}}  

 

 

 

测试代码：

 

 

[java] view plaincopyprint?

1. package com.priorityquence;  
2. /** 
3.  *  
4.  * @author kinglong1203  2011.2.20 
5.  * 
6.  */  
7. public class MaxPriorityQuenceTest {  
8.     /** 
9.      * @param args 
10.      */  
11.     public static void main(String[] args) {  
12.         MaxPriorityQuence maxPriority = new MaxPriorityQuence();  
13.           
14.         maxPriority.maxPriorityInsert(15);  
15.         maxPriority.maxPriorityInsert(13);  
16.         maxPriority.maxPriorityInsert(9);  
17.         maxPriority.maxPriorityInsert(5);  
18.         maxPriority.maxPriorityInsert(12);  
19.         maxPriority.maxPriorityInsert(8);  
20.         maxPriority.maxPriorityInsert(7);  
21.         maxPriority.maxPriorityInsert(4);  
22.         maxPriority.maxPriorityInsert(0);  
23.         maxPriority.maxPriorityInsert(6);  
24.         maxPriority.maxPriorityInsert(2);  
25.         maxPriority.maxPriorityInsert(1);  
26.           
27.         System.out.println("优先级最高的是： "+maxPriority.maximum());  
28.         maxPriority.printQuence();  
29.           
30.           
31.         maxPriority.maxPriorityInsert(10);  
32.         System.out.println("优先级最高的是： "+maxPriority.maximum());  
33.         maxPriority.extractMax();  
34.         maxPriority.printQuence();  
35.     }  
36. }