算法排序

排序算法主要包括：冒泡排序、快速排序、希尔排序、插入排序、选择排序、堆排序、归并排序、基数排序、桶排序

（1）.冒泡排序：

• 比较相邻的元素。如果第一个比第二个大，就交换它们两个；
• 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；
• 针对所有的元素重复以上的步骤，除了最后一个；
• 重复步骤1~3，直到排序完成。

　/**
      * 冒泡排序
      *
      * @param array
      * @return
      */
public  int[] bubbleSort(int[] array){

     if(array.length==0)  return array;
      int temp=0;
     for(int i=0;i<array.length;i++){
           for(int j=0;j<array.length-i;j++){
               if (array[j + 1] < array[j]) {
                     temp = array[j + 1];
                     array[j + 1] = array[j];
                     array[j] = temp;
                 }
         }  
     }   
　　return array;                 
}

（2）.快速排序

 　　快速排序的原理：选择一个关键值作为基准值，比基准值小的在左边序列，比基准值大的在右边序列（一般左右都是无序的），一般选择序列的第一个元素。

　　一次循环：从后往前比较，用基准值和最后一个值比较，如果比基准值小的就交换位置，如果没有就继续比较下一个，直到找到第一个比基准值小的数才交换，找到这个值之后，又从前往后开始比较，如果有比基准值大的就交换位置，没有就继续比较下一个，直到找到第一个比基准值大的值才交换，直到从前往后的比较索引>从后往前比较的索引，结束第一次循环，此时，对于基准值 来说，左右两边就是有序的了。

 public void sort(int[] a,int low,int high){ 
         int start = low; 
         int end = high;  
         int key = a[low];       
         while(end>start){ 
             //从后往前比较 
             while(end>start&&a[end]>=key)  
 　　　　　　　//如果没有比关键值小的，比较下一个，直到有比关键值小的交换位置，然后又从前往后比较 
                 end--; 
             if(a[end]<=key){ 
                 int temp = a[end]; 
                 a[end] = a[start]; 
                 a[start] = temp; 
             } 
             //从前往后比较 
             while(end>start&&a[start]<=key) 
　　　　　　　　//如果没有比关键值大的，比较下一个，直到有比关键值大的交换位置 
                start++; 
             if(a[start]>=key){ 
                 int temp = a[start]; 
                 a[start] = a[end]; 
                 a[end] = temp; 
             } 
         //此时第一次循环比较结束，关键值的位置已经确定了。左边的值都比关键值小，右边的 值都比关键值大，但是两边的顺序还有可能是不一样的，进行下面的递归调用 
         } 
         //递归 
         if(start>low) sort(a,low,start-1);//左边序列。第一个索引位置到关键值索引-1 
         if(end<high) sort(a,end+1,high);//右边序列。从关键值索引+1到最后一个 
     } 
   } 

（3）.插入排序

　　通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应的位置并插入。 插入排序非常类似于整扑克牌。在开始摸牌时，左手是空的，牌面朝下放在桌上。接着，一次从 桌上摸起一张牌，并将它插入到左手一把牌中的正确位置上。为了找到这张牌的正确位置，要将 它与手中已有的牌从右到左地进行比较。无论什么时候，左手中的牌都是排好序的。

　　如果输入数组已经是排好序的话，插入排序出现最佳情况，其运行时间是输入规模的一个线性函 数。如果输入数组是逆序排列的，将出现最坏情况。平均情况与最坏情况一样，其时间代价是(n2)。    

 

 

 

 

 

 

 

 

 public void sort(int arr[]) 
        { 
            for(int i =1; i<arr.length;i++) 
            { 
                //插入的数 
                int insertVal = arr[i]; 
                //被插入的位置(准备和前一个数比较) 
                int index = i-1; 
                        //如果插入的数比被插入的数小 
                        while(index>=0&&insertVal<arr[index]) 
                        { 
                            //将把arr[index] 向后移动 
                            arr[index+1]=arr[index]; 
                            //让index向前移动 
                            index--; 
                        } 
                        //把插入的数放入合适位置 
                arr[index+1]=insertVal; 
            } 
  } 

（4）.希尔排序

　　基本思想：先将若干待排序的记录序列分成若干子序列分别进行直接插入排序，待整个序列中的记录基本有序时，再对全体记录进行依次直接插入排序。

1. 选择一个增量序列t1，t2...tk，其中ti>tj，tk=1；
2. 按增两个序列个数k，对序列进行k趟排序；
3. 每趟排序根据对应的增量ti，将待排序列分割成若干长度为m的子序列，分别对各子表进行直接插入排序

 private void shellSort(int[] a) { 
   int dk = a.length/2;  
   while( dk >= 1  ){   
        ShellInsertSort(a, dk);   
        dk = dk/2; 
   } 
 } 
 private void ShellInsertSort(int[] a, int dk) { 
//类似插入排序，只是插入排序增量是1，这里增量是dk,把1换成dk就可以了 
  for(int i=dk;i<a.length;i++){ 
    if(a[i]<a[i-dk]){ 
     int j; 
     int x=a[i];//x为待插入元素 
     a[i]=a[i-dk]; 
     for(j=i-dk;  j>=0 && x<a[j];j=j-dk){ 
//通过循环，逐个后移一位找到要插入的位置。 
     a[j+dk]=a[j]; 
    } 
    a[j+dk]=x;//插入 
   } 
  } 
 } 

 

（5）.归并排序算法 

