十大排序算法(Java版)

总览

维基百科词条：

冒泡排序

流程图

Java代码

    //冒泡排序
    public void bubleSort(int arr[]){
    
    
        int len=arr.length;
        for(int i=1;i<arr.length;++i){
    
    
            for(int j=0;j<len-i;++j){
    
    
                if(arr[j+1]<arr[j]){
    
    
                    int temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
            }
        }
    }

复杂度分析

时间复杂度为O($N^2$),空间复杂度为O($1$),该排序算法是稳定的

选择排序

流程图

思路：从0索引处开始，依次和后面的元素进行比较 ，小的元素往前放，经过一轮比较后，最小的元素就放在了最小索引处，每经过一轮比较，索引位置 + 1。

Java代码

    //选择排序
    public static void selectSort(int[] arr) {
    
    
        int len=arr.length;
        for(int i=0;i<len-1;++i){
    
    
            for(int j=i+1;j<len;++j){
    
    
                if(arr[i]>arr[j]){
    
    
                    int temp=arr[i];
                    arr[i]=arr[j];
                    arr[j]=temp;
                }
            }
        }
    }

复杂度分析

时间复杂度为O($N^2$),空间复杂度为O(1),该排序算法是不稳定的

直接插入排序

流程图

Java代码

    //插入排序
    public static void insertSort(int[] arr){
    
    
        int len=arr.length;
        for(int i=1;i<len;++i){
    
    
            for(int j=i;j>0;--j){
    
    
                if(arr[j]<arr[j-1]){
    
    
                    int temp=arr[j];
                    arr[j]=arr[j-1];
                    arr[j-1]=temp;
                }
            }
        }
        return;
    }

复杂度分析

时间复杂度为O($N^2$),空间复杂度为O(1),该排序算法是稳定的。

快速排序

算法描述

参考B站：https://www.bilibili.com/video/BV15b4y117RJ?p=24

代码实现

单边循环：

class Solution {
    
    
    public int[] sortArray(int[] nums) {
    
    
        quick(nums,0,nums.length-1);
        return nums;
    }

    public void quick(int[] a,int x,int y){
    
    
        if(x>=y) return;
        int pivot=quickSort(a,x,y);
        quick(a,pivot+1,y);
        quick(a,x,pivot-1);
    }

    public int quickSort(int[] a,int x,int y){
    
    
        int pivot=a[y];
        int i=x;
        for (int j = i; j < y; j++) {
    
    
            if(a[j]<pivot){
    
    
                swap(a,i,j);
                i++;
            }
        }
        swap(a,i,y);
        return i;
    }

    public void swap(int[] a,int x,int y){
    
    
        int temp=a[x];
        a[x]=a[y];
        a[y]=temp;
    }
}

双边循环：

class Solution {
    
    
    public int[] sortArray(int[] nums) {
    
    
        quick(nums,0,nums.length-1);
        return nums;
    }

    public void quick(int[] nums,int left,int right){
    
    
        if(left>=right)
            return;

        int pivot=quickSort(nums, left, right);
        quick(nums,left,pivot-1);
        quick(nums,pivot+1,right);
    }

    public int quickSort(int[] nums,int left,int right){
    
    
        int temp=nums[left];
        int i=left;
        int j=right;
        while (i<j){
    
    
            while(i<j && nums[j]>temp)
                j--;
            while(i<j && nums[i]<=temp)
                i++;
            swap(nums,i,j);
        }
        swap(nums,i,left);
        return i;
    }

    public void swap(int[] nums,int i,int j){
    
    
        int temp=nums[i];
        nums[i]=nums[j];
        nums[j]=temp;
    }
}

复杂度分析

时间复杂度为O(nlogn),空间复杂度为O(logn)， 该算法是不稳定的