• Java实现的9种排序


    交换排序: 
    1.冒泡排序 

    Java代码  收藏代码
    1. public static void bubble(int arr[]){  
    2.         for(int i=1;i<arr.length;i++){//控制次数  
    3.             for(int j=0;j<arr.length-i;j++){//控制当前比较到那个位置  
    4.                 if(arr[j]>arr[j+1]){  
    5.                     swap(arr,j,j+1);  
    6.                 }  
    7.             }  
    8.         }  
    9.     }  



    2.快排 

    Java代码  收藏代码
    1. public static void quickSort(int a[],int left,int right){  
    2.     int i;  
    3.     if(left<right){  
    4.         i=partition(a,left,right);  
    5.         quickSort(a,left,i-1);  
    6.         quickSort(a,i+1,right);  
    7.     }  
    8. }  
    9.   
    10. public static int partition(int a[],int left,int right){  
    11.     int base = a[left];  
    12.     while(left<right){  
    13.         while(left<right && a[right]>=base) {--right;}  
    14.         a[left] = a[right];  
    15.         while(left<right && a[left]<=base)  {++left;}  
    16.         a[right] = a[left];  
    17.     }  
    18.     a[left] = base;//a[right]=base;  right==left;  
    19.     return left;  
    20. }  



    选择排序 
    1.直接选择 

    Java代码  收藏代码
    1. public static void select(int a[]){  
    2.     int index;  
    3.     for(int i=0;i<a.length-1;i++){  
    4.         index = i;  
    5.         for(int j=i+1;j<a.length;j++){  
    6.             if(a[j]<a[index]){  
    7.                 index = j;  
    8.             }  
    9.         }  
    10.         if(index!=i){  
    11.             swap(a,index,i);  
    12.         }  
    13.     }  
    14. }  



    2.堆排序 

    Java代码  收藏代码
    1. public static void  heap(int[] data)  
    2.     {  
    3.         int n = data.length;  
    4.         for(int i=n/2-1;i>=0;i--){//从中间有叶子节点的数据开始  
    5.              keepHeap(data,i,n);  
    6.         }  
    7.         while (n > 0) {  
    8.           swap(data, 0, n-1);//把第一个和本次建堆的最后一个交换  
    9.           keepHeap(data, 0,--n);//排除最后一个继续建堆  
    10.         }  
    11.     }  
    12.       
    13.     /** 
    14.      * 建(大/小顶)堆操作 
    15.      * @param r 
    16.      * @param index 本次建堆的起始下标 
    17.      * @param length 本次建堆的数据长度 
    18.      */  
    19.      private static void keepHeap(int[] r, int index,int length) {  
    20.          int x = r[index];  
    21.          int j = 2 * index + 1;  
    22.          while (j < length ) {//注意是: 下标 < 长度(不是 下标<最长的下表)  
    23.          if (j < length - 1 && r[j] < r[j + 1])//判断是否存在右节点,且和左节点比较大小  
    24.             ++j;  
    25.          if (r[j] > x) {  
    26.             r[index] = r[j];//上面小的变成下面大的  
    27.             index = j;  
    28.             j = 2 * index + 1//继续向下  
    29.            }else{  
    30.                break;  
    31.            }  
    32.          }  
    33.          r[index] = x;  
    34.     }  



    插入排序 

    1.直接插入排序 

    Java代码  收藏代码
    1. public static void insert(int a[]){  
    2.         for(int i=1;i<a.length;i++){  
    3.             int t = a[i];  
    4.             int j = i-1;  
    5.             while(j>=0 && t<a[j]){  
    6.                 a[j+1] = a[j];  
    7.                 j--;  
    8.             }  
    9.             a[j+1] = t;  
    10.         }  
    11.           
    12.     }  



    2.折半插入排序 

    Java代码  收藏代码
    1. public static void halfInsert(int a[]){  
    2.     for(int i=1;i<a.length;i++){  
    3.         int t = a[i];  
    4.         int big = i-1, small = 0;  
    5.         while(big>=small){  
    6.             int mid = (big+small)/2;  
    7.             if(a[mid]<t){  
    8.                 small = mid+1;  
    9.             }else{  
    10.                 big = mid-1;  
    11.             }  
    12.         }  
    13.         //(i-1)->small 数值 均向前移动一位   
    14.         for(int j=i;j>small;j--){  
    15.             a[j] = a[j-1];  
    16.         }  
    17.         a[big+1] = t;  
    18.     }  
    19. }  



    3.希尔排序 
    方法1. 

    Java代码  收藏代码
    1. public static void shell(int a[]){  
    2.     for(int span=a.length/2;span>=1;span--){  
    3.         for(int i=span;i<a.length;i++){  
    4.             int tmp = a[i];  
    5.             int j = i-span;  
    6.             while(j>=0 && a[j]>tmp){  
    7.                 a[j+span] = a[j];  
    8.                 j -= span;  
    9.             }  
    10.             a[j+span] = tmp;  
    11.         }  
    12.     }  
    13. }  



    方法2: 

    Java代码  收藏代码
    1. public static  void  shell2(Number[] data)  
    2. {  
    3.     int span=data.length/7;  
    4.     if(span==0)span=1;  
    5.     while(span>=1){  
    6.         for(int i=0;i<span;i++){  
    7.             for(int j=i;j<data.length;j=j+span){  
    8.                 //组内直接插入排序    
    9.                 int p = j-span;  
    10.                 Number temp = data[j];  
    11.                 while( p >=0 && data[p].doubleValue() > temp.doubleValue()){  
    12.                     data[p+span] = data[p];  
    13.                     p -=span;  
    14.                 }  
    15.                 data[p + span] = temp;  
    16.             }  
    17.         }  
    18.         span=span/2;  
    19.     }  
    20. }  




    方法1和2的微妙之处,至于1是在span之内先增加i,遇到块便向后查询 
    2是先循环一个块上的数据来排序,然后在span之内在递增 
    二者最外层都是在缩小span; 
    解释的不是很清楚,需要阅读代码 
    其他: 

    归并排序 

    Java代码  收藏代码
      1. /**  
      2.     * 分治和归并  
      3.     * @param a  
      4.     * @param low  
      5.     * @param high  
      6.     * @param b  
      7.     */   
      8.     public static void mergeSort(int a[],int low,int high,int b[]){  
      9.         int mid;  
      10.         if(low<high){  
      11.             mid = (low+high)/2;//分治位置   
      12.             mergeSort(a, low, mid, b);  
      13.             mergeSort(a,mid+1,high,b);  
      14.             merge(a,low,mid,high,b);//归并   
      15.         }  
      16.     }  
      17.       
      18.       
      19.     /**  
      20.      * 合并两个有序子序列  
      21.      * @param a  
      22.      * @param low  
      23.      * @param mid  
      24.      * @param high  
      25.      * @param b 辅助数组  
      26.      */   
      27.     public static void merge(int a[],int low,int mid,int high,int b[]){  
      28.         int i = low;  
      29.         int j = mid+1;  
      30.         int p = 0;  
      31.         while(i<=mid&&j<=high){  
      32.             b[p++] = (a[i]<=a[j])?a[i++]:a[j++];  
      33.         }  
      34.         //如果子序列1没有合并完则直接复制到辅助数组中去   
      35.         //复制low mid段未被copy的部分  
      36.         while(i<=mid){  
      37.             b[p++] = a[i++];  
      38.         }  
      39.         //如果子序列2没有合并完则直接复制到辅助数组中去   
      40.         //复制mid+1 high段未被copy的部分  
      41.         while(j<=high){  
      42.             b[p++] = a[j++];  
      43.         }  
      44.           
      45.         //把辅助数组的元素复制到原来的数组中去   
      46.         //复制b[0 ~ p-1]到a[low ~ high]  
      47.         for(p=0,i=low;i<=high;i++,p++){  
      48.             a[i] = b[p];  
      49.         }  
      50.     }  
    高山仰止, 景行行止。 四牡鲱鲱, 六辔如琴。 觏尔新婚, 以慰我心。
  • 相关阅读:
    前端页面有哪三层构成,分别是什么?作用是什么?
    如何使用jQuery设置背景的透明度
    笔试基础
    我的设计模式3
    C++ 输入输出流
    我的设计模式2
    剑指offer: 38 数字在排序数组中出现的次数
    我的设计模式
    常用算法设计与分析
    iOS viewController 和 view 的创建消失生命周期总结
  • 原文地址:https://www.cnblogs.com/davidshi/p/3338222.html
Copyright © 2020-2023  润新知