目录

一.冒泡排序

相邻元素之间两两比较,大的放右边,小的放左边

二.选择排序

从0索引开始,拿着每一个索引上的元素和后面的元素依次标胶,小的放在前面,大的放在后面

三.插入排序

假如0到n索引的数据遵循从小到大排序,就可以将0-n看做有序的,则n+1到最大索引都是无序的

四.方法的递归

递归: 方法中调用方法本身(注意:递归要有出口,不然会出现内存溢出)

两个核心:

(1)找出口: 什么时候不再调用方法

(2)找规则: 然后把大问题化为小问题

五.快速排序

---

一.冒泡排序

相邻元素之间两两比较,大的放右边,小的放左边

代码示范:

package Demo;

public class BubbleDemo {
    public static void main(String[] args) {
        //定义一个数组
        int[] arr = {4,2,1,5,3};

        //利用冒泡排序,得到1 2 3 4 5

        //外循环,表示要循环多少次
        for (int i = 0; i < arr.length-1; i++) {
            //内循环:比较数据大小,看是否需要交换
            //-1: 防止索引越界
            //-i: 依次减少内循环的次数,提高效率
            for (int j = 0; j < arr.length-1-i; j++) {
                if(arr[j] > arr[j+1]){
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
        //遍历数组
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+" ");
        }

    }
}

结果展示:

 

二.选择排序

从0索引开始,拿着每一个索引上的元素和后面的元素依次标胶,小的放在前面,大的放在后面

代码示范:

package Demo;

public class Demo1 {
    public static void main(String[] args) {
        int[] arr = {2,1,5,4,3};

        //外循环: 循环几次
        //i: 表示这一轮中,我拿那个索引和后面的数据进行比较
        for (int i = 0; i < arr.length-1; i++) {
            //内循环:每一轮都要和i后的数据进行比较
            //j = i + 1
            for (int j = i+1; j < arr.length; j++) {
                if(arr[i] > arr[j]){
                    int temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
            }
        }
        //遍历
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+" ");
        }
    }
}

结果展示:

三.插入排序

假如0到n索引的数据遵循从小到大排序,就可以将0-n看做有序的,则n+1到最大索引都是无序的

代码示范:

package Demo;

public class InsertDemo {
    public static void main(String[] args) {
        //创建一个数组
        int[] arr = {12,45,67,23,65,98,54,66,75,28,31};

        //找到无序是在哪个索引开始的
        int startIndex = -1;//无序开始的索引初始化为-1,不存在-1索引
        for (int i = 0; i < arr.length; i++) {
            if(arr[i]>arr[i+1]){
                startIndex = i+1;
                break;
            }
        }

        //遍历从startIndex开始到最后一个元素
        for (int i = startIndex; i < arr.length; i++) {
            //创建一个变量来记录i
            int j = i;
            while(j > 0 && arr[j] < arr[j-1]){
                int temp = arr[j];
                arr[j] = arr[j-1];
                arr[j-1] = temp;
                j--;
            }
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+" ");
        }
    }
}

结果展示:

 

四.方法的递归

递归: 方法中调用方法本身(注意:递归要有出口,不然会出现内存溢出)

两个核心:

(1)找出口: 什么时候不再调用方法

(2)找规则: 然后把大问题化为小问题

练习:利用递归写一个方法,求1--100之间的和

代码示范:

package Demo;

public class Demo1 {
    public static void main(String[] args) {

        System.out.println(getSum(100));

    }
    public static int getSum(int number){
        //出口
        if(number == 1){
            return 1;
        }
        return number+getSum(number-1);
    }
}

结果展示:

 

五.快速排序

有点复杂,看代码试着理解

代码示范: 

package Demo;

public class QuickSortDemo {
    public static void main(String[] args) {
        int[] arr = {5,4,6,3,7,8,1,9,2};
        quickSort(arr,0,arr.length-1);
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+" ");
        }
    }
    public static void quickSort(int[] arr,int i, int j){
        int start = i;//起始索引
        int end = j;//结束索引

        //递归出口
        if(start > end){
            return;
        }
        //记录基准数
        int baseNumber = arr[i];
        while(start != end){
            //
            while(true){
                //从右往左找出小于基准数的数据
                if(end <= start || arr[end] < baseNumber){
                    break;
                }
                end--;
            }
            while(true){
                //从左往右找出大于基准数的数据
                if(end <= start || arr[start] > baseNumber){
                    break;
                }
                start++;
            }
            //交换数据
            int temp = arr[start];
            arr[start] = arr[end];
            arr[end] = temp;
        }
        int temp = arr[i];
        arr[i] = arr[start];
        arr[start] = temp;

        //确定第一轮基准数左边的范围,重复
        quickSort(arr,i,start-1);
        //确定第一轮基准数右边的范围,重复
        quickSort(arr,start+1,j);
    }
}

结果展示: