Java中各种排序的实现

  1 用Java语言实现的各种排序，包括插入排序、冒泡排序、选择排序、Shell排序、快速排序、归并排序、堆排序、SortUtil等。
  2 
  3 插入排序：
  4 
  5 import org.rut.util.algorithm.SortUtil;
  6 
  7 /**
  8  * @author treeroot
  9  * @since 2006-2-2
 10  * @version 1.0
 11  */
 12 public class BubbleSort implements SortUtil.Sort{
 13 
 14     /* (non-Javadoc)
 15      * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
 16 
 17 package org.rut.util.algorithm.support;
 18 
 19 import org.rut.util.algorithm.SortUtil;
 20 /**
 21  * @author treeroot
 22  * @since 2006-2-2
 23  * @version 1.0
 24  */
 25 public class InsertSort implements SortUtil.Sort{
 26 
 27     /* (non-Javadoc)
 28      * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
 29      */
 30     public void sort(int[] data) {
 31         int temp;
 32         for(int i=1;i<data.length;i++){
 33             for(int j=i;(j>0)&&(data[j]<data[j-1]);j--){
 34                 SortUtil.swap(data,j,j-1);
 35             }
 36         }        
 37     }
 38 
 39 }
 40 冒泡排序：
 41 
 42 package org.rut.util.algorithm.support;
 43 
 44 
 45      */
 46     public void sort(int[] data) {
 47         int temp;
 48         for(int i=0;i<data.length;i++){
 49             for(int j=data.length-1;j>i;j--){
 50                 if(data[j]<data[j-1]){
 51                     SortUtil.swap(data,j,j-1);
 52                 }
 53             }
 54         }
 55     }
 56 
 57 }
 58  
 59 
 60 快速排序：
 61 
 62 package org.rut.util.algorithm.support;
 63 
 64 import org.rut.util.algorithm.SortUtil;
 65 
 66 /**
 67  * @author treeroot
 68  * @since 2006-2-2
 69  * @version 1.0
 70  */
 71 public class QuickSort implements SortUtil.Sort{
 72 
 73     /* (non-Javadoc)
 74      * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
 75      */
 76     public void sort(int[] data) {
 77         quickSort(data,0,data.length-1);        
 78     }
 79     private void quickSort(int[] data,int i,int j){
 80         int pivotIndex=(i+j)/2;
 81         //swap
 82         SortUtil.swap(data,pivotIndex,j);
 83         
 84         int k=partition(data,i-1,j,data[j]);
 85         SortUtil.swap(data,k,j);
 86         if((k-i)>1) quickSort(data,i,k-1);
 87         if((j-k)>1) quickSort(data,k+1,j);
 88         
 89     }
 90     /**
 91      * @param data
 92      * @param i
 93      * @param j
 94      * @return
 95      */
 96     private int partition(int[] data, int l, int r,int pivot) {
 97         do{
 98            while(data[++l]<pivot);
 99            while((r!=0)&&data[--r]>pivot);
100            SortUtil.swap(data,l,r);
101         }
102         while(l<r);
103         SortUtil.swap(data,l,r);        
104         return l;
105     }
106 
107 }
108 改进后的快速排序：
109 
110 package org.rut.util.algorithm.support;
111 
112 import org.rut.util.algorithm.SortUtil;
113 
114 /**
115  * @author treeroot
116  * @since 2006-2-2
117  * @version 1.0
118  */
119 public class ImprovedQuickSort implements SortUtil.Sort {
120 
121     private static int MAX_STACK_SIZE=4096;
122     private static int THRESHOLD=10;
123     /* (non-Javadoc)
124      * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
125      */
126     public void sort(int[] data) {
127         int[] stack=new int[MAX_STACK_SIZE];
128         
129         int top=-1;
130         int pivot;
131         int pivotIndex,l,r;
132         
133         stack[++top]=0;
134         stack[++top]=data.length-1;
135         
136         while(top>0){
137             int j=stack[top--];
138             int i=stack[top--];
139             
140             pivotIndex=(i+j)/2;
141             pivot=data[pivotIndex];
142             
143             SortUtil.swap(data,pivotIndex,j);
144             
145             //partition
146             l=i-1;
147             r=j;
148             do{
149                 while(data[++l]<pivot);
150                 while((r!=0)&&(data[--r]>pivot));
151                 SortUtil.swap(data,l,r);
152             }
153             while(l<r);
154             SortUtil.swap(data,l,r);
155             SortUtil.swap(data,l,j);
156             
157             if((l-i)>THRESHOLD){
158                 stack[++top]=i;
159                 stack[++top]=l-1;
160             }
161             if((j-l)>THRESHOLD){
162                 stack[++top]=l+1;
163                 stack[++top]=j;
164             }
165             
166         }
167         //new InsertSort().sort(data);
168         insertSort(data);
169     }
170     /**
171      * @param data
172      */
173     private void insertSort(int[] data) {
174         int temp;
175         for(int i=1;i<data.length;i++){
176             for(int j=i;(j>0)&&(data[j]<data[j-1]);j--){
177                 SortUtil.swap(data,j,j-1);
178             }
179         }       
180     }
181 
182 }
183 
184 
185 归并排序：
186 
187 package org.rut.util.algorithm.support;
188 
189 import org.rut.util.algorithm.SortUtil;
190 
191 /**
192  * @author treeroot
193  * @since 2006-2-2
194  * @version 1.0
195  */
196 public class MergeSort implements SortUtil.Sort{
197 
198     /* (non-Javadoc)
199      * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
200      */
201     public void sort(int[] data) {
202         int[] temp=new int[data.length];
203         mergeSort(data,temp,0,data.length-1);
204     }
205     
206     private void mergeSort(int[] data,int[] temp,int l,int r){
207         int mid=(l+r)/2;
208         if(l==r) return ;
209         mergeSort(data,temp,l,mid);
210         mergeSort(data,temp,mid+1,r);
211         for(int i=l;i<=r;i++){
212             temp[i]=data[i];
213         }
214         int i1=l;
215         int i2=mid+1;
216         for(int cur=l;cur<=r;cur++){
217             if(i1==mid+1)
218                 data[cur]=temp[i2++];
219             else if(i2>r)
220                 data[cur]=temp[i1++];
221             else if(temp[i1]<temp[i2])
222                 data[cur]=temp[i1++];
223             else
224                 data[cur]=temp[i2++];            
225         }
226     }
227 
228 }
229 改进后的归并排序:
230 
231 package org.rut.util.algorithm.support;
232 
233 import org.rut.util.algorithm.SortUtil;
234 
235 /**
236  * @author treeroot
237  * @since 2006-2-2
238  * @version 1.0
239  */
240 public class ImprovedMergeSort implements SortUtil.Sort {
241 
242     private static final int THRESHOLD = 10;
243 
244     /*
245      * (non-Javadoc)
246      * 
247      * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
248      */
249     public void sort(int[] data) {
250         int[] temp=new int[data.length];
251         mergeSort(data,temp,0,data.length-1);
252     }
253 
254     private void mergeSort(int[] data, int[] temp, int l, int r) {
255         int i, j, k;
256         int mid = (l + r) / 2;
257         if (l == r)
258             return;
259         if ((mid - l) >= THRESHOLD)
260             mergeSort(data, temp, l, mid);
261         else
262             insertSort(data, l, mid - l + 1);
263         if ((r - mid) > THRESHOLD)
264             mergeSort(data, temp, mid + 1, r);
265         else
266             insertSort(data, mid + 1, r - mid);
267 
268         for (i = l; i <= mid; i++) {
269             temp[i] = data[i];
270         }
271         for (j = 1; j <= r - mid; j++) {
272             temp[r - j + 1] = data[j + mid];
273         }
274         int a = temp[l];
275         int b = temp[r];
276         for (i = l, j = r, k = l; k <= r; k++) {
277             if (a < b) {
278                 data[k] = temp[i++];
279                 a = temp[i];
280             } else {
281                 data[k] = temp[j--];
282                 b = temp[j];
283             }
284         }
285     }
286 
287     /**
288      * @param data
289      * @param l
290      * @param i
291      */
292     private void insertSort(int[] data, int start, int len) {
293         for(int i=start+1;i<start+len;i++){
294             for(int j=i;(j>start) && data[j]<data[j-1];j--){
295                 SortUtil.swap(data,j,j-1);
296             }
297         }
298     }
299 
300 堆排序：
301 
302 package org.rut.util.algorithm.support;
303 
304 import org.rut.util.algorithm.SortUtil;
305 
306 /**
307  * @author treeroot
308  * @since 2006-2-2
309  * @version 1.0
310  */
311 public class HeapSort implements SortUtil.Sort{
312 
313     /* (non-Javadoc)
314      * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
315      */
316     public void sort(int[] data) {
317         MaxHeap h=new MaxHeap();
318         h.init(data);
319         for(int i=0;i<data.length;i++)
320             h.remove();
321         System.arraycopy(h.queue,1,data,0,data.length);
322     }
323 
324      private static class MaxHeap{         
325         
326         void init(int[] data){
327             this.queue=new int[data.length+1];
328             for(int i=0;i<data.length;i++){
329                 queue[++size]=data[i];
330                 fixUp(size);
331             }
332         }
333          
334         private int size=0;
335 
336         private int[] queue;
337                 
338         public int get() {
339             return queue[1];
340         }
341 
342         public void remove() {
343             SortUtil.swap(queue,1,size--);
344             fixDown(1);
345         }
346         //fixdown
347         private void fixDown(int k) {
348             int j;
349             while ((j = k << 1) <= size) {
350                 if (j < size && queue[j]<queue[j+1])
351                     j++; 
352                 if (queue[k]>queue[j]) //不用交换
353                     break;
354                 SortUtil.swap(queue,j,k);
355                 k = j;
356             }
357         }
358         private void fixUp(int k) {
359             while (k > 1) {
360                 int j = k >> 1;
361                 if (queue[j]>queue[k])
362                     break;
363                 SortUtil.swap(queue,j,k);
364                 k = j;
365             }
366         }
367 
368     }
369 
370
posted on 2013-01-07 12:47 anqli 阅读(76) 评论(0) 收藏举报
刷新页面返回顶部
anqli

公告
