算法

一、数组的操作

1、 冒泡排序

相邻元素两两比较，大的往后放，第一次完毕，最大值出现在了最大索引处

public static void main(String[] args) {
    // 定义一个数组
    int[] arr = { 24, 69, 80, 57, 13 };
    System.out.println("排序前：");
    printArray(arr);        
    //由于我可能有多个数组要排序，所以我要写成方法
    bubbleSort(arr);
    System.out.println("排序后：");
    printArray(arr);
}

//冒泡排序代码
public static void bubbleSort(int[] arr){
    for (int x = 0; x < arr.length - 1; x++) {
        for (int y = 0; y < arr.length - 1 - x; y++) {
            if (arr[y] > arr[y + 1]) {
                int temp = arr[y];
                arr[y] = arr[y + 1];
                arr[y + 1] = temp;
            }
        }
    }
}

// 遍历功能
public static void printArray(int[] arr) {
    System.out.print("[");
    for (int x = 0; x < arr.length; x++) {
        if (x == arr.length - 1) {
            System.out.print(arr[x]);
        } else {
            System.out.print(arr[x] + ", ");
        }
    }
    System.out.println("]");
}                                  

运行效果：

结果.png

原理图：

冒泡排序.png

2. 选择排序

从0索引开始，依次和后面元素比较，小的往前放，第一次完毕，最小值出现在了最小索引处

public static void main(String[] args) {
    // 定义一个数组
    int[] arr = { 24, 69, 80, 57, 13 };
    System.out.println("排序前：");
    printArray(arr);
    
    selectSort(arr);
    System.out.println("排序后：");
    printArray(arr);
}   
public static void selectSort(int[] arr){
    for(int x=0; x<arr.length-1; x++){
        for(int y=x+1; y<arr.length; y++){
            if(arr[y] <arr[x]){
                int temp = arr[x];
                arr[x] = arr[y];
                 arr[y] = temp;
            }
        }
    }
}
// 遍历功能
public static void printArray(int[] arr) {
    System.out.print("[");
    for (int x = 0; x < arr.length; x++) {
        if (x == arr.length - 1) {
            System.out.print(arr[x]);
        } else {
            System.out.print(arr[x] + ", ");
        }
    }
    System.out.println("]");
}                                       

运行效果：

结果.png

原理图：

选择排序.png

3. 了解二分查找

1. 查找：
   首先，假设表中元素是按升序排列，将表中间位置记录的关键字与查找关键字比较，如果两者相等，则查找成功；否则利用中间位置录记录将表分成前、后两个子表，如果中间位置记录的关键字大于查找关键字，则进一步查找前一子表，否则进一步查找后一子表。重复以上过程，直到找到满足条件的记录，使查找成功，或直到子表不存在为止，此时查找不成功。

2. 分析：

   A:定义最大索引，最小索引
   B:计算出中间索引
   C:拿中间索引的值和要查找的值进行比较
    相等：就返回当前的中间索引
    不相等：
        大   左边找
        小   右边找
   D:重新计算出中间索引
        大   左边找
            max = mid - 1;
        小   右边找
            min = mid + 1;
   E:回到B
   

3. 代码：

   public static void main(String[] args) {
       //定义一个数组
       int[] arr = {11, 22, 33, 44, 55, 66, 77};
       //写功能实现
       int index = getIndex(arr, 33);
       System.out.println("index:" + index);
       //假如这个元素不存在后有什么现象呢?
       index = getIndex(arr, 333);
       System.out.println("index:" + index);
   }
   
   /*
   * 两个明确：
   * 返回值类型：int
   * 参数列表：int[] arr,int value
   */
   public static int getIndex(int[] arr, int value) {
       //定义最大索引，最小索引
       int max = arr.length - 1;
       int min = 0;
       //计算出中间索引
       int mid = (max + min) / 2;
       //拿中间索引的值和要查找的值进行比较
       while (arr[mid] != value) {
           if (arr[mid] > value) {
               max = mid - 1;
           } else if (arr[mid] < value) {
               min = mid + 1;
           }
           //加入判断
           if (min > max) {
                   return -1;
               }
               mid = (max + min) / 2;
           }
           return mid;
    }
   

4. 运行效果：

运行结果.png

5. 原理图：

二分查找.png