JAVA黑马程序员之排序算法（冒泡排序、选择排序、插入排序、递归算法、快速排序）

冒泡排序

package Sort_code;

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

        //利用冒泡排序将数组中的元素变成1 2 3 4 5
        //第一轮结束之后，最大值在数组的最右边 .....5
        //外循环：表示我要执行多少轮，如果有n个数据那么执行n-1轮
        for (int i = 0; i < arr.length-1; i++) {
            //内循环：每一轮中我如何比较数据并找到当前的最大值
            //-1：为防止索引越界
            //-i:提高效率，每一轮执行的次数应该比上一轮少一次
            for(int j=0;j<arr.length-1-i;j++){//选中j，按shift+f6即可替换循环中所有用到j的地方
                //i依次表示数组中的每一个索引0 1 2 3 4
                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.println(arr[i]);
        }
    }
}

选择排序

package Sort_code;
//选择排序
public class A02_SelectionDemo {
    public static void main(String[] args) {
        //1、定义数组
        int[] arr={2,4,5,3,1};

        //外循环:循环几轮
        //i:表示这一轮中，我拿着哪个索引上的数据跟后面的数据进行比较并交换
        for (int i = 0; i < arr.length-1; i++) {
            //内循环：每一轮我要干什么事？
            //拿着i跟i后面的数据进行比较交换
            for (int j = i+1; j < arr.length; j++){ //内循环中的索引是从i+1开始的
                if(arr[i]>arr[j]) {
                    int temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
            }
        }
        for (int k = 0; k < arr.length; k++) {
            System.out.println(arr[k]);
        }
    }
}

插入排序

package Sort_code;
//插入排序
public class A03_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;
                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);
    }

    public static void printarr(int[] arr){
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }

}

递归求1-100的和

递归核心：1、找出口 2、找规律 3、方法内部再次调用方法的时候，参数必须要更靠近出口

package Sort_code;
//递归:求1-100的和
public class A04_RecursionDemo2 {
    public static void main(String[] args) {

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

    public static int getSum(int num){
        if(num==1){
            return 1;
        }

        return num+getSum(num-1);
    }
}

用递归求5的阶乘

package Sort_code;
//递归求5的阶乘
public class A04_RecursionDemo3 {
    public static void main(String[] args) {
        System.out.println(getFactorialRecursion(5));
    }

    public static int getFactorialRecursion(int num){
        if(num==1){//出口
            return 1;
        }

        return num * getFactorialRecursion(num-1);
    }
}

递归原理：

快速排序

package Sort_code;

public class A05_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);
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+" ");
        }
    }

    /*参数一：我们要排序的数组
    * 参数二：要排序数组的起始索引
    * 参数三：要排序数组的结束索引
    * */
    public static void quickSort(int[] arr,int i,int j){
        //start，找比0索引大的
        int start=i;
        //end,找比0索引小的
        int end=j;

        if(start>end){//递归的出口,要写在basenum的前面
            return;
        }

        //basenum表示arr[0]基准数
        int basenum=arr[i];

        //利用循环找到要交换的数字，注意最外层的大循环是start!=end
        while(start!=end){
            while(true){
                //利用end从后往前找比基准数小的，注意要先移动end再移动start
                if(end<=start||arr[end]<basenum){
                break;
                    }
                    end--;
                }

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

        //两个循环都结束了，说明到这里start和end已经找到，这里进行交换
        int temp=arr[start];
        arr[start]=arr[end];
        arr[end]=temp;
        }

        //最外层循环结束说明end==start，此时基准元素归位
        int temp2=arr[i];
        //i是传进来的参数，表示要排序数组的起始索引,
        // 注意此处arr[i]不能用bsenum替代，因为basenum仅表示一个数，不表示数组中的元素
        arr[i]=arr[start];
        arr[start]=temp2;

        //确定6左边的范围，重复刚刚所做的所有事
        quickSort(arr,i,start-1);//递归

        //确定6右边的范围，重复刚刚所做的所有事
        quickSort(arr,start+1,j);
    }
}