代码01_01

选择排序

从i+1到n上找到最小值，放在i位置；

i从0到n-1，就可以安置好每一个顺序；

package class01;
import java.util.Arrays;
 
public class Code01_SelectionSort {
    public static void selectionSort(int[] arr) {
        if (arr == null || arr.length < 2) {
            return;
        }
        for (int i = 0; i < arr.length - 1; i++) { // i ~ N-1
            int minIndex = i;
            for (int j = i + 1; j < arr.length; j++) { // i ~ N-1 上找最小值的下标 
                minIndex = arr[j] < arr[minIndex] ? j : minIndex;
            }
            swap(arr, i, minIndex);
        }
    }
    public static void swap(int[] arr, int i, int j) {
        int tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
    }
}

---

冒泡排序

冒泡排序：0到i-1位置上，交换所有前者大于后者的数

i从n-1到1

package class01;
import java.util.Arrays;
 
public class Code02_BubbleSort {
 
    public static void bubbleSort(int[] arr) {
        if (arr == null || arr.length < 2) {
            return;
        }
        for (int i = arr.length - 1; i > 0; i--) { // 0 ~ e
            for (int j = 0; j < e; j++) {
                if (arr[j] > arr[j + 1]) {
                    swap(arr, j, j + 1);
                }
            }
        }
    }
 
    // 交换arr的i和j位置上的值
    public static void swap(int[] arr, int i, int j) {
        arr[i] = arr[i] ^ arr[j];
        arr[j] = arr[i] ^ arr[j];
        arr[i] = arr[i] ^ arr[j];
    }
}

---

插入排序

插入排序：保证0-i上是有序的

插入排序时间复杂度与数据状况有关

仍然按最差的情况（O(N^2)）

package class01;
import java.util.Arrays;
 
public class Code03_InsertionSort {
    public static void insertionSort(int[] arr) {
        if (arr == null || arr.length < 2) {
            return;
        }
        // 0~0 有序的
        // 0~i 想有序
        for (int i = 1; i < arr.length; i++) { // 0 ~ i 做到有序
            for (int j = i - 1; j >= 0 && arr[j] > arr[j + 1]; j--) {
                swap(arr, j, j + 1);
            }
        }
    }
 
    // i和j是一个位置的话，会出错
    public static void swap(int[] arr, int i, int j) {
        arr[i] = arr[i] ^ arr[j];
        arr[j] = arr[i] ^ arr[j];
        arr[i] = arr[i] ^ arr[j];
    }
}

---

二分查找

package class01;
 
public class Code04_BSExist {
 
    public static boolean exist(int[] sortedArr, int num) {
        if (sortedArr == null || sortedArr.length == 0) {
            return false;
        }
        int L = 0;
        int R = sortedArr.length - 1;
        int mid = 0;
        // L..R
        while (L < R) {
            mid = L + ((R - L) >> 1); // mid = (L + R) / 2
            if (sortedArr[mid] == num) {
                return true;
            } else if (sortedArr[mid] > num) {
                R = mid - 1;
            } else {
                L = mid + 1;
            }
        }
        return sortedArr[L] == num;
    }
 
}

---

异或运算

异或运算 = 无进位相加

a = a^b;
b = a^b;
a = a^b;

package class01;
 
public class Code07_EvenTimesOddTimes {
 
    public static void printOddTimesNum1(int[] arr) {
        int eor = 0;
        for (int cur : arr) {
            eor ^= cur;
        }
        System.out.println(eor);
    }
     
    public static void printOddTimesNum2(int[] arr) {
        int eor = 0;
        for (int i = 0 ; i < arr.length;i++) {
            eor ^= arr[i];
        }
        // eor = a ^ b
        // eor != 0
        // eor必然有一个位置上是1
        int rightOne = eor & (~eor + 1); // 提取出最右的1
        int onlyOne = 0; // eor'
        for (int cur : arr) {
            if ((cur & rightOne) == 1) {
                onlyOne ^= cur;
            }
        }
        System.out.println(onlyOne + " " + (eor ^ onlyOne));
    }
}

---

对数器

生成数组

---

递归函数时间复杂度

package class01;
 
public class Code08_GetMax {
 
    public static int getMax(int[] arr) {
        return process(arr, 0, arr.length - 1);
    }
 
    // arr[L..R]范围上求最大值         N
    public static int process(int[] arr, int L, int R) {
        if (L == R) { // arr[L..R]范围上只有一个数，直接返回，base case
            return arr[L];
        }
        int mid = L + ((R - L) >> 1); // 中点
        int leftMax = process(arr, L, mid);
        int rightMax = process(arr, mid + 1, R);
        return Math.max(leftMax, rightMax);
    }
 
}

master公式：子问题等规模

T(N) = a*T(N/b) + O(N^d)

上述代码可以记为：

T(N) = 2*T(N/2) + O(1)

1. logb(a) < d =>O(N^d)
2. logb(a) > d =>O(N^(logb(a)))
3. logb(a) = d =>O(N^d * logN)