Java学习day05：排序，选择、冒泡、快速、二分、杨辉三角

声明：该专栏本人重新过一遍java知识点时候的笔记汇总，主要是每天的知识点+题解，算是让自己巩固复习，也希望能给初学的朋友们一点帮助，大佬们不喜勿喷(抱拳了老铁！)

---

Java学习day05：排序，选择、冒泡、快速、二分、杨辉三角

一、选择排序

1.原理：

找到最小值的索引，然后和第1个数据进行交换。再找除了第一个数据以外的最小值的索引。然后和第二个数据交换

2.代码示例：

public class Demo1 {
 public static void main(String[] args) {
  //选择排序
  int[] arr = {3,4,1,5,2};
  /**
   * i=0 0<4 true minIndex=0  
   *    进入内层的for循环
   *    j=0 0<5 true arr[0] >arr[0]false j++
   *    j=1 1<5 true arr[0] >arr[1] false j++
   *    j=2 2<5 true arr[0]>arr[2]true minIndex=2 j++
   *    j=3 3<5 true arr[2]>arr[3]fasle j++
   *    j=4 4<5 true arr[2]>arr[4] fasle j++
   *    j=5 5<5fasle循环结束
   *    执行交换代码
   *    temp = arr[2]=1
   *    arr[2] = arr[0] {3,4,3,5,2}
   *    arr[0] = 1  {1,4,3,5,2} i++
   * i=1 1<4 true minIndex =1
   *      ......
   * 
   */
  for (int i = 0; i < arr.length - 1; i++) {//控制的是轮数
   int minIndex = i;
   for (int j = i; j < arr.length; j++) {//遍历咱们的数据找到最小值的索引的
    if (arr[minIndex] > arr[j]) {
     minIndex = j;
    }
    
   }
   //交换位置
   int temp = arr[minIndex];
   arr[minIndex] = arr[i];
   arr[i] = temp;
  }
  System.out.println(Arrays.toString(arr));
 }

}

 代码写的非常详细，大家把代码看懂就好

二、冒泡排序

 1.原理：

从小到大排序，比较两个相邻的数据，如果左边比右边元素大就交换位置。如果左边比右边小，就不变

2.代码示例

public class Demo2 {

 public static void main(String[] args) {
  //冒泡 排序和索引没有关系
  int[] arr = {1,5,2,3};
  for (int i = 0; i < arr.length - 1; i++) {
   //最内层的循环两两比较交换位置
   //4-1-i=>i=0  第1轮   3次
   //4-1-i=>i=1 第2轮   2次
   //4-1-i=>i=2 第3轮  1次
   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;
    }
   }
  }
  System.out.println(Arrays.toString(arr));
 }
}

3.二者比较

这里要提的一点，区分选择排序和冒泡排序，选择排序是每次遍历所有数据，找出最大的那个并和第一个交换，所以代码里是内层for循环结束后在外层for循环里交换，而冒泡排序则是每次把相邻的两个数进行比较，如果前面的大则交换位置，这样比较下去最终最大的那个数就会冒出来，这也就是为什么，冒泡是在内存for循环里交换，并且变量j的初始值为0，而不是i。

三、快速排序

1.原理

快速排序是一种常用的排序算法，它的基本思想是通过分治的方法将一个大问题拆分成若干个小问题来解决，选择一个基准元素（通常选择数组的第一个元素）将数组分成两部分，一部分小于基准元素，一部分大于基准元素，对这两部分分别进行快速排序递归地重复以上步骤，直到每个子数组只有一个元素或者为空。

2.代码示例

举个例子，假设我们要对数组[5, 3, 8, 2, 1, 9]进行快速排序：选择基准元素为5，将数组分成[3, 2, 1]和[8, 9]两部分，对两部分分别进行快速排序，得到[1, 2, 3]和[8, 9]，最后得到排序后的数组为[1, 2, 3, 5, 8, 9]

public class QuickSort {
    public static void main(String[] args) {
        int[] arr = {5, 3, 8, 2, 1, 9};
        quickSort(arr, 0, arr.length - 1);
        System.out.println("排序后的数组：");
        for (int num : arr) {
            System.out.print(num + " ");
        }
    }

    public static void quickSort(int[] arr, int low, int high) {
        if (low < high) {
            int pivot = partition(arr, low, high); // 获取基准元素的位置
            quickSort(arr, low, pivot - 1); // 对基准元素左边的子数组进行快速排序
            quickSort(arr, pivot + 1, high); // 对基准元素右边的子数组进行快速排序
        }
    }

    public static int partition(int[] arr, int low, int high) {
        int pivot = arr[low]; // 选择第一个元素作为基准元素
        while (low < high) {
            while (low < high && arr[high] >= pivot) {
                high--;
            }
            arr[low] = arr[high]; // 将比基准元素小的元素移到低位
            while (low < high && arr[low] <= pivot) {
                low++;
            }
            arr[high] = arr[low]; // 将比基准元素大的元素移到高位
        }
        arr[low] = pivot; // 将基准元素放到最终位置
        return low; // 返回基准元素的位置
    }
}

另外拓展一小点：java面向对象里封装了sort方法，该方法底层就是快速排序

int[] arr=new int[]{123,523,1,4,244,14231,122};
Arrays.sort(arr);//sort的底层是快排，效率最高
System.out.println(Arrays.toString(arr));

四、杨辉三角 

1.什么是杨辉三角

杨辉三角是一个由数字排列成的三角形，其中每个数字是它上方两个数字的和。它的第n行有n个数字，第一个和最后一个数字都是1，其他数字是上一行相邻两个数字的和。

举个例子，下面是一个4行的杨辉三角：
       1
      1 1
     1 2 1
    1 3 3 1 

 2.代码示例

如何生成指定行数的杨辉三角？通过使用二维数组来存储杨辉三角的每个数字，然后利用动态规划的思想，根据每个数字等于上一行两个相邻数字的和的规律来生成杨辉三角。

public class PascalTriangle {
    public static void main(String[] args) {
        int numRows = 5;
        generatePascalTriangle(numRows);
    }

    public static void generatePascalTriangle(int numRows) {
        int[][] triangle = new int[numRows][];
        for (int i = 0; i < numRows; i++) {
            triangle[i] = new int[i + 1];
            triangle[i][0] = 1; // 每行的第一个数字为1
            triangle[i][i] = 1; // 每行的最后一个数字为1
            for (int j = 1; j < i; j++) {
                triangle[i][j] = triangle[i - 1][j - 1] + triangle[i - 1][j]; // 每个数字等于上一行两个相邻数字的和
            }
        }
        // 打印杨辉三角
        for (int i = 0; i < numRows; i++) {
            for (int j = 0; j <= i; j++) {
                System.out.print(triangle[i][j] + " ");
            }
            System.out.println();
        }
    }
}

 五、二分法查找算法

1.原理：

二分法查找算法是一种高效的查找算法，它适用于已排序的数组。如何使用二分法查找算法在有序数组中查找指定的目标值？通过不断缩小查找范围，将数组分成两部分，并与目标值进行比较，从而确定目标值在数组中的位置。如果找到目标值，返回它在数组中的索引；如果找不到目标值，返回-1。

 2.具体步骤：

具体步骤如下：
1)选择数组的中间元素
2)如果中间元素等于目标值，则查找成功
3)如果中间元素大于目标值，则在数组的前半部分继续查找
4)如果中间元素小于目标值，则在数组的后半部分继续查找
5)重复以上步骤，直到找到目标值或者数组为空

3.代码示例

举个例子，假设我们要在有序数组[1, 2, 3, 5, 8, 9]中查找数字5：选择中间元素为3，由于3小于5，所以在数组的后半部分[5, 8, 9]中继续查找，选择中间元素为8，由于8大于5，所以在数组的前半部分[5]中继续查找，找到目标值5，查找成功

public class BinarySearch {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 5, 8, 9};
        int target = 5;
        int index = binarySearch(arr, target);
        if (index != -1) {
            System.out.println("目标值 " + target + " 在数组中的索引为 " + index);
        } else {
            System.out.println("目标值 " + target + " 不在数组中");
        }
    }

    public static int binarySearch(int[] arr, int target) {
        int low = 0;
        int high = arr.length - 1;
        while (low <= high) {
            int mid = (low + high) / 2;
            if (arr[mid] == target) {
                return mid; // 找到目标值，返回索引
            } else if (arr[mid] < target) {
                low = mid + 1; // 目标值在数组的后半部分
            } else {
                high = mid - 1; // 目标值在数组的前半部分
            }
        }
        return -1; // 目标值不在数组中
    }
}

---

 今天没有习题，理解为主，其中选择排序和冒泡排序是现在必须要理解的，至于后面的快速排序、杨辉三角、二分查找等，则先理解，后面还会再次讲解。