　　归并排序法是将两个（或两个以上）有序表合并成一个新的有序表，即把待排序序列 分为若干个子序列，每个子序列是有序的。然后再把有序子序列合并为整体有序序列。

 

 public class MergeSortTest {   
     public static void main(String[] args) {   
        int[] data = new int[] { 5, 3, 6, 2, 1, 9, 4, 8, 7 };   
        print(data);   
        mergeSort(data);   
        System.out.println("排序后的数组：");   
        print(data);   
    }   
     public static void mergeSort(int[] data) {   
        sort(data, 0, data.length - 1);   
    }   
      public static void sort(int[] data, int left, int right) {   
        if (left >= right)   
            return;   
        // 找出中间索引   
        int center = (left + right) / 2;   
        // 对左边数组进行递归   
        sort(data, left, center);   
        // 对右边数组进行递归   
        sort(data, center + 1, right);   
        // 合并   
        merge(data, left, center, right);   
        print(data);   
    }   
      /**  
     * 将两个数组进行归并，归并前面2个数组已有序，归并后依然有序  
28  
     *   
     * @param data  
     *            数组对象  
     * @param left  
     *            左数组的第一个元素的索引  
     * @param center  
     *            左数组的最后一个元素的索引，center+1是右数组第一个元素的索引  
     * @param right  
     *            右数组最后一个元素的索引  
     */   
    public static void merge(int[] data, int left, int center, int right) {   
        // 临时数组   
        int[] tmpArr = new int[data.length];   
        // 右数组第一个元素索引   
        int mid = center + 1;   
        // third 记录临时数组的索引   
        int third = left;   
        // 缓存左数组第一个元素的索引   
        int tmp = left;   
        while (left <= center && mid <= right) {   
            // 从两个数组中取出最小的放入临时数组   
            if (data[left] <= data[mid]) {   
                tmpArr[third++] = data[left++];   
            } else {   
                tmpArr[third++] = data[mid++];   
            }   
        }   
        // 剩余部分依次放入临时数组（实际上两个while只会执行其中一个）   
        while (mid <= right) {   
            tmpArr[third++] = data[mid++];   

 
        }   
        while (left <= center) {   
            tmpArr[third++] = data[left++];   
        }   
        // 将临时数组中的内容拷贝回原数组中   
        // （原left-right范围的内容被复制回原数组）   
        while (tmp <= right) {   
            data[tmp] = tmpArr[tmp++];   
        }   
    }   
    public static void print(int[] data) {   
        for (int i = 0; i < data.length; i++) {   
            System.out.print(data[i] + "\t");   
        }   
        System.out.println();   
    }   
  } 

（6）.桶排序算法

　　桶排序的基本思想是：把数组arr划分为n个大小相同子区间（桶），每个子区间各自排序，最后合并，基数排序是桶排序的一种特殊情况，可以把基数排序当成每个桶里只有一个元素的情况。

1. 找出待排序数组中最大值Max、最小值Min
2. 使用动态数组ArrayList作为桶，桶里放的元素也用ArrayList存储，桶的数量为(Max-Min)/arr.length+1
3. 遍历数组arr，计算每个元素arr[i]放的桶
4. 每个桶各自排序

  public static void bucketSort(int[] arr){      
        int max = Integer.MIN_VALUE;   
        int min = Integer.MAX_VALUE;  
        for(int i = 0; i < arr.length; i++){ 
            max = Math.max(max, arr[i]);     
            min = Math.min(min, arr[i]);   
        }    
        //创建桶   
         int bucketNum = (max - min) / arr.length + 1;               
         ArrayList<ArrayList<Integer>> bucketArr = new ArrayList<>(bucketNum);   
        for(int i = 0; i < bucketNum; i++){    
            bucketArr.add(new ArrayList<Integer>());   
        }     
     //将每个元素放入桶   
        for(int i = 0; i < arr.length; i++){     
            int num = (arr[i] - min) / (arr.length);    
            bucketArr.get(num).add(arr[i]);  
         }         
         //对每个桶进行排序  
         for(int i = 0; i < bucketArr.size(); i++){     
            Collections.sort(bucketArr.get(i));   
        }          

（7）.基数排序算法

　　将所有的比较数值（正整数）统一为同样的数位长度，数位较短的数前面补零，然后从最低位开始，依次进行一次排序，这样从最低位一直到最高位排序完成以后，数列就变成一个有序序列。

 public class radixSort {       
        inta[]={49,38,65,97,76,13,27,49,78,34,12,64,5,4,62,99,98,54,101,56,17,18,23,34,15,35,2 5,53,51};   
        public  radixSort(){   
            sort(a);
            for(int i=0;i<a.length;i++){
                  System.out.println(a[i]);
           }
       }         
          public void sort(int[] array){
             
             //确定排序的趟数
             for(int i=1;i<array.length;i++){       
                 if(array[i]>max){
                       max=array[i];
                }
            }
            int time=0;
            //判断位数;
            while(max>0){
               max/=10;
                time++;
            }
            //建立10个队列;
            List<ArrayList> queue=newArrayList<ArrayList>();
            for(int i=0;i<10;i++){
                   ArrayList<Integer>queue1=new ArrayList<Integer>(); 
                   queue.add(queue1);
            }
               //进行time次分配和收集;
            for(int i=0;i<time;i++){
                //分配数组元素;
               for(intj=0;j<array.length;j++){
                    //得到数字的第time+1位数;
                    int x=array[j]%(int)Math.pow(10,i+1)/(int)Math.pow(10, i);
                    ArrayList<Integer>queue2=queue.get(x);
                    queue2.add(array[j]);
                    queue.set(x, queue2);
             }
              int count=0;//元素计数器
               //收集队列元素;
               for(int k=0;k<10;k++){
                  while(queue.get(k).size()>0){
                      ArrayList<Integer>queue3=queue.get(k);
                      array[count]=queue3.get(0);
                        queue3.remove(0);
                      count++;
                 }
              }
            }
           }
          }