Java实现排序算法(一)

  1. /**
  2.  * @(#)SortTest.java
  3.  * 排序算法
  4.  *
  5.  * @author 
  6.  * @version 1.00 2008/8/2
  7.  */
  8. public class SortTest {
  9.     /**
  10.      *选择排序
  11.      *在找到全局第i小的时候记下该元素位置,最后跟第i个元素交换,从而保证数组最终的有序
  12.     */
  13.    void selectSort(int[] sortIn){
  14.         int i,j,temp,min=0;
  15.         for(i=0;i<sortIn.length;i++){
  16.             min=i;
  17.             for(j=i;j<sortIn.length;j++){//每一趟都选择一个最小的
  18.                 if(sortIn[j]<sortIn[min]) min=j;
  19.             }
  20.             //交换
  21.             swap(sortIn,i,min);
  22.         }
  23.     }
  24.     
  25.     /**
  26.      *冒泡排序
  27.      *算法思想是每次从数组末端开始比较相邻两元素,把第i小的冒泡到数组的第i个位置
  28.      */
  29.     void bubbleSort(int[] sortIn){
  30.         for(int i=0;i<sortIn.length;i++){
  31.             for(int j=sortIn.length-1;j>i;j--){
  32.                 if(sortIn[j]<sortIn[j-1])
  33.                     swap(sortIn,j-1,j);         
  34.             }
  35.         }
  36.     }
  37.     
  38.     /**
  39.      *插入排序
  40.      */
  41.     void insertSort(int[] sortIn){
  42.         for(int i=1;i<sortIn.length;i++){
  43.             int temp=sortIn[i];
  44.             int j=i-1;
  45.             while(j>=0&&temp<sortIn[j]){
  46.                 sortIn[j+1]=sortIn[j];//向后移动元素
  47.                 j--;
  48.             }
  49.             sortIn[j+1]=temp;
  50.         }
  51.     }
  52.     
  53.     /**
  54.      *希尔排序
  55.      *Shell排序每次把数据分成若个小块,来使用插入排序,而且之后在这若个小块
  56.      *排好序的情况下把它们合成大一点的小块,继续使用插入排序,不停的合并小块,
  57.      *知道最后成一个块,并使用插入排序。
  58.      *这里每次分成若干小块是通过“增量” 来控制的,开始时增量交大,接近N/2,
  59.      *从而使得分割出来接近N/2个小块,逐渐的减小“增量“最终到减小到1。
  60.      */
  61.     void sheelSort(int[] sortIn){
  62.         int d=sortIn.length;
  63.         while(d>1){
  64.             d=(d+1)/2;
  65.             for(int i=0;i<sortIn.length-d;i++){
  66.                 if(sortIn[i+d]<sortIn[i]){
  67.                     swap(sortIn,i+d,i);
  68.                 }
  69.             }
  70.         }
  71.     }
  72.     /**
  73.      *快速排序
  74.      *(1)分解(2)求解(3)组合
  75.      */
  76.     void quickSort(int[] sortIn,int low,int high){
  77.         int pivotpos;//划分后的基准记录的位置
  78.         if(low<high){//仅当区间长度大于1时才需排序
  79.             pivotpos=partition(sortIn,low,high);//做划分
  80.             quickSort(sortIn,low,pivotpos-1);//对左区间进行递归排序
  81.             quickSort(sortIn,pivotpos+1,high);//对右区间进行递归排序
  82.         }
  83.     }
  84.     
  85.     private int partition(int[] sortIn,int i,int j){
  86.         int pivot=sortIn[i];
  87.         while(i<j){
  88.             //从右向左扫描,查找第一个关键字小于pivot的记录
  89.             while(i<j&&sortIn[j]>=pivot) j--;
  90.             if(i<j){
  91.                 swap(sortIn,i,j);//交换sortIn[i]和sortIn[j]
  92.                 i++;
  93.             }
  94.             
  95.             //从左向右扫描,查找第一个关键字大于pivot的记录
  96.             while(i<j&&sortIn[i]<=pivot) i++;
  97.             if(i<j){
  98.                 swap(sortIn,i,j);
  99.                 j--;
  100.             }
  101.         }
  102.         sortIn[i]=pivot;//基准位置已被最终定位
  103.         return i;
  104.     } 
  105.         
  106.     /**
  107.      *交换位置
  108.      */
  109.     private void swap(int a[],int i,int j){
  110.         int temp=a[i];
  111.         a[i]=a[j];
  112.         a[j]=temp;
  113.     }
  114.     
  115.     public static void main(String[] args){
  116.         int[] sortIn={49,38,56,97,76,13,27,99,55,3};
  117.         SortTest ss=new SortTest();
  118.         
  119.         //ss.selectSort(sortIn);
  120.         //ss.bubbleSort(sortIn);
  121.         //ss.insertSort(sortIn);
  122.         //ss.sheelSort(sortIn);
  123.         ss.quickSort(sortIn,0,sortIn.length-1);
  124.         for(int num:sortIn){
  125.             System.out.print(" "+num);
  126.         }
  127.     }
  128. }
  • 0
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值