排序

查找

1. 二分查找

前提：数组必须是有序的
思想：每次比较目标值与中间值大小

[算法]

• 初始化指针：
  1、left = 0;
  2、right = n-1;
  3、pivot = left + (right - left)/2 ;
• 当 left <= right
  比较中间元素 arr[pivot] 与目标值 target
  1、target == arr[pivot] 返回 pivot
  2、target > arr[pivot] : left = pivot + 1;
  3、target < arr[pivot] : right = pivot -1;

[时间复杂度]

• 时间复杂度：\mathcal{O}(\log N)O(logN)。
• 空间复杂度：\mathcal{O}(1)O(1)。

public static int getIndexByEle(int[] arr,int target){
    // 定义最小、最大、中间索引
    int left = 0;
    int right = arr.length - 1;
    int pivot = left + (right - left)/2;
    while(left <= right){
        if (target == arr[pivot]){
             return pivot;
        } else if (target > arr[pivot]){
             left = pivot + 1;
        } else {
             right = pivot - 1;
        }
        pivot = left + (right - left)/2;
    }
    return -1;
}

排序

- 冒泡排序 - 稳定

【算法】：
比较相邻两个元素的大小，第一个比第二个大，交换位置，
比较n-1趟，每趟比较 n-趟数
for(int i=0;i<arr.length-;i++);for(int j=0;j<arr.length-i;j++)

public int[] sort(int[] arr){
    for(int i=0;i<arr.length-1;i++){
        boolean flag = true;
        for(int j=0;j<arr.length-i;j++){
            if(arr[j]>arr[j+1]){
                int temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
                flag = false;
            }
        }
        if(flag){
            break;
        }
    }
    return arr;
}

- 选择排序 - 不稳定

【算法】

选择最小元素的下标，插入到最前边

public int[] sort(int[] arr){
    for(int i=0;i<arr.length-1;i++){
        int min = i;
        for(int j=i+1;i<arr.length;j++){
            if(arr[j]<arr[min]){
                min = j;
            }
        }
        if(i!=min){
            int temp = arr[i];
            arr[i] = arr[min];
            arr[min] = temp;
        }
    }
    return arr;
}

- 插入排序

【算法】

将第一个元素作为有序序列，剩余元素作为无序序列
扫描无序序列，将每一个扫描到的元素插入到有序序列中

public int[] sort(int[] arr){
    for(int i=1;i<arr.length;i++){
        int temp = arr[i];
        int j=i;
        while(j>0 && temp < arr[j-1]){
            arr[j] = arr[j-1];
            j--;
        }
        if(i!=j){
            arr[j] = temp;
        }
        return arr;
    }
}

- 快速排序

找一个基准数，小的放左边，大的放右边，递归地跟基准数比较

   public void kuisu(){
        int[] arr = {16,1,0,9,8};
        int pivot = arr[0];
        arr = quickSort(arr,0,arr.length-1);
        for (int i = 0;i<arr.length;i++){
            System.out.println(arr[i]);
        }
    }
    private int[] quickSort(int[] arr, int left, int right) {
        if (left < right) {
            int partitionIndex = partition(arr, left, right);
            quickSort(arr, left, partitionIndex - 1);
            quickSort(arr, partitionIndex + 1, right);
        }
        return arr;
    }

    private int partition(int[] arr, int left, int right) {
        // 设定基准值（pivot）
        int pivot = left;
        int index = pivot + 1;
        for (int i = index; i <= right; i++) {
            if (arr[i] < arr[pivot]) {
                swap(arr, i, index);
                index++;
            }
        }
        swap(arr, pivot, index - 1);
        return index - 1;
    }

    private void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }