Java八大排序算法实现

快速排序

public class FastSort {
    public static void main(String[] args) {
        int [] array=new int [10000000];
        for (int i=0;i<10000000;i++){
            array[i]= (int) (1+Math.random()*10000);
        }
        long starTime=System.nanoTime();
        fastpre(array);
        long endTime=System.nanoTime();
        long Time=endTime-starTime;
        System.out.println("快速排序千万随机数:"+Time/1000000.0+"毫秒");
    }
    public static void fastsort(int [] array,int start,int end){
        int key=array[start];//选第一个数作为基准数进行比较
        int temp=0;
        int starttemp=start;
        int endtemp=end;
        while (start<end){
            boolean flag1=true;
            boolean flag2=true;
            while (flag1){//从后往前排序，若后面的某数比基准数小，则与基准数做交换
                if (array[end]<=key){
                    temp=array[end];
                    array[end]=array[start];
                    array[start]=temp;
                    start++;//数组前边的下标往前移动一位
                    flag1=false;
                }else {
                    end--;//若没有比基准数小的，比较下一个，直到找到比关键字小的交换位置，然后又从前往后比较
                }
            }
            while (flag2){//从前往后比较
                if (array[start]>=key){
                    temp=array[end];
                    array[end]=array[start];
                    array[start]=temp;
                    end--;
                    flag2=false;
                }else {
                    start++;//如果没有比关键值大的，比较下一个，直到有比关键值大的交换位置
                }
            }
        }
        //此时第一次循环比较结束，关键值的位置已经确定了。左边的值都比关键值小，右边的
        //值都比关键值大，但是两边的顺序还有可能是不一样的，进行下面的递归调用
        if (starttemp<start-1){
            fastsort(array,starttemp,start-1);//左边序列。第一个索引位置到关键值索引-1
        }
        if (end+1<endtemp){
            fastsort(array,end+1,endtemp);//右边序列。从关键值索引+1 到最后一个
        }
    }
}

归并排序

/**
 * @author xianyanglin
 * @title: MergeSort
 * @projectName 
 * @description: 归并排序
 * @date 2019/6/28 00289:43
 */
public class MergeSort {
    public static void main(String[] args) {
        int [] array=new int [1000000];
        for (int i=0;i<1000000;i++){
            array[i]= (int) (1+Math.random()*10000000);
        }
        long starTime=System.nanoTime();
        Sort(array, 0, array.length - 1);
        long endTime=System.nanoTime();
        long Time=endTime-starTime;
        System.out.println("归并排序百万随机数:"+Time/1000000.0+"毫秒");
    }
    public static int[] Sort(int[] array,int start,int end) {
         if (start==end){
            return new int []{array[start]};
         }
         int mid=(start+end)/2;
         int [] l=Sort(array,start,mid);
         int [] r=Sort(array,mid+1,end);
         return merge(l,r);
    }
    private static int[] merge(int[] l, int[] r) {
        int [] arr=new int [l.length+r.length];
       // int min=l.length<=r.length?l.length-1:r.length-1;
        int k=0;
        int i=0;
        int j=0;
        while (i<l.length&&j<r.length){
            if(l[i]<r[j]){
                    arr[k++]=l[i];
                    i++;
                }
            else{
                arr[k++] = r[j];
                j++;
            }
        }
        while (i<l.length){
            arr[k++]=l[i++];
        }
        while (j<r.length){
            arr[k++]=r[j++];
        }
        return arr;
    }

}

基数排序

/**
 * @author xianyanglin
 * @title: radixsort
 * @projectName login
 * @description: 基数排序
 * @date 2019/7/3 000319:01
 */
public class radixsort {
    public static void main(String[] args) {
        int [] array=new int [1000000];
        for (int i=0;i<1000000;i++){
            array[i]= (int) (1+Math.random()*10000000);
        }
        long starTime=System.nanoTime();
        function(array);
        long endTime=System.nanoTime();
        long Time=endTime-starTime;
        System.out.println("基数排序百万随机数:"+Time/1000000.0+"毫秒");	
    }
    public static void function(int [] array){
        int [][] arr=new int [10][array.length];
        int max=0;
        for (int i=0;i<array.length;i++){
            if (array[i]>max)max=array[i];
        }
        int len=String.valueOf(max).length();
            for (int w=0;w<len;w++){
                int [] arrlen=new int[10];//代表十个桶各自的长度
                double pow = Math.pow(10, w);
                for (int j = 0; j < array.length; j++) {
                    int l = (int) ((array[j]/pow) % 10);
                    arr[l][arrlen[l]++] = array[j];
                }
                int h = 0;
                for (int k = 0; k < 10; k++) {
                    for (int n = 0; n < arrlen[k]; n++) {
                        array[h] = arr[k][n];
                        h++;
                    }
                }
            }
    }
}

桶排序

/**
 * @author xianyanglin
 * @title: BucketSort
 * @projectName login
 * @description: 桶排序
 * @date 2019/6/28 002814:03
 */
public class BucketSort {

    public static void main(String[] args) {
        int [] array=new int [1000000];
        for (int i=0;i<1000000;i++){
            array[i]= (int) (1+Math.random()*10000);
        }
        long starTime=System.nanoTime();
        // fastsort(array,0,array.length-1);
        Sort(array);
        long endTime=System.nanoTime();

        long Time=endTime-starTime;
        System.out.println("桶排序百万随机数:"+Time/1000000.0+"毫秒");

    }
    public static void Sort(int [] array){
        int [] arr=new int[array.length];
        /**
         　　* @description: 找到最大最小值
         　　* @param [array]
         　　* @return void
         　　* @throws
         　　* @author xianyanglin
         　　* @date 2019/6/28 0028 14:46
         　　*/
        int max=array[0];
        int min=array[0];
        for (int i=1;i<array.length;i++){
            max=max>array[i]?max:array[i];
            min=min<array[i]?min:array[i];
        }
        //计算出桶的数量以确定区间
        ArrayList<ArrayList<Integer>> Buchet=new ArrayList<>((max-min)/array.length+1);

        //初始化集合
        for (int j=0;j<(max-min)/array.length+1;j++){
            Buchet.add(new ArrayList<>());
        }
        //将数组放入对应的桶中
        for (int j=0;j<array.length;j++){
            int num=(array[j]-min)/array.length;
            Buchet.get(num).add(array[j]);
        }
        //将桶里的数继进行排序
        for (int k=0;k<(max-min)/array.length+1;k++){
            Collections.sort(Buchet.get(k));
        }
            int h=0;
            for (int n=0;n<Buchet.size();n++){
                for (int m=0;m<Buchet.get(n).size();m++){
                    arr[h++]=Buchet.get(n).get(m);
                }
            }
    }
}

冒泡排序

   public static void fastsort2(int [] array){
        for (int i=0;i<array.length;i++){
            for (int j=0;j<array.length-i;j++){//array.length-1防止数组下标溢出
                if (array[i]>array[j]){
                    int temp=array[j];
                    array[j]=array[i];
                    array[i]=temp;
                }
            }
        }
    }

插入排序

public void sort(int arr[])
13/04/2018 Page 234 of 283
 {
 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;
 }
 }

希尔排序

public class InsertSort {
    public static void main(String[] args) {
        int [] array=new int [10000000];
        for (int i=0;i<10000000;i++){
            array[i]= (int) (1+Math.random()*10000000);
        }
        long starTime=System.nanoTime();
        int mid=array.length/2;
        while(mid>0) {
            Sort(array,mid);
            mid=mid/2;
        }
        long endTime=System.nanoTime();

        long Time=endTime-starTime;
        System.out.println("希尔排序计算一千万随机数:"+Time/1000000.0+"毫秒");
    }
    public static void Sort(int [] array,int mid){
        for (int i=mid;i<array.length;i++){
            if (array[i]<array[i-mid]){
                int temp=array[i];
                int j=i;
                while(j-mid>0&&temp<array[j-mid]){
                    array[j]=array[j-mid];
                    j=j-mid;
                }
                array[j]=temp;
            }
        }
    }
}

堆排序

    /**
    * 选择排序-堆排序
    * @param array 待排序数组
    * @return 已排序数组
    */
    public static int[] heapSort(int[] array) {
        //这里元素的索引是从0开始的,所以最后一个非叶子结点array.length/2 - 1
        for (int i = array.length / 2 - 1; i >= 0; i--) {  
            adjustHeap(array, i, array.length);  //调整堆
        }
  
        // 上述逻辑，建堆结束
        // 下面，开始排序逻辑
        for (int j = array.length - 1; j > 0; j--) {
            // 元素交换,作用是去掉大顶堆
            // 把大顶堆的根元素，放到数组的最后；换句话说，就是每一次的堆调整之后，都会有一个元素到达自己的最终位置
            swap(array, 0, j);
            // 元素交换之后，毫无疑问，最后一个元素无需再考虑排序问题了。
            // 接下来我们需要排序的，就是已经去掉了部分元素的堆了，这也是为什么此方法放在循环里的原因
            // 而这里，实质上是自上而下，自左向右进行调整的
            adjustHeap(array, 0, j);
        }
        return array;
    }
  
    /**
    * 整个堆排序最关键的地方
    * @param array 待组堆
    * @param i 起始结点
    * @param length 堆的长度
    */
    public static void adjustHeap(int[] array, int i, int length) {
        // 先把当前元素取出来，因为当前元素可能要一直移动
        int temp = array[i];
        for (int k = 2 * i + 1; k < length; k = 2 * k + 1) {  //2*i+1为左子树i的左子树(因为i是从0开始的),2*k+1为k的左子树
            // 让k先指向子节点中最大的节点
            if (k + 1 < length && array[k] < array[k + 1]) {  //如果有右子树,并且右子树大于左子树
                k++;
            }
            //如果发现结点(左右子结点)大于根结点，则进行值的交换
            if (array[k] > temp) {
                swap(array, i, k);
                // 如果子节点更换了，那么，以子节点为根的子树会受到影响,所以，循环对子节点所在的树继续进行判断
                i = k;  //这一步决定了下一个步骤执行到的是左子树还是右子树
            } else {  //不用交换，直接终止循环
                break;
            }
        }
    }
  
    /**
    * 交换元素
    * @param arr
    * @param a 元素的下标
    * @param b 元素的下标
    */
    public static void swap(int[] arr, int a, int b) {
        int temp = arr[a];
        arr[a] = arr[b];
        arr[b] = temp;
    }

二分查找

public static int biSearch(int []array,int a){
int lo=0;
int hi=array.length-1;
int mid;
while(lo<=hi){
mid=(lo+hi)/2;//中间位置
if(array[mid]==a){
return mid+1;
}else if(array[mid]<a){ //向右查找
lo=mid+1;
}else{ //向左查找
hi=mid-1;
} }
return -1;
}