2021-03-22

排序算法

冒泡排序

/**
 * 冒泡排序
 * 稳定
 * 内排序
 * 最佳情况：数列有序，则时间复杂度为O(n)，比较次数n，移动次数为0
 * 最坏情况：数列逆序，则时间复杂度为O(n^2)，比较次数n*（n-1）/2(等差数列求和)，移动次数为n*（n-1）/2
 * 平均情况：数列杂序，则时间复杂度为O(n^2)
 * 空间复杂度O(1)
 * 
 */
public class BubbleSort{
    public static int[] bubbleSort(int[] array){
        if(array.length == 0){
            return array;
        }
        Boolean isSwap = false;
        for (int i=0;i<array.length;i++){
            for(int j =0;j<array.length-i-1;j++){
                if (array[j]>array[j+1]){
                    int temp =  array[j+1];
                    array[j+1] = array[j];
                    array[j] = temp;
                    isSwap = true;
                }
    
            }
            
            if (isSwap = false){
                return array;
            }
        }
        
        return array;
    }
    public static void main(String[] args) {
        System.out.println("bubble sort");
        int[] in = {1,23,43,2,34,45};
        int[] array = bubbleSort(in);
        for (int i : array) {
            System.out.println(i);
        }
    }
}

归并排序

import java.util.Arrays;

/**
 * 归并排序
 * 稳定
 * 内排序
 * 最佳情况：数列有序，则时间复杂度为O(nlog2n)
 * 最坏情况：数列逆序，则时间复杂度为O(nlog2n)
 * 平均情况：数列杂序，则时间复杂度为O(nlog2n)
 * 空间复杂度O(n)
 * 
 */
public class MergeSort{
    /**
     * 归并排序
     */
    public static int[] MergeSort(int[] array){
        if(array.length == 1){
            return array;
        }
        int middle = array.length/2;
        int[] left = Arrays.copyOfRange(array, 0, middle);
        int [] right = Arrays.copyOfRange(array, middle, array.length);
        int[] result = merge(MergeSort(left), MergeSort(right));
        return result;
    }

    public static int[] merge(int[] left ,int[] right ){
        int [] result  = new int[left.length+right.length];
        for(int i=0,j=0,k=0;i<result.length;i++){
            if (j>=left.length){
                result[i] = right[k++];
            }else if(k>=right.length){
                result[i] = left[j++];
            }else if(left[j]>right[k]){
                result[i] = right[k++];

            }else{
                result[i] = left[j++];
            }
        }
        return result;
    }
    public static void main(String[] args) {
        System.out.println("bubble sort");
        int[] in = {1,23,43,2,34,45};
        int[] array = MergeSort(in);
        for (int i : array) {
            System.out.println(i);
        }
    }
}