java 实现几种常见的排序算法

包含了 冒泡，快速排序，选择排序，插入排序，希尔排序，堆排序，
归并排序，基数排序

package Test;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class SortAny {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int[] array = {32,43,23,13,5};
        SortAny  sortany = new SortAny();

//      sortany.BubbleSort(array);   //冒泡
//      sortany.SelectSort(array);  // 选择
//      sortany.InsertSort(array);  // 插入
//      sortany.QuicksSort(array, 0, 4);  // 快速排序
//      sortany.sheelSort(array);  // 希尔排序
//      sortany.HeapSort(array);  // 堆排序
//      sortany.mergeSort(array,0,4);  // 归并排序
        sortany.Radixsort(array);  // 基数排序
    }
    /*----------------------------------------------------------------*/
    // 冒泡排序，32 ，43，23, 13, 5 
    // 思想：升序排序，将数据两两比较，每次把最大的那个排到最后面
    // 第一趟排序 32 43 23 13 5  ----32 23 43 13 5 ----32 23 13 43 5 -----32 23 13 5 43 
    // 第二趟排序 23 32 13 5 43 -----23 13 32 5 43----- 23 13 5 32 43
    // 第三趟排序 13 23 5 32 43----- 13 5 23 32 43
    // 第四趟排序 5 13 23 32 43 
    public  void BubbleSort(int[] array){
        for (int i = 0; i < array.length-1; i++){
            for(int j = 0; j<array.length - i -1; j++){
                if(array[j]>array[j + 1]){
                    int temp=array[j];
                    array[j]=array[j+1];
                    array[j+1]=temp;
                }

            }
            for (int k=0; k<array.length; k++){
                System.out.print(array[k]+"  ");
            }
            System.out.println();

        }       
    }

    /*----------------------------------------------------------------*/
    //选择排序 思想：遍历整个数组，每次选择最小的一个放在最前面
    // 第一趟排序 
    public  void SelectSort(int[] array){
        for(int i=0;i<array.length;i++){
            int min=array[i];
            int minIndex=i;
            int j;
            for(j=i;j<array.length;j++){
                if(array[j]<min){
                    min=array[j];
                    minIndex=j;
                }
            }
            array[minIndex]=array[i];
            array[i]=min;
            for (int k=0; k<array.length; k++){
                  System.out.print(array[k]+"  ");
             }
             System.out.println();
        }
    }
    /*----------------------------------------------------------------*/
    // 直接插入排序 思想：将第一个数和第二个数排序，然后构成一个有序序列，再将下一个数插入到有序序列值中
   // 第一趟插入排序：32 43 23 13 5
    // 第二趟插入排序： 23 32 43 13 5
    // 第三趟插入排序： 13 23 32 43 5
    // 第四趟插入排序： 5 13 23 32 43 
    public  void  InsertSort(int[] array){
        for(int i=1;i<array.length;i++){
            for(int j=i;j>0;j--){
                if(array[j]<array[j-1]){
                    int temp=array[j-1];
                    array[j-1]=array[j];
                    array[j]=temp;
                }
            }
            for (int k=0; k<array.length; k++){
                  System.out.print(array[k]+"  ");
             }
             System.out.println();
        }

    }

    /*----------------------------------------------------------------*/
    // 快速排序 思想 选择一个数为p，小于p的放在左边，大于p的放在右边，递归
    public void QuicksSort(int[] array, int min, int max){
        if(min<max){
            int middle=OneQuickSort(array, min, max);
            QuicksSort(array,min,middle-1);
            QuicksSort(array,middle+1,max);
        }
    }
    public int OneQuickSort(int[] array, int min, int max){
        int temp=array[min];
        while (min<max){
            while (min<max && array[max]>=temp){
                max--;
            }
            //出现了比temp要小的数，此时调整顺序
            array[min]=array[max];
            while(min<max && array[min]<=temp){
                min++;
            }
            array[max]=array[min];

        }
        // 注意的是最后一定要把temp值赋给 array[min]
        array[min]=temp;

        for (int k=0; k<array.length; k++){
              System.out.print(array[k]+"  "); 
         }
         System.out.println();
        return min;
    }

    /*----------------------------------------------------------------*/
