用Java实现三大基本排序(冒泡排序、选择排序、插入排序)。个人思路

Java数组三大基本排序

1、冒泡排序
2、选择排序
3、插入排序
个人思路，大家互相参考，讨论
排序是把一堆数组有小到大、由大到小从头到尾按照一定的顺序排列起来的。（全部以从小到大排列讨论）

1、冒泡排序

冒泡排序指数组中的从头开始的元素两个两个相比，数组中的一二相比、二三相比、三四相比········
每两个数相比完就排一次。排完后，再比较下一个（二三相比）一直向下····直到排序完成。
按照这样的方式依次向下比较排序，通过这样的排序，可以直接把数组中的最大值直接排到数组最后，则下一次的排序，可以不用管最后一个数组比较，这样可以大幅优化代码时间复杂度。

import java.util.Arrays;

public class Demo1 {
   
    public static void main(String[] args){
   
        int [] a = new int[] {
   3,4,2,1,1,5};
        //                    4 3 2 1 1 5
        //                    3 2 1 1 4 5
        //                    2 1 1 3 4 5
        //                    1 1 2 3 4 5
        for (int i = 0; i < a.length-1; i++) {
   
            for (int j = 0; j < a.length-1-i; j++) {
   
                if (a [j] > a [j+1]){
   
                    //加不加等于号，对于在数组相等情况下的排序不造成任何影响
                    int num;
                    num = a[j] + a[j+1];
                    a[j] = num - a[j];
                    a[j+1] = num - a[j+1];
                    /*这是另一种交换数据的方法
                    num = a[j+1];
                    a[j+1] = a[j];
                    a[j] = num;     */
                }
            }
        }
        //打印输出数组中的元素
        System.out.println(Arrays.toString(a));
    }
}

外层循环控制数组中的元素从第一个开始往后每一个都比较到
内层循环控制数组比较的元素与后面的每一个元素进行一一对比

输出结果为

2、选择排序

数组从头开始的元素与其后的所有元素依次比较，选择最小的放在其比较的元素位置。
选择排序同冒泡排序一样，每次排序后都会确定之前那的元素不会再改变，之所以之前的元素可以不用再参与循环，同样可以减少时间复杂度

import java.util.Arrays;

public class Demo1 {
   
    public static void main(String[] args) {
   
        int [] a = {
   4,5,1,2,3};
        //          5,4,1,2,3
        //          1,4,5,2,3
        //          1,2,4,5,3
        //          1,2,3,5,4
        //          1,2,3,4,5
        for (int i = 0; i < a.length - 1; i++) {
   //外层循环，控制第几个数字开始相比较
            for (int j = i+1; j < a.length; j++) {
   
                //内层循环，控制int i 与之后的数字相比较（是int i之后的元素相比较）
                if ( a[i] > a[j]){
   
                    int num = a[i];
                    a[i] = a[j];
                    a[j] = num;
                }
            }
        }
        System.out.println(Arrays.toString(a));
    }
}

输出结果为
也可以借用C语言指针的思想，来看这个问题，在循环内部传递数组的下标，这样更能减少一些时间复杂度（这里是用空间复杂度的增加，减少时间复杂度）

import java.util.Arrays;

public class Demo1 {
   
    public static void main(String[] args) {
   
        int[] a = {
   5,4,1,2,3};
        for (int i = 0; i < a.length-1; i++) {
   //外层循环，把 i 设为最小值
            int min = i;
            for (int j = i+1; j < a.length; j++) {
   //与之后的数相比，把第 j 个数字设为min
                if (a[min] > a[j]){
   
                    min = j;//只进行位置的交换
                }
            }
            //交换第i个数字和min的数组交换
            int temp = a[i];
            a[i] = a[min];
            a[min] = temp;
        }
        System.out.println(Arrays.toString(a));
    }
}

3、插入排序

就是从数组中的第二个数字开始循环，从当前这个数开始向前依次比较，一旦发现比它小的，就进行交换。
插入排序就好比，打牌时，整理牌时，从最左边的第二个开始看起，把现在看的牌跟之前的牌依次从右到做依次比较，直到找到比一张牌小时，就可以停止了，把这张牌放到这个位置即可。插入排序的思想就和这个一样理解即可。

import java.util.Arrays;

public class Demo1 {
   
    public static void main(String[] args) {
   
        int[] a = {
   4,3,2,5,1};
        //外层循环，控制第几个数字进行循环
        for(int i = 1; i < a.length; i++) {
   
            //内层循环控制进行与之前的比较
            for (int j = i; j > 0; j--) {
   
                if (a[j-1] > a[j]){
   
                    int t = a[j-1];
                    a[j-1] = a[j];
                    a[j] = t;
                }else {
   
                    break;//一旦前面的没有这个数字大时，即可结束内层循环，减少时间复杂度
                }
            }
        }
        System.out.println(Arrays.toString(a));
    }
}

同选择排序一样，插入排序也可以用空间复杂度来换取时间复杂度。
插入排序代码对初学者，可能难懂，详细注释在代码注释里有详细解析

import java.util.Arrays;

public class Demo1 {
   
    public static void main(String[] args) {
   
        int a[] = {
   3,4,2,1,5};
        for (int i = 0; i < a.length-1; i++) {
   
            int place = i;  //计数当前排序的位置,初始值是当前排序位置的前一个
            int data = a[i+1];//记录当前所要比较位置的数据，从数组中的第二个开始
            while (place >=0 && a[place]>data){
   
        //判断当前循环计数在循环体内，并且前面的元素比调取的元素data大，执行循环
                a[place+1] = a[place];//把前面的小值赋值给后面的
                place --;//前面的数组位置向前推进一个
            }
            a[place + 1] = data;
    //把当前比较的元素放到循环判断结束后的位置，因为循环结束完前还多减了一个place，在这补上
        }
        System.out.println(Arrays.toString(a));
    }
}

好了，这就是用Java实现三大经典排序，欢迎大家讨论。