Java基础(冒泡排序 和 选择排序 和 快速排序) 比较细的详情

详情网站：https://blog.youkuaiyun.com/qq_41679818/article/details/90296399   

  public static void main(String[] args) {
       //冒泡排序简介(从小到大排序）
        int[] numbrs = new int[]{1, 5, 8, 2, 3, 9, 4};
        for (int i = 0; i < numbrs.length - 1; i++) { //numbrs.length本来7数字  numbrs.length - 1 就是6个数 比较 6个数据就可以了 这样就能找出最小值    numbrs.length 数组下标长度7，numbrs.length-1数组下标长度变成长度是6
            for (int j = 0; j < numbrs.length - 1 - i; j++) {

                 //System.out.println(numbrs[j]);//numbrs[j]就是当前数字是  1, 5, 8, 2, 3, 9, 4
                 //System.out.println(numbrs[j+1]);//numbrs[j+1]就是j后一位数字 比如 int[]{1, 5, 8, 2, 3, 9, 4};  就是j后一位数字  5, 8, 2, 3, 9, 4

                //判断一个numbrs[j]下标值比 numbrs[j + 1]下标值还要小就进入判断赋值numbrs[j]
                if (numbrs[j] > numbrs[j + 1]) {//> 大于判断从小到大排序后  < 小于判断从大到小排序后

                    //数字大小交换  比如 第一个瓶子和第二个瓶子水 交换 
                    // 分析以下
                    // 第一瓶水倒入第二瓶水，就会漏出，然后就要借用tepm变量设置为 第三空瓶
                    // 第一瓶水倒入第三空瓶，然后第三瓶装满了
                    // 然后第一瓶没水，就把第二瓶水倒入第一瓶, 然后第二瓶没水，就把第三瓶水倒入第一瓶  这样就成功二瓶水切换了 就是大小切换了
                    
                    
                    
                    int tepm = numbrs[j];//  numbrs[j]是第一瓶水倒入 tepm是第三空瓶
                    numbrs[j] = numbrs[j + 1];// numbrs[j + 1]是第二瓶水倒入numbrs[j]第一瓶水
                    numbrs[j + 1] = tepm; // tepm是第三瓶水倒入第二瓶
                }
            }
        }
        System.out.println("从小到大排序后的结果是:");
        for (int i = 0; i < numbrs.length; i++) {
            System.out.print(numbrs[i] + "");//打印 输出 1234589
        }
}

 

 public static void main(String[] args) {
        //选择排序 从小到大排序
        int[] nums = {2, 9, 5, 7, 3};
        //外循环 循环nums 长度
        //nums .length本来5数字  nums .length - 1 就是4个数 比较 4个数据就可以了
        for (int i = 0; i < nums.length - 1; i++) {
            //最小下标
            int min = i; // 比如最小值是 i
            // 从i+1开始找，找到最小的数
            //内循环结束，最小的值就找到了
            for (int j = i + 1; j < nums.length; j++) {
                //System.out.print(" i:"+nums[min]);  //输出  i:2 i:2 i:2 i:2 i:9 i:5 i:5 i:5 i:5 i:7
                //System.out.print(" min:"+min); //输出min下标  min:0 min:0 min:0 min:0 min:1 min:2 min:2 min:2 min:2 min:3

                // System.out.print(" j:"+nums[j]);     //输出 j:9 j:5 j:7 j:3 j:5 j:7 j:3 j:7 j:3 j:3
                // System.out.print(" j:"+j);     //输出j下标  j:1 j:2 j:3 j:4 j:2 j:3 j:4 j:3 j:4 j:4

                //然后将nums[min]下标和nums[j]下标进行比较 比nums[min]小的 则对min重新赋值  nums[min] 下标是1 数字就是9 , nums[j])下标是2 数字就是5
                if (nums[min] > nums[j]) {// 判断一个下标值比它还要小  赋值给 min
                    min = j;// j当前最小值下标 赋值 给 min
                }
            }
            //数字位置大小交换
            //比如 第一个瓶子和第二个瓶子水 交换
            // 分析以下
            // 第一瓶水倒入第二瓶水，就会漏出，然后就要借用tepm变量设置为 第三空瓶
            // 第一瓶水倒入第三空瓶，然后第三瓶装满了
            // 然后第一瓶没水，就把第二瓶水倒入第一瓶, 然后第二瓶没水，就把第三瓶水倒入第一瓶  这样就成功大小切换了

            if (min != i) {
                int temp = nums[min];//nums[min]是第一瓶水倒入 tepm是第三空瓶
                nums[min] = nums[i];//  nums[i]是第二瓶水倒入nums[min]第一瓶水
                nums[i] = temp;// tepm是第三瓶水倒入第二瓶nums[i]
            }
        }
        System.out.println();
        System.out.println("交换后：");
        for (int num : nums) {
            System.out.print(num + " ");// 输出 2 3 5 7 9
        }
}

 

 //快速排序
 public static void main(String[] args) {

        int[] arr = {-9,78,0,23,-567,70};
        quickSort(arr,0,arr.length -1);
        System.out.println("arr="+ Arrays.toString(arr));//输出 arr=[-567, -9, 0, 23, 70, 78]

    }

    public static void quickSort(int[] arr,int left,int rigth){
      // 快速排序思路分析
      // 数据{-9,78,0,23,-567,70}
      // 0是中间值 用小于0和大于0 就行判断
      // 向左递归 -9,-567, 0 , 向右递归23,78,70

      int l = left;
      int r = rigth;
      int temp = 0;
      // pivot 中间值
      int pivot = arr[(left+rigth) /2];
      //while循环的目的地是让比pivot 值小放到左边
      //比pivot值大放到右边
      while (l < r){

          //在pivot的左边一直找，找到大于等于pivot值,才退出
          while (arr[l] < pivot){
              //{-9,78,0,23,-567,70};
              l += 1;//+1 就是在left 最左边的值一直加一直找 // 比如 -9 加1就是 78
          }
          //在pivot的右边一直找，找到小于等于pivot值,才退出
          while (arr[r] > pivot){
              //{-9,78,0,23,-567,70};
              r -=1; //-1 就是在rigth 最右边的值一直减一直找 // 比如 70 减1就是 -567
          }
          //如果l>=r说明pivot 的左右两的值,已经按照左边全部是小于等于pivot值,
          //右边全部是大于等于pivot值
          if (l >= r){
              break;
          }
          //交换
          temp = arr[l];
          arr[l]= arr[r];
          arr[r]= temp;

          //如果交换完成后,发现这个arr[l] == pivot值相等 --,前移
          if (arr[l] == pivot){
              r -= 1;
          }
          //如果交换完成后,发现这个arr[r] == pivot值相等 1++,后移
          if (arr[l] == pivot){
              l += 1;
          }
      }
      //如果l == r ,必须 l++,r--,否则为出现溢出
        if (l == r){
            l += 1;
            r -= 1;
        }

        //向左递归
        if (left < r){
           quickSort(arr,left,r);
        }
        //向右递归
        if (rigth > l){
            quickSort(arr,l,rigth);

        }
    }

 

