首页 > java > 各种排序算法java实现

各种排序算法java实现

2010年6月28日
43 views 评论 发表评论

插入排序:
 

  1.  
  2. package org.rut.util.algorithm.support;
  3. import org.rut.util.algorithm.SortUtil;
  4.  
  5. public class InsertSort implements SortUtil.Sort{
  6.     /* (non-Javadoc)
  7.      * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
  8.      */
  9.     public void sort(int[] data) {
  10.         int temp;
  11.         for(int i=1;i<data.length;i++){
  12.             for(int j=i;(j>0)&amp;&amp;(data[j]<data[j-1]);j–){
  13.                 SortUtil.swap(data,j,j-1);
  14.             }
  15.         }        
  16.     }
  17. }
  18. <span id="more-798"></span>

冒泡排序:
 

  1.  
  2. package org.rut.util.algorithm.support;
  3. import org.rut.util.algorithm.SortUtil;
  4.  
  5. public class BubbleSort implements SortUtil.Sort{
  6.     /* (non-Javadoc)
  7.      * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
  8.      */
  9.     public void sort(int[] data) {
  10.         int temp;
  11.         for(int i=0;i<data.length;i++){
  12.             for(int j=data.length-1;j>i;j–){
  13.                 if(data[j]<data[j-1]){
  14.                     SortUtil.swap(data,j,j-1);
  15.                 }
  16.             }
  17.         }
  18.     }
  19. }
  20.  

选择排序:

  1.  
  2. package org.rut.util.algorithm.support;
  3. import org.rut.util.algorithm.SortUtil;
  4.  
  5. public class SelectionSort implements SortUtil.Sort {
  6.     /*
  7.      * (non-Javadoc)
  8.      * 
  9.      * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
  10.      */
  11.     public void sort(int[] data) {
  12.         int temp;
  13.         for (int i = 0; i < data.length; i++) {
  14.             int lowIndex = i;
  15.             for (int j = data.length – 1; j > i; j–) {
  16.                 if (data[j] < data[lowIndex]) {
  17.                     lowIndex = j;
  18.                 }
  19.             }
  20.             SortUtil.swap(data,i,lowIndex);
  21.         }
  22.     }
  23. }
  24.  

Shell排序:

  1.  
  2. package org.rut.util.algorithm.support;
  3. import org.rut.util.algorithm.SortUtil;
  4.  
  5. public class ShellSort implements SortUtil.Sort{
  6.     /* (non-Javadoc)
  7.      * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
  8.      */
  9.     public void sort(int[] data) {
  10.         for(int i=data.length/2;i>2;i/=2){
  11.             for(int j=0;j<i;j++){
  12.                 insertSort(data,j,i);
  13.             }
  14.         }
  15.         insertSort(data,0,1);
  16.     }
  17.     /**
  18.      * @param data
  19.      * @param j
  20.      * @param i
  21.      */
  22.     private void insertSort(int[] data, int start, int inc) {
  23.         int temp;
  24.         for(int i=start+inc;i<data.length;i+=inc){
  25.             for(int j=i;(j>=inc)&amp;&amp;(data[j]<data[j-inc]);j-=inc){
  26.                 SortUtil.swap(data,j,j-inc);
  27.             }
  28.         }
  29.     }
  30. }

快速排序:

  1.  
  2. package org.rut.util.algorithm.support;
  3. import org.rut.util.algorithm.SortUtil;
  4.  
  5. public class QuickSort implements SortUtil.Sort{
  6.     /* (non-Javadoc)
  7.      * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
  8.      */
  9.     public void sort(int[] data) {
  10.         quickSort(data,0,data.length-1);        
  11.     }
  12.     private void quickSort(int[] data,int i,int j){
  13.         int pivotIndex=(i+j)/2;
  14.         //swap
  15.         SortUtil.swap(data,pivotIndex,j);
  16.         
  17.         int k=partition(data,i-1,j,data[j]);
  18.         SortUtil.swap(data,k,j);
  19.         if((k-i)>1) quickSort(data,i,k-1);
  20.         if((j-k)>1) quickSort(data,k+1,j);
  21.         
  22.     }
  23.     /**
  24.      * @param data
  25.      * @param i
  26.      * @param j
  27.      * @return
  28.      */
  29.     private int partition(int[] data, int l, int r,int pivot) {
  30.         do{
  31.            while(data[++l]<pivot);
  32.            while((r!=0)&amp;&amp;data[–r]>pivot);
  33.            SortUtil.swap(data,l,r);
  34.         }
  35.         while(l<r);
  36.         SortUtil.swap(data,l,r);        
  37.         return l;
  38.     }
  39. }

