数组的高级操作 - 查找与排序

二分查找： 

• 概述

  查找指定元素在数组中的位置时,以前的方式是通过遍历,逐个获取每个元素,看是否是要查找的元素,这种方式当数组元素较多时,查找的效率很低

        二分查找也叫折半查找,每次可以去掉一半的查找范围,从而提高查找的效率

• 实现步骤

  1. 定义两个变量，表示要查找的范围。默认min = 0 ，max = 最大索引

  2. 循环查找，但是min <= max

  3. 计算中间索引mid的值，最大索引加最小索引除以2

  4. 判断mid位置的元素是否为要查找的元素，如果是直接返回对应索引

  5. 如果要查找的值在mid的左半边，那么min值不变，max = mid -1.继续下次循环查找

  6. 如果要查找的值在mid的右半边，那么max值不变，min = mid + 1.继续下次循环查找

  7. 当min > max 时，表示要查找的元素在数组中不存在，返回-1.

• 代码实现

  public class MyBinarySearchDemo01 {
      public static void main(String[] args) {
          int [] arr = {1,2,3,4,5,6,7,8,9,10};
          int number = 4;
  ​
          //二分查找方法
          int index = binarySearchForIndex(arr,number);
          System.out.println(index);
      }
  ​
      private static int binarySearchForIndex(int[] arr, int number) {
          //1,定义查找的范围，0-最大索引
          int min = 0;
          int max = arr.length - 1;
          //2.循环查找 min>max两边都找完了
          while(min <= max){
              //3.计算出中间索引 mid
              int mid = (min + max) >> 1;
              //mid指向的元素和要找的数据比较
              if(arr[mid] > number){
                  //mid比number大，number在左边，最大索引改变为中间索引mid-1.
                  max = mid -1;
              }else if(arr[mid] < number){
                  //mid比number大，number在右边，最小索引改变为中间索引mid+1.
                  min = mid + 1;
              }else{
                  //相等，返回索引
                  return mid;
              }
          }
          //如果min大于了max就表示元素不存在,返回-1.
          return -1;
      }
    
  }

• 注意事项

  有一个前提条件，数组内的元素一定要按照大小顺序排列。

冒泡排序:

• 概述

  一种排序的方式，对要数据中相邻的数据进行两两比较，将较大的数据放在后面，依次对比较，直到最大的数据放在最后；一次循环结束,就相当于确定了当前的最大值,也能确定最大值在数组中应存入的位置；如果有n个数据进行排序，总共需要比较n-1次，每一次比较完毕，下一次的比较就会少一个数据参与

• 代码实现

  public class MyBubbleSortDemo2 {
      public static void main(String[] args) {
          int[] arr = {3, 5, 2, 1, 4};
          //1 2 3 4 5
          bubbleSort(arr);
      }
  ​
      private static void bubbleSort(int[] arr) {
          //外部循环控制的是次数 比数组的长度少一次.
          for (int i = 0; i < arr.length -1; i++) {
  
              //内部循环就是实际循环比较的
              //-1 是为了让数组最大索引不要越界，
              //-i 每一轮结束之后,我们就会少比一个数字.
              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;
                  }
              }
          }
  ​
          printArr(arr);
      }
  ​    //遍历查看方法
      private static void printArr(int[] arr) {
          for (int i = 0; i < arr.length; i++) {
              System.out.print(arr[i] + " ");
          }
          System.out.println();
      }
    
  }

快速排序:

• 概述

  冒泡排序算法中,一次循环结束,就能确定当前的最大值,也能确定最大值在数组中应存入的位置

  快速排序算法中,每一次递归时以第一个数为基准数,找到数组中所有比基准数小的.再找到所有比基准数大的.小的全部放左边,大的全部放右边,确定基准数的正确位置

• 方法实现核心步骤

  1. 右边指针，从右开始找比基准小的

  2. 左边指针，从左开始找比基准大的

  3. 同时找到，才能交换两个值的位置

  4. 移动指针继续查找和交换，直到指向相同索引

  5. 基准数交换到指针处，此时左边全是小的，右边全是大的

  6. 把两边都看成一个数组，再调用查找方法

• 代码实现

  public class MyQuiteSortDemo2 {
      public static void main(String[] args) {
  
          int[] arr = {6, 1, 2, 7, 9, 3, 4, 5, 10, 8};
  ​
          quiteSort(arr,0,arr.length-1);
  ​
          for (int i = 0; i < arr.length; i++) {
              System.out.print(arr[i] + " ");
          }
      }
  ​
      private static void quiteSort(int[] arr, int left, int right) {
          // 指针反转递归结束
          if(right < left){
              return;
          }
  ​
          int left0 = left;
          int right0 = right;
  ​
          //基准数，左边第一个
          int baseNumber = arr[left0];
  ​
          while(left != right){
              //1，从右开始找比基准数小的
              while(arr[right] >= baseNumber && right > left){
                  right--;
              }
              //2，从左开始找比基准数大的
              while(arr[left] <= baseNumber && right > left){
                  left++;
              }
              //3，交换两个值的位置
              int temp = arr[left];
              arr[left] = arr[right];
              arr[right] = temp;
          }
          //基准数归位
          int temp = arr[left];
          arr[left] = arr[left0];
          arr[left0] = temp;
        
          // 递归调用自己,将左半部分排好序
          quiteSort(arr,left0,left-1);
          // 递归调用自己,将右半部分排好序
          quiteSort(arr,left +1,right0);
  ​
      }
  }

Arrays工具类：

• 概述

        调用方法操作数组，因为数组本身没有相应的类与方法

• 常用方法

  方法名	说明
  public static String toString(int[] a)	返回指定数组内容的字符串
  public static void sort(int[] a)	按照数字顺序排列指定的数组
  public static int binarySearch(int[] a, int key)	利用二分查找返回指定元素的索引