双层循环

int[] numbrs = new int[]{1, 5, 8, 2, 3, 9, 4};
for (int i = 0; i < numbrs.length-1 ; i++){// 外层循环控制行数 一共6行

    for (int j = 0; j < numbrs.length - 1 - i; j++){//内循环打印 每行数的次数
        System.out.println(" i的值："+numbrs[i]+"  j的值："+numbrs[j]  );

 i的值：1  j的值：1
 i的值：1  j的值：5
 i的值：1  j的值：8
 i的值：1  j的值：2
 i的值：1  j的值：3
 i的值：1  j的值：9
 i的值：5  j的值：1
 i的值：5  j的值：5
 i的值：5  j的值：8
 i的值：5  j的值：2
 i的值：5  j的值：3
 i的值：8  j的值：1
 i的值：8  j的值：5
 i的值：8  j的值：8
 i的值：8  j的值：2
 i的值：2  j的值：1
 i的值：2  j的值：5
 i的值：2  j的值：8
 i的值：3  j的值：1
 i的值：3  j的值：5
 i的值：9  j的值：1
    }
}

 

 

//打印输出

j+1

1
2
3
4
5
6

1
2
3
4
5

1
2
3
4

1
2
3

1
2

 System.out.println(numbrs[j+1]);

5
8
2
3
9
4

5
8
2
3
9

5
8
2
3

5
8
2

5
8

5

System.out.println(numbrs[j]);

1
5
8
2
3
9

1
5
8
2
3

1
5
8
2

1
5
8

1
5

1

System.out.println(tepm);
8
9
8
8
8