冒泡排序，选择排序

目录

一 冒泡排序

二 选择排序

三 插入排序

四 递归排序

五 快速排序

---

一 冒泡排序

1.相邻的数据两两比较，小的放前面，大的放后面。

2.第一轮循环结束，最大值已经找到，在数组的最右边。

3.第二轮循环只要在剩余的元素找到最大值就可以了。

4.每二轮循环结束，次大值已经确定，第三轮循环继续在剩余数据中循环。

二 选择排序

选择排序：从0索引开始，拿着每一个索引上的元素跟后面的元素一次比较，小的放前面，大的放后面，以此类推。

第一轮;0索引和后面的元素一一比较，第一轮结束后，最小的数据已经确定了。

第二轮：则是从1索引和后面的元素一一比较，以此类推。

public class SelectionDemo {
    public static void main(String[] args) {
        //1.定义数组
        int[] arr = {2, 4, 5, 3, 1};
        //2.利用选择排序让数组变成1，2，3，4，5
        /*//第一轮：从0索引开始，和后面的元素一一比较；
        for (int i = 0+1; i <arr.length; i++) {
            if (arr[0] > arr[i]) {
                int temp = arr[0];
                arr[0] = arr[i];
                arr[i] = temp;

            }
        }*/
        //最终代码
        //外循环：表示要循环几轮；
        //i表示这一轮我拿着哪个索引上的数据和后面的数据进行比较和交换；
        for (int i = 0; i < arr.length-1; i++) {
            //内循环：表示每一轮我要干什么
            //拿着i跟i后面的数据进行比较交换；
            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;
                }
            }
        }
        printArr(arr);
    }
    private static void printArr(int[] arr){
        //3.遍历数组
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+"");
        }
        System.out.println();
    }
}

三 插入排序

（打扑克时让扑克牌变得有顺序，就是插入排序）

插入排序：将0索引的元素到N索引的元素看作是有序的，把N+1索引的元素到最后一个当成是无序的，遍历无序的数据，将遍历到的元素插入有序序列中适当位置，如遇到相同数据，插在后面。

N的范围：0~最大索引；

public class InsertDemo {
    public static void main(String[] args) {
        //插入排序
        int[] arr = {3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48};
        //1.第一步：找到无序的那一组数据是从哪个索引开始的；2
        int startIndex = -1;
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] > arr[i + 1]) {
                startIndex=i+1;
                //表示有序的那一组数据到1索引就结束了；
                break;
            }
        }
        //2.遍历从startIndex开始到最后一个元素，依次得到无序的那一组数据的每一个元素；
        for (int i = startIndex; i < arr.length; 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--;
            }

        }
        printArr(arr);
    }

    private static void printArr(int[] arr) {
        //3.遍历数组
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + "");
        }
        System.out.println();
    }
}

四 递归排序

递归算法;递归指的是方法中调用方法本身的现象。

public class RecursionDemo1 {
    public static void main(String[] args){
        method();
    }
    private static void method() {
        method();
    }
}

递归就是自己调用自己，但是如上图所示调用会出现报错；

但是值得注意的是：递归一定要有出口，否则就会出现内存溢出；

递归算法的所用：

把一个复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解。

递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算；

书写递归的两个核心:

1.找出口，什么时候不在调用方法；

2.找规则：如何把大问题变成规模较小的问题；

public class RecursionDemo2 {
    public static void main(String[] args) {
        //利用递归求1~100之间的和；
        //1~100之间的和：1~99之间的和；
        System.out.println(getSum(100));//5050
    }
    public static int getSum(int number){
        if(number==1){
            return 1;
        }
        //number不为1
        return number+getSum(number-1);
    }
}

public class RecursionDemo3 {
    public static void main(String[] args) {
        //利用递归求5的阶乘，把结果在控制台输出；
        //出口：参数为1时自动不再调用；
        //找规律
        //心得：方法内部再次调用方法的时候，参数必须要更加的靠近出口；
        //因为第一次调用为5，第二次4，以此类推；
        System.out.println(getFactorialRecursion(5));//120
    }
    public static int getFactorialRecursion(int number){
        if(number==1){
            return 1;
        }
        return number*getFactorialRecursion(number-1);
    }
}

五 快速排序

第一轮：把0索引的数字作为基准数，确定基准数在数组中正确的位置。

• 将排序范围中的第一个数字作为基准数，再定义两个变量start，end;
• start是从前往后找比基准数大的，end是从后往前找比基准数小的。
• 找到之后交换start和end指向的元素，并循环这一过程，直到start和end处于同一个位置，该位置是基准数在数组中应存入的位置，再让基准数归位；
• 归位后的效果：基准数左边的，比基准数小，基准数右边的，比基准数大；

比基准数小的全部在左边，比基准数大的全部在右边；

基准数归位；

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

    }
        public static void quickSort ( int[] arr, int i, int j){
            //定义两个变量记录要查找的范围；
            int start = i;
            int end = j;
            if(start>end){
                return;
            }
            //2.记录基准数
            int baseNumber = arr[i];
            //利用循环找到要交换的数字；
            while (start != end) {

                //利用end从后往前开始找，比基准数小的数字；
                while (true) {
                    if (end <= start || arr[end] < baseNumber) {
                        break;
                    }
                    end--;
                }
                //利用start从前往后找，比基准数大的数字；
                while (true) {
                    if (end <= start || arr[start] > baseNumber) {
                        break;
                    }
                    start++;
                }

                //把end和start指向的元素进行交换；
                int temp=arr[start];
                arr[start]=arr[end];
                arr[end]=temp;
            }
            //当start和end指向了同一个元素的时候，上面的循环则会结束；
            //此时表示已经找到了基准数在数组中应存入的位置；
            //基准数归位；
            //就是拿着这个范围中的第一个数字跟start交换
            int temp=arr[i];
            arr[i]=arr[start];
            arr[start]=temp;
            //确定6左边的范围，重复刚刚所做的事情
            quickSort(arr,i,start-1);
            //确定6右边的范围，重复刚才所做的事情
            quickSort(arr,start+1,j);


        }
    }

总结：冒泡排序和选择排序最为重要；