各排序算法java实现

 

package SortingAlgorithm;

import java.util.Arrays;

public class sortalgorithm {
    public static void main(String[] args) {
        int[] array = {3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48};
//        bubbleSort(array);
//        selectionSort(array);
//        insertionSort(array);
//        mergeSort(array);
//        quickSort(array);
        countSort(array);
        System.out.print(Arrays.toString(array));
    }
//    1.冒泡排序
//    最佳情况：T(n) = O(n) 最差情况：T(n) = O(n2) 平均情况：T(n) = O(n2)
    public static void bubbleSort(int[] array){
        if(array==null||array.length<=1)return;
        // 外层循环控制比较轮数i
        for(int i=0;i<=array.length-1;i++){
            // 内层循环控制每一轮比较次数，每进行一轮排序都会找出一个较大值
            // (array.length - 1)防止索引越界，(array.length - 1 - i)减少比较次数
            for(int j=0;j<array.length-1-i;j++){
                if(array[j]>array[j+1]){
                    int temp = array[j];
                    array[j]=array[j+1];
                    array[j+1]=temp;
                }
            }
        }
    }
//     2.选择排序
//     最佳情况：T(n) = O(n2) 最差情况：T(n) = O(n2) 平均情况：T(n) = O(n2)
//    它的工作原理：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，
//    然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。
    public static void selectionSort(int[] array) {
        if(array==null||array.length<=1) return;
        for(int i=0;i<array.length-1;i++){
            int minindex=i;
            for(int j=i+1;j<array.length;j++){
                if(array[j]<array[minindex]){
                    minindex=j;
                }
            }
            if(minindex!=i){
                swap(array,minindex,i);
            }
        }
    }
    private static void swap(int[] array, int a, int b) {
        int temp = array[a];
        array[a] = array[b];
        array[b] = temp;
    }
//    3.插入排序
//    最佳情况：T(n) = O(n) 最坏情况：T(n) = O(n2) 平均情况：T(n) = O(n2)
//    它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。
    public static void insertionSort(int[] array) {
        if(array==null||array.length<=1)return;
        for(int i=1;i<array.length;i++){
            int insertNum = array[i];
            int j=i-1;
            while(j>=0&&array[j]>insertNum){
                array[j+1]=array[j];
                j--;
            }
            array[j+1]=insertNum;
        }
    }
//    4.归并排序
//    最佳情况：T(n) = O(nlogn) 最差情况：T(n) = O(nlogn) 平均情况：T(n) = O(nlogn)
    public static void mergeSort(int[] array) {
        if(array==null||array.length<=1)return;
        sort(array,0,array.length-1);
    }
    public static void sort(int[] array,int left,int right){
        if(left==right){return;}
        int mid = (left+right)>>1;
        sort(array,left,mid);
        sort(array,mid+1,right);
        merge(array,left,mid,right);
    }
    public static void merge(int[] array,int left,int mid,int right){
        int[] temp = new int[right-left+1];
        int p1 = left;
        int p2 = mid+1;
        int i=0;
        while(p1<=mid&&p2<=right){
            temp[i++]=array[p1]<array[p2]?array[p1++]:array[p2++];
        }
        while(p1<=mid) temp[i++]=array[p1++];
        while(p2<=right) temp[i++]=array[p2++];
        for(i=0;i<temp.length;i++){
            array[left+i]=temp[i];
        }
    }
//    5.快速排序
//    最佳情况：T(n) = O(nlogn) 最差情况：T(n) = O(n2) 平均情况：T(n) = O(nlogn)
//    从数列中挑出一个元素，称为 “基准”（pivot）；
//重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。
// 在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；
//递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。
    public static void quickSort(int[] array) {
        quickSort(array,0,array.length-1);
    }
    public static void quickSort(int[] array,int left,int right){
        if(array==null||left>=right||array.length<=1)return;
        int mid = partition(array,left,right);
        quickSort(array,left,mid);
        quickSort(array,mid+1,right);
    }
    private static int partition(int[] array, int left, int right){
        int temp = array[left];
        while(left<right){
            while(temp<=array[right]&&left<right){
                right--;
            }
            if(left<right){
                array[left]=array[right];
                left++;
            }
            while(temp>=array[left]&&left<right){
                left++;
            }
            if(left<right){
                array[right]=array[left];
                right--;
            }
        }
        array[left]=temp;
        return left;
    }
//******************************************************************
//    6.计数排序
    public static void countSort(int[] array) {
        if(array==null||array.length<=1) return;
        int max = array[0];
        int min =array[0];
        for(int i=0;i<array.length;i++){
            if(max<array[i]) max=array[i];
            if(min>array[i]) min=array[i];
        }
        int len = max-min+1;
        int[] countArray = new int[len];
        for(int i=0;i<array.length;i++){
            countArray[array[i]-min]++;
        }
        int index=0;
        for(int i=0;i<countArray.length;i++){
            for(int j=0;j<countArray[i];j++){
                array[index++]=i+min;
            }
        }
    }


}