左程云算法笔记（一）简单排序、异或运算、二分法

简单排序 (LC912)

1. 冒泡排序

多次遍历数组，每次遍历时比较相邻的元素。若顺序错误就交换他们两个。
对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。大的元素会移动到数组的末尾，如同水中的气泡上浮到顶端，故名冒泡排序。
初始时，整个数组都是未排序的数组。每一次遍历数组，未排序的子数组中的最大元素将会移动到该子数组的末尾，使得未排序的子数组的长度减 1。当所有元素都移动到正确的位置时，排序结束。

如果在一次遍历数组的过程中没有发现相邻的两个元素顺序错误的情况，则说明所有的元素都在正确的位置，此时可以提前结束排序。这是冒泡排序的一个可以优化的点。

public int[] bubbleSort(int[] nums) {
    if (nums == null || nums.length <= 1) {
        return nums;
    }
    for (int i=nums.length-1; i>0; i--) { //外层循环：控制此轮遍历的范围
        // 优化：设定一个标记，若为true，则表示此次循环没有进行交换，即待排序列已经有序，排序完成
        boolean flag = true;
        for (int j=0; j<i; j++) {         //内层循环：遍历该范围，依次比较相邻位置的数
            if (nums[j] > nums[j+1]) {
                swap1(nums, j, j+1);
                flag = false;
            }
        }
        if (flag) {
            break;
        }
    }
    return nums;
}

public void swap1(int[] nums, int a, int b) {
    int temp = nums[a];
    nums[a] = nums[b];
    nums[b] = temp;
}

时间复杂度: $O(n^2)$

2. 选择排序

首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置。
再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。
重复第二步，直到所有元素均排序完毕。

多次遍历数组，每次在未排序的子数组中找到最小元素，将其与该子数组中的首个元素交换。如果未排序的子数组中的最小元素与首个元素相等，则不执行交换操作。

初始时，整个数组都是未排序的数组。每一次遍历数组，未排序的子数组中的最小元素将会移动到该子数组的起始位置，使得已排序的子数组的长度加 11，未排序的子数组的长度减 11。当所有元素都交换结束时，排序结束。

public int[] selectionSort(int[] nums) {
        for (int i=0; i<nums.length; i++) { // 外层循环：确定无序的范围
            int minIndex = i;
            boolean flag = false;
            for (int j=i+1; j<nums.length; j++) { // 内层循环：寻找当次循环中的最小值
                minIndex = nums[j] < nums[minIndex] ? j : minIndex;
            }
            swap1(nums, i, minIndex);
        }
        return nums;
}

时间复杂度: $O(n^2)$

3. 插入排序

插入排序操作类似于摸牌并将其从大到小排列。
① 从第一个元素开始，该元素可以认为已经被排序
② 取出下一个元素，在已经排序的元素序列中从后向前扫描
③ 如果该元素（已排序）大于新元素，将该元素移到下一位置
④ 重复步骤③，直到找到已排序的元素小于或者等于新元素的位置
⑤ 将新元素插入到该位置后
⑥ 重复步骤②~⑤

public int[] insertionSort(int[] nums) {
     for (int i=0; i<nums.length-1; i++) { // 外层循环：确定有序数组的范围
         for (int j=i; j>=0 && nums[j]>nums[j+1]; j--) { // 内层循环：在有序数组中从后往前逐个比较，找到需要插入元素的位置（换到不能再换）。nums[j+1]即为需要插进去的那个数
             swap1(nums, j, j+1);
         }              
     }
     return nums;
}

时间复杂度: $O(n^2)$

异或运算

异或运算相当于不带进位的二进制加法。

性质：

1. 0^x = 0
2. x^x = 0
3. 异或满足交换律与结合律。

1. 不开辟新空间实现两数交换

原理：
A = a ^ b
B = A ^ b = a ^ b ^ b = a
A = A ^ B = a ^ b ^ a = b

public void swap2(int[] nums, int a, int b) { // 需保证a和b不相等
    nums[a] = nums[a]^nums[b];
    nums[b] = nums[a]^nums[b];
    nums[a] = nums[a]^nums[b];
}

2. 一堆数中只有一个数出现了奇数次，其余均出现了偶数次，如何找出该数？(LC136)

思路：将所有的数进行异或操作,出现偶数次的数经过异或操作后必定为0,最终的异或结果为出现奇数次的数

public int singleNumber(int[] nums) {
    int xor = 0;
    for (int i=0; i<nums.length; i++) {
        xor ^= nums[i];
    }
    return xor;
}

