JAVA 基础算法-排序 冒泡排序 选择排序 插入排序 快速排序 kaki的博客

冒泡排序
口诀：两两替换，逐一比较

  //冒泡排序  逐一比较（第一个与第二个比较，第二个与第三个比较），两两替换
    public static void bubbo(int [] arr){
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr.length-1; j++) {
                if(arr[i]<arr[j]){
                    int temp =  arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
            }
        }
    }

选择排序
口诀：交换最小索引

   //选择排序  记录最小数据的索引并替换 交换索引
    public static void select(int [] arr){
        for (int i = 0; i < arr.length -1; i++) {
            int minIndex = i;
            for (int j = minIndex+1; j < arr.length; j++) {
                if(arr[minIndex]>arr[j]){
                    int tmep = arr[minIndex];
                    arr[minIndex]= arr[j] ;
                    arr[j] = tmep;
                }
            }
        }
    }

插入排序
口诀：与前一个比较，成立则代替，否则为最终

    //插入排序  记录一个数据值，依次比较其前面的值，如果大于它就放在后边，如果小于它位置不变
    public static void insert(int [] arr){
        int temp = 0;
        for (int i = 1; i < arr.length; i++) {
            temp = arr[i];
            int j = i-1;
            while (j>=0){
                if(arr[j]>temp){
                    //如果前一个数字大于当前数字，就取代当前数字位置
                    arr[j+1] = arr[j];
                }else {
                    break;
                }
                j--;
            }
            //直到前边的数字不大于当前数字，那该数字就是当前数字位置加1处
            arr[j+1] = temp;
        }
    }

经典递归案例

   //经典递归(累加)
    public int recursion(int sum){
        if (sum<1){
            throw new RuntimeException("sum > 1 才行");
        }

        if(sum== 1){
            return 1;
        }else {
            return sum + recursion(sum-1);
        }

    }

快速排序

 //快速排序
    public static void quickSort(int[] datas,int start,int end){
        if (start >= end) {//判断是否交叉
            return;
        } else {
            //中间位置
            int middle = findMiddle(datas,start,end);
            //数据分成2半
            quickSort(datas, start, middle -1);
            quickSort(datas, middle + 1, end);
        }
    }

    private static int findMiddle(int[] datas,int start,int end){
        //参照物
        int temp = datas[end];
        int left = start;//左下标
        int right = end - 1;//右下标

        //循环判断找位置
        while (true) {
            // 从左边找第一个比参照大的值
            while (left < end && datas[left] <= temp) left++;

            if (left == end) {
                //参照物是最大的
                break;
            }


            //从右边找第一个比惨照物小的值
            while (right >= start && datas[right] >= temp) right--;



            //判断是否交叉
            if (left < right) {
                //否：交换左右下标的值，继续
                change(datas, left, right);
                continue;
            } else {

                //有： 交换左下标和参照物的值，结束，左下标把数据分成2半，结束循环
                change(datas,left,end);
                break;
            }
        }



        return left;
    }

    private static void change(int datas[], int from, int to) {
        int temp = datas[from];
        datas[from] = datas[to];
        datas[to] = temp;
    }

欢迎点赞关注收藏哦 ，码云搜索KakiNakajima