常见排序算法

冒泡排序

import java.util.Arrays;

public class BubbleSort {

    public static void sort(int [] arrs){
        //1.包含所有参与游戏的人物
        for(int i = arrs.length - 1;i > 0;i --){
            //2.控制交换手绢的过程
            for(int j = 0;j < i;j ++){
                //3.设置交换手绢的条件
                if(arrs[j] > arrs[j + 1]){
                    int temp = arrs[j];
                    arrs[j] = arrs[j+1];
                    arrs[j+1] = temp;
                }
            }
        }
    }

    public static void main(String[] args) {
        int []a = new int[] {9,5,1,2,7,3,4,8,6};
        BubbleSort.sort(a);
        //打印展示排序结果
        Arrays.stream(a).forEach(System.out::println);
    }
}

插入排序

import java.util.Arrays;

public class InsertionSort {

    public static void sort(int [] arrs){
        //1.循环购买玩具，模拟玩具的增加过程
        for(int i = 0;i < arrs.length;i ++){ //从左到右 -->循环
            //2.对自己已有的玩具进行排序
            for(int j = i - 1;j >= 0;j --){ //数据比较 -->从右往左
                //3.对玩具进行喜爱程度的排序
                if(arrs[j] > arrs[j + 1]){
                    //4.交换数据
                    int temp = arrs[j];
                    arrs[j] = arrs[j + 1];
                    arrs[j + 1] = temp;
                }
            }
        }
    }

    public static void main(String[] args) {
        int [] a = new int[] {10,8,100,78,66,33,88};
        InsertionSort.sort(a);
        Arrays.stream(a).forEach(System.out::println);
    }
}

快速排序

import java.util.Arrays;

/**
 * 快速排序的空间复杂度为O(logn)，时间复杂度为O(nlogn)
 */

public class QuickSort {

    public static void sort(int [] a,int left,int right){
        //设置排序结束的条件
        if(left > right){
            return;
        }
        //记录左边编号，记录右边编号
        int i = left,j = right;
        //记录基准数字
        int base = a[left];

        //核心算法
        while(i != j){
            //右侧编号查找数字
            while(j > i && a[j] >= base){
                j --;
            }

            //左侧编号查找数字
            while(i < j && a[i] <= base){
                i ++;
            }
            //数字交换
            if(i < j){
                int temp = a[i];
                a[i] = a[j];
                a[j] = temp;
            }
        }
        //基准数字和i位置数字的交换
        a[left] = a[i];
        a[i] = base;

        //i位置是基准数字，不再参与排序过程
        //左侧数字进行二次分类
        sort(a,left,i - 1);

        //右侧数字进行二次分类
        sort(a,i + 1,right);
    }

    public static void sort(int [] a){
        sort(a,0,a.length - 1);
    }

    public static void main(String[] args) {
        int [] a = {3,5,9,7,4,1,0,2};
        QuickSort.sort(a);
        System.out.println(Arrays.toString(a));
    }
}

选择排序

import java.util.Arrays;

public class SelectionSort {

    public static void sort(int[] arrs){
        //1.循环所有参与游戏的小伙伴
        for(int i = 0;i < arrs.length;i ++){

            //2.假设当前第一个位置的小伙伴，就是认识时间最短的
            int minIndex = i;

            //3.使用当前小伙伴和其他小伙伴做对比
            for(int j = i;j < arrs.length;j ++){
                //4.时间比较--数字比较
                if(arrs[j] < arrs[minIndex]){
                    minIndex = j;
                }
            }

            //5.真是交换数据
            if(minIndex != i){
                int temp = arrs[i];
                arrs[i] = arrs[minIndex];
                arrs[minIndex] = temp;
            }
        }
    }

    public static void main(String[] args) {
        int [] a = new int[]{1,10,8,29,48,10,5,18,4};
        SelectionSort.sort(a);
        Arrays.stream(a).forEach(System.out::println);
    }
}

希尔排序

import java.util.Arrays;

public class ShellSort {

    public static void sort(int [] arrs){
        //1.得到小组数目
        int gap = arrs.length / 2;
        //声明一个变量，记录当前数据
        int current;

        //2.循环遍历所有小组[小组是动态更新的]
        while(gap > 0){
            //3.对当前小组中的数据进行插入排序
            for(int j = gap;j < arrs.length;j ++){

                current = arrs[j]; //当前需要比较的数据
                int preIndex = j - gap; //得到小组内上一个数据的索引

                //4.内部数据进行插入排序
                while (preIndex >= 0 && current < arrs[preIndex]){
                    //数据交换
                    arrs[preIndex + gap] = arrs[preIndex];
                    preIndex -= gap;
                }
                arrs[preIndex + gap] = current;
            }

            gap = gap / 2;
        }
    }

    public static void main(String[] args) {
        int [] a = new int[] {19,80,2,7,4,1,10,12,88,44,33,29,80};
        ShellSort.sort(a);
        System.out.println(Arrays.toString(a));
    }
}