3. 一堆数中只有两个数出现了奇数次，其余均出现了偶数次，求这两个数。(LC260)

思路：将所有数进行异或操作,最终结果为两个目标数的异或结果 (x^y)。由于两个数必定不相同,则这个异或结果必定不为0，即二进制中必定至少有一位为1 (x和y一个在这位是0，一个是1)。接下来，根据这一位的值，可以将所有数分为两类：该位为1或该位为0。分类后即同上一题同解法。

public int[] singleNumber(int[] nums) {
    int xor = 0;
    for (int i=0; i<nums.length; i++) {
        xor ^= nums[i];
    }
    int bit_1 = xor & (~xor + 1); // 提取二进制最右边一位1的方法
    int a = 0;
    for (int i=0; i<nums.length; i++) {
        if ((nums[i] & bit_1) == 0) {  // 两种情况：该数二进制的bit_1那位是0或1
                                     	// 写法二：  if (nums[i] ^ bit_1 == bit_1)
            a ^= nums[i]; // 则a是bit_1位上为0的那个目标数
        }
    }
    int b = xor ^ a;
    return new int[]{a, b};
}

二分法

0. 求数组中值的写法

初始写法：int mid = (left + right)/2
该写法的问题是对于很长的数组，left+right会产生超出范围的问题

改进1： int mid = left + (right - left)/2
改进2： int mid = left + ((right - left)>>1)
$>>1$即二进制下右移一位，等价于/2，但是计算效率比除法高

1. 有序数组中是否存在一个数，需要O(logN) (LC704)

public int search(int[] nums, int target) {
        int left = 0;
        int right = nums.length - 1;
        int mid = left + ((right - left)>>1)
        while (left <= right) { // 若使用<则对于只有一个数的情况会return -1
            if (nums[mid] < target) {
                left = mid + 1; // 因为当前mid不是target，即可以排除考虑。否则也会出现left or right = mid 的情况无限循环
                mid =  (int) (left+right)/2;
            } else if (nums[mid] > target) {
                right = mid - 1;
                mid =  (int) (left+right)/2;
            } else {
                return mid;
            }
        }
        return -1;
}

时间复杂度分析：每次砍一半直到砍到没有，砍的次数就是计算的次数，即logN。

2. 有序数组中找$\ge$某个数最左侧的位置

public int nearestIndex(int[] nums, int target) {
	int left = 0;
	int right = nums.length - 1;
	int mid;
	int index = -1;
	while (left <= right) {
		mid =left + ((right - left)>>1);
		if (nums[mid] >= target) { // 若mid>=target，则继续在mid左侧范围搜索，并更新index为mid
			index = mid;
			right = mid - 1;
		} else { // 若mid<target，则在mid右侧范围搜索
			left = mid + 1;
		}
	}
	return index;
}

3. 无序列表中寻找局部最小值/最大值，相邻数都不相等 (LC162/852/1095)

假设nums[-1] = num[n] = -∞

思路（for局部峰值）：

1. 如果第一个数或最后一个数是局部峰值，则直接return。否则：说明第二个数一定比第一个数大（升），倒数第二个数一定比最后一个数大（降），则中间一定存在至少一个局部峰值作趋势的转折。
2. 取中间位置，若mid为局部峰值则return，否则mid左右一定有一个数比mid大。若左边比mid大，则 [0, mid-1] 一定存在局部峰值；若右边比mid大，则 [mid+1, right] 一定存在一个局部峰值

public int findPeakElement(int[] nums) {
        if (nums == null || nums.length == 0) {
            return -1;
        }
        if (nums.length == 1 || nums[0] > nums[1]) {
            return 0;
        }
        if (nums[nums.length-1] > nums[nums.length-2]) {
            return nums.length-1;
        }
        int left = 1;
        int right = nums.length- 2;
        int mid;
        while (left <= right) {
            mid = left + ((right - left)>>1);
            if (nums[mid] < nums[mid-1]) { //mid比mid-1小，则说明要往mid左边找
                right = mid-1;
            } else if (nums[mid] < nums[mid+1]) { //mid比mid+1小，则说明要往mid右边找
                left = mid+1;
            } else { // 既不比左边小，也不比右边小，则说明mid为peak
                return mid;
            }
        }
        return -1;
}

Reference:
左程云算法课堂笔记(初级1)
左程云github
leetcode912讲解
leetcode704评论-代强