冒泡+快排+归并

排序算法复杂度总结：

摘自于超详细十大经典排序算法总结

1.冒泡排序算法

package sortMethod;

import java.util.Scanner;
import java.util.jar.JarOutputStream;

public class bubbleSort {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String s = sc.next();
        String[] arr_string = s.split(",");
        int[] arr = new int[arr_string.length];
        
        for(int i=0;i<arr.length;i++){
            arr[i] = Integer.parseInt(arr_string[i]);
        }
        for(int i=0;i<arr.length;i++){
            //关键：遍历i次，倒数第i个会排好顺序
            for(int j=0;j<arr.length-1-i;j++){
                if(arr[j+1]<arr[j]){
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
        System.out.println("arr");
        for(int i=0;i<arr.length;i++){
            System.out.print(arr[i]+",");
        }
    }
}

2.快速排序算法：

package sortMethod;

import java.util.Scanner;

public class test {
    public static void main(String[] args){
        Scanner sc  = new Scanner(System.in);
        String str = sc.next();
        //输入str通过分隔符","转化为String型数组
        String[] arr = str.split(",");
        int[] arr1 = new int[arr.length];
        //将String型数组转换为int型数组
        for(int i=0;i<arr1.length;i++){
            arr1[i] = Integer.parseInt(arr[i]+",");
        }

        quicksort(arr1,0,arr.length-1);
        for(int i=0;i<arr1.length;i++){
            System.out.print(arr1[i]);
        }

    }
    //分区：利用双指针思想为基准值pivot寻找中间的位置，并且返回该位置。
    public static int partition(int[] arr,int low,int high){
        int i = low;
        int j = high;

        int pivot = arr[low];
        while(i<j){
         //1.从右向左移动j，找到第一个小于基准值的值 arr[j]
            while(arr[j]>=pivot && i<j){
                j--;
            }
            //2.将右侧找到小于基准数的值加入到左边的（坑）位置， 左指针想中间移动一个位置i++
            if(i<j){
                arr[i] = arr[j];
                i++;
            }
             //3.从左向右移动i，找到第一个大于等于基准值的值 arr[i]
            while(arr[i]<=pivot && i<j){
                i++;
            }
            //4.将左侧找到的打印等于基准值的值加入到右边的坑中，右指针向中间移动一个位置 j--
            if(i<j){
                arr[j] = arr[i];
                j--;
            }
        }
        //使用基准值填坑，这就是基准值的最终位置
        arr[i] = pivot;
        //返回基准值的位置索引
        return i;
    }

    public static void quicksort(int[] arr,int low,int high){
        //利用递归的思想完成pivot左序列，pivot右序列的快排
        if(low < high){
            //分区操作，将一个数组分成两个分区，返回分区界限索引
            int index = partition(arr,low,high);
            //对左分区进行快排
            quicksort(arr,low,index-1);
            //对右分区进行快排
            quicksort(arr,index+1,high);
        }

    }
}

3.归并排序

package sortMethod;

import java.util.Arrays;

public class mergeSort {
    public static void main(String[] args) {
        int[] arr = {8,10,2,5,3};
        int[] ans = mergesort(arr);
        for(int i=0;i<ans.length;i++){
            System.out.print(ans[i]+" ");
        }

    }

    public static int[] mergesort(int[] arr){
        if(arr.length < 2){
            return arr;
        }
        int mid = arr.length/2;
        int[] left = Arrays.copyOfRange(arr,0,mid);
        int[] right = Arrays.copyOfRange(arr,mid,arr.length);
        return merge(mergesort(left),mergesort(right));
    }

//合并两个有序数组
    public static int[] merge(int[] left,int[] right){
        int[] ans = new int[left.length+right.length];
        for(int index=0,i=0,j=0;index<ans.length;index++) {
            if(i>=left.length){
                ans[index] = right[j++];
            }else if(j>=right.length){
                ans[index] = left[i++];
            }else if(left[i]>right[j]){
                ans[index] = right[j++];
            }else{
                ans[index] = left[i++];
            }

        }
        return ans;

    }
}

以上仅作为学习笔记，参考多个网站学习消化后所得，如有侵权，请联系，删。