//    堆排序
//将序列构建成大顶堆。
//将根节点与最后一个节点交换，然后断开最后一个节点。
//重复第一、二步，直到所有节点断开。
    public  void HeapSort(int[] a){
        System.out.println("开始排序");      
        int arrayLength=a.length;        //循环建堆  
        for(int i=0;i<arrayLength-1;i++){            //建堆  
            BuildMaxHeap(a,arrayLength-1-i);            //交换堆顶和最后一个元素  
            Swap(a,0,arrayLength-1-i);
            System.out.println(Arrays.toString(a));
        }
    } 
    private void BuildMaxHeap(int[] data, int maxIndex){
        int i=(maxIndex-1)/2; //从最后一个节点的父亲节点开始
        int biggerIndex;
        // 最后的一个父亲节点比较特殊，判断为单个孩子节点还是双孩子节点 
        biggerIndex=2*i+1;
        if(2*i+2==maxIndex){ // 双个孩子节点，先比较这两个数据的大小,确定孩子节点中较大的一个
            if(data[biggerIndex]<data[biggerIndex+1]){
                biggerIndex=biggerIndex+1;
            }       
        }
        //判断孩子和父亲的大小
        if(data[i]<data[biggerIndex]){
            Swap(data,i,biggerIndex);
        }
        i--;
        for(;i>=0;i--){
            biggerIndex=2*i+1;
            if(data[biggerIndex]<data[biggerIndex+1]){
                biggerIndex=biggerIndex+1;
            }   
            //判断孩子和父亲的大小
            if(data[i]<data[biggerIndex]){
                Swap(data,i,biggerIndex);
            }

        }
    }
    private  void Swap(int[] data, int i, int j) {     
        // TODO Auto-generated method stub  
        int tmp=data[i];
        data[i]=data[j];
        data[j]=tmp;
    } 

    /*----------------------------------------------------------------*/
//  归并排序
    public static void mergeSort(int[] numbers, int left, int right) {   
        int t = 1;// 每组元素个数   
        int size = right - left + 1;   
        while (t < size) {   
            int s = t;// 本次循环每组元素个数   
            t = 2 * s;   
            int i = left;   
            while (i + (t - 1) < size) {   
                merge(numbers, i, i + (s - 1), i + (t - 1));   
                i += t;   
            }   
            if (i + (s - 1) < right)   
                merge(numbers, i, i + (s - 1), right);   
        }   
    }   
    private static void merge(int[] data, int p, int q, int r) {   
        int[] B = new int[data.length];   
        int s = p;   
        int t = q + 1;   
        int k = p;   
        while (s <= q && t <= r) {   
            if (data[s] <= data[t]) {   
                B[k] = data[s];   
                s++;   
            } else {   
                B[k] = data[t];   
                t++;   
            }   
            k++;   
        }   
        if (s == q + 1)   
            B[k++] = data[t++];   
        else  
            B[k++] = data[s++];   
        for (int i = p; i <= r; i++)   
            data[i] = B[i];   
    }
    /*----------------------------------------------------------------*/
//  希尔排序
//    首先确定分的组数。
//    然后对组中元素进行插入排序。
//    然后将length/2，重复1,2步，直到length=0为止。
    public  void sheelSort(int[] a){       
        int d  = a.length;        
        while (d!=0) {
             d=d/2;           
            for (int x = 0; x < d; x++) {//分的组数
               for (int i = x + d; i < a.length; i += d) {//组中的元素，从第二个数开始
                  int j = i - d;//j为有序序列最后一位的位数
                  int temp = a[i];//要插入的元素
                  for (; j >= 0 && temp < a[j]; j -= d) {//从后往前遍历。
                      a[j + d] = a[j];//向后移动d位
                  }
                a[j + d] = temp;
            }
        }
    }
}
    /*----------------------------------------------------------------*/
//  基数排序
//    用于大量数，很长的数进行排序时。
//
//    将所有的数的个位数取出，按照个位数进行排序，构成一个序列。
//    将新构成的所有的数的十位数取出，按照十位数进行排序，构成一个序列。
    public void Radixsort(int[] array) {        //首先确定排序的趟数;     
        int max = array[0];        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 = new ArrayList<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 (int j = 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++;
                }
            }
        }
    }


}