改进后的快速排序:

  1.  
  2. package org.rut.util.algorithm.support;
  3. import org.rut.util.algorithm.SortUtil;
  4.  
  5. public class ImprovedQuickSort implements SortUtil.Sort {
  6.     private static int MAX_STACK_SIZE=4096;
  7.     private static int THRESHOLD=10;
  8.     /* (non-Javadoc)
  9.      * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
  10.      */
  11.     public void sort(int[] data) {
  12.         int[] stack=new int[MAX_STACK_SIZE];
  13.         
  14.         int top=-1;
  15.         int pivot;
  16.         int pivotIndex,l,r;
  17.         
  18.         stack[++top]=0;
  19.         stack[++top]=data.length-1;
  20.         
  21.         while(top>0){
  22.             int j=stack[top–];
  23.             int i=stack[top–];
  24.             
  25.             pivotIndex=(i+j)/2;
  26.             pivot=data[pivotIndex];
  27.             
  28.             SortUtil.swap(data,pivotIndex,j);
  29.             
  30.             //partition
  31.             l=i-1;
  32.             r=j;
  33.             do{
  34.                 while(data[++l]<pivot);
  35.                 while((r!=0)&amp;&amp;(data[–r]>pivot));
  36.                 SortUtil.swap(data,l,r);
  37.             }
  38.             while(l<r);
  39.             SortUtil.swap(data,l,r);
  40.             SortUtil.swap(data,l,j);
  41.             
  42.             if((l-i)>THRESHOLD){
  43.                 stack[++top]=i;
  44.                 stack[++top]=l-1;
  45.             }
  46.             if((j-l)>THRESHOLD){
  47.                 stack[++top]=l+1;
  48.                 stack[++top]=j;
  49.             }
  50.             
  51.         }
  52.         //new InsertSort().sort(data);
  53.         insertSort(data);
  54.     }
  55.     /**
  56.      * @param data
  57.      */
  58.     private void insertSort(int[] data) {
  59.         int temp;
  60.         for(int i=1;i<data.length;i++){
  61.             for(int j=i;(j>0)&amp;&amp;(data[j]<data[j-1]);j–){
  62.                 SortUtil.swap(data,j,j-1);
  63.             }
  64.         }       
  65.     }
  66. }

归并排序:

  1.  
  2. package org.rut.util.algorithm.support;
  3. import org.rut.util.algorithm.SortUtil;
  4.  
  5. public class MergeSort implements SortUtil.Sort{
  6.     /* (non-Javadoc)
  7.      * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
  8.      */
  9.     public void sort(int[] data) {
  10.         int[] temp=new int[data.length];
  11.         mergeSort(data,temp,0,data.length-1);
  12.     }
  13.     
  14.     private void mergeSort(int[] data,int[] temp,int l,int r){
  15.         int mid=(l+r)/2;
  16.         if(l==r) return ;
  17.         mergeSort(data,temp,l,mid);
  18.         mergeSort(data,temp,mid+1,r);
  19.         for(int i=l;i<=r;i++){
  20.             temp[i]=data[i];
  21.         }
  22.         int i1=l;
  23.         int i2=mid+1;
  24.         for(int cur=l;cur<=r;cur++){
  25.             if(i1==mid+1)
  26.                 data[cur]=temp[i2++];
  27.             else if(i2>r)
  28.                 data[cur]=temp[i1++];
  29.             else if(temp[i1]<temp[i2])
  30.                 data[cur]=temp[i1++];
  31.             else
  32.                 data[cur]=temp[i2++];            
  33.         }
  34.     }
  35. }

改进后的归并排序:
 

  1.  
  2. package org.rut.util.algorithm.support;
  3. import org.rut.util.algorithm.SortUtil;
  4.  
  5. public class ImprovedMergeSort implements SortUtil.Sort {
  6.     private static final int THRESHOLD = 10;
  7.     /*
  8.      * (non-Javadoc)
  9.      * 
  10.      * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
  11.      */
  12.     public void sort(int[] data) {
  13.         int[] temp=new int[data.length];
  14.         mergeSort(data,temp,0,data.length-1);
  15.     }
  16.     private void mergeSort(int[] data, int[] temp, int l, int r) {
  17.         int i, j, k;
  18.         int mid = (l + r) / 2;
  19.         if (l == r)
  20.             return;
  21.         if ((mid – l) >= THRESHOLD)
  22.             mergeSort(data, temp, l, mid);
  23.         else
  24.             insertSort(data, l, mid – l + 1);
  25.         if ((r – mid) > THRESHOLD)
  26.             mergeSort(data, temp, mid + 1, r);
  27.         else
  28.             insertSort(data, mid + 1, r – mid);
  29.         for (i = l; i <= mid; i++) {
  30.             temp[i] = data[i];
  31.         }
  32.         for (j = 1; j <= r – mid; j++) {
  33.             temp[r – j + 1] = data[j + mid];
  34.         }
  35.         int a = temp[l];
  36.         int b = temp[r];
  37.         for (i = l, j = r, k = l; k <= r; k++) {
  38.             if (a < b) {
  39.                 data[k] = temp[i++];
  40.                 a = temp[i];
  41.             } else {
  42.                 data[k] = temp[j–];
  43.                 b = temp[j];
  44.             }
  45.         }
  46.     }
  47.     /**
  48.      * @param data
  49.      * @param l
  50.      * @param i
  51.      */
  52.     private void insertSort(int[] data, int start, int len) {
  53.         for(int i=start+1;i<start+len;i++){
  54.             for(int j=i;(j>start) &amp;&amp; data[j]<data[j-1];j–){
  55.                 SortUtil.swap(data,j,j-1);
  56.             }
  57.         }
  58.     }
  59. }
  60.  

堆排序:

  1.  
  2. package org.rut.util.algorithm.support;
  3. import org.rut.util.algorithm.SortUtil;
  4.  
  5. public class HeapSort implements SortUtil.Sort{
  6.     /* (non-Javadoc)
  7.      * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
  8.      */
  9.     public void sort(int[] data) {
  10.         MaxHeap h=new MaxHeap();
  11.         h.init(data);
  12.         for(int i=0;i<data.length;i++)
  13.             h.remove();
  14.         System.arraycopy(h.queue,1,data,0,data.length);
  15.     }
  16.  
  17.      private static class MaxHeap{
  18.          
  19.         
  20.         void init(int[] data){
  21.             this.queue=new int[data.length+1];
  22.             for(int i=0;i<data.length;i++){
  23.                 queue[++size]=data[i];
  24.                 fixUp(size);
  25.             }
  26.         }
  27.          
  28.         private int size=0;
  29.         private int[] queue;
  30.                 
  31.         public int get() {
  32.             return queue[1];
  33.         }
  34.         public void remove() {
  35.             SortUtil.swap(queue,1,size–);
  36.             fixDown(1);
  37.         }
  38.         //fixdown
  39.         private void fixDown(int k) {
  40.             int j;
  41.             while ((j = k << 1) <= size) {
  42.                 if (j < size &amp;&amp; queue[j]<queue[j+1])
  43.                     j++; 
  44.                 if (queue[k]>queue[j]) //不用交换
  45.                     break;
  46.                 SortUtil.swap(queue,j,k);
  47.                 k = j;
  48.             }
  49.         }
  50.         private void fixUp(int k) {
  51.             while (k > 1) {
  52.                 int j = k >> 1;
  53.                 if (queue[j]>queue[k])
  54.                     break;
  55.                 SortUtil.swap(queue,j,k);
  56.                 k = j;
  57.             }
  58.         }
  59.     }
  60. }

SortUtil:

  1.  
  2. package org.rut.util.algorithm;
  3. import org.rut.util.algorithm.support.BubbleSort;
  4. import org.rut.util.algorithm.support.HeapSort;
  5. import org.rut.util.algorithm.support.ImprovedMergeSort;
  6. import org.rut.util.algorithm.support.ImprovedQuickSort;
  7. import org.rut.util.algorithm.support.InsertSort;
  8. import org.rut.util.algorithm.support.MergeSort;
  9. import org.rut.util.algorithm.support.QuickSort;
  10. import org.rut.util.algorithm.support.SelectionSort;
  11. import org.rut.util.algorithm.support.ShellSort;
  12.  
  13. public class SortUtil {
  14.     public final static int INSERT = 1;
  15.     public final static int BUBBLE = 2;
  16.     public final static int SELECTION = 3;
  17.     public final static int SHELL = 4;
  18.     public final static int QUICK = 5;
  19.     public final static int IMPROVED_QUICK = 6;
  20.     public final static int MERGE = 7;
  21.     public final static int IMPROVED_MERGE = 8;
  22.     public final static int HEAP = 9;
  23.     public static void sort(int[] data) {
  24.         sort(data, IMPROVED_QUICK);
  25.     }
  26.     private static String[] name={
  27.             "insert","bubble","selection","shell","quick","improved_quick","merge","improved_merge","heap"
  28.     };
  29.     
  30.     private static Sort[] impl=new Sort[]{
  31.             new InsertSort(),
  32.             new BubbleSort(),
  33.             new SelectionSort(),
  34.             new ShellSort(),
  35.             new QuickSort(),
  36.             new ImprovedQuickSort(),
  37.             new MergeSort(),
  38.             new ImprovedMergeSort(),
  39.             new HeapSort()
  40.     };
  41.     public static String toString(int algorithm){
  42.         return name[algorithm-1];
  43.     }
  44.     
  45.     public static void sort(int[] data, int algorithm) {
  46.         impl[algorithm-1].sort(data);
  47.     }
  48.     public static interface Sort {
  49.         public void sort(int[] data);
  50.     }
  51.     public static void swap(int[] data, int i, int j) {
  52.         int temp = data[i];
  53.         data[i] = data[j];
  54.         data[j] = temp;
  55.     }
  56. }
  57.  

纯净水 java

  1. 目前还没有任何评论.
  1. 目前还没有任何 trackbacks 和 pingbacks.