数组相关算法整理（一）

先从基础 ：二分查找开始吧 。

1 二分查找

别看一个 二分查找： 他也有很多要注意的点 。区间开闭？相应边界怎么控制？

二分查找思想1946 年提出 ， 知道1962年才出现一个真正没有bug的二分查找法。

//二分查找 前提： 原数组有序

template <typename T>
int binarySearch(T arr[], int n, T target){		
	int l =0; int r = n-1;//闭区间
	while(l <= r)//闭区间,相等时元素仍有效
	{
		int mid = l + ((r - l)>>1);//请注意这里防止溢出：这里全世界画了16年时间才发现整形溢出错误
		if(arr[mid] == target)
			return mid;
		if (arr[mid] > target)
			r = mid-1;//始终保持闭区间
		else
			l = mid + 1;//始终保持闭区间
	}
	return -1;//没找到
}

再看看 左闭右开的样子：【）

template <typename T>
int binarySearch(T arr[], int n, T target){		
	int l =0; int r = n;//开区间
	while(l < r)//前闭后开区间,相等时元素无效 【42，42） 此时无效
	{
		int mid = l + ((r - l)>>1);//请注意这里防止溢出：这里全世界画了16年时间才发现整形溢出错误
		if(arr[mid] == target)
			return mid;
		if (arr[mid] > target)
			r = mid;//左闭右开【）右边取不到 mid此时本来就取不到
		else
			l = mid + 1;//左区间有效，【) 
	}
	return -1;//没找到
}

所以最好写闭区间【】吧，这样子容易理解， 也不容易出错。
千万别被代码哦， 理解这分析。

力扣 283 ： 移动 0

给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。

下边来见识下 ：无休止的优化。

class Solution {
public:
    /*
    void moveZeroes(vector<int>& nums) {
     int a = nums.size();
        if(a==0) return ;

     vector<int> v(a);
     int j = 0;
     for(int i=0; i < a; ++i)
     {
         if(nums[i] != 0)
         {
             v[j] = nums[i];
             ++j;
         }
     }
     nums = v;
    }
    */

    /*

    //算法的初衷 ：  能不能做的更好： 时空复杂的
    void moveZeroes(vector<int>& nums) {
        int k=0;
        for (int i =0; i<nums.size(); ++i)
            if(nums[i] != 0)  nums[k++] = nums[i]; 
                
        for(int i=k; i<nums.size(); ++i)
            nums[i] = 0;
    }
    */


/*
void moveZeroes(vector<int>& nums) {
     int k = 0;
     for(int i=0; i<nums.size(); ++i)
        if(nums[i] != 0)
                swap(nums[i],nums[k++]);       
}
*/


 void moveZeroes(vector<int>& nums) {
     int k = 0;
     for(int i=0; i<nums.size(); ++i)
        if(nums[i] != 0)
            if (i != k)
                swap(nums[i],nums[k++]);       
            else    
                ++k;//相等 k++
 }
};

三路快排

题目描述

给定一个包含红色、白色和蓝色，一共 n 个元素的数组，原地对它们进行排序，使得相同颜色的元素相邻，并按照红色、白色、蓝色顺序排列。

此题中，我们使用整数 0、 1 和 2 分别表示红色、白色和蓝色。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/sort-colors

//下边用三路快排实现一下

class Solution {
public:
//1  快排 O(nlogN)  O(1)
//2  计数排序 o(N) ,O(1) //换种情况O(N)
//3  3路快排  O(N)  O(1)


    void sortColors(vector<int>& nums) {
     //sort(nums.begin(), nums.end()); 
    
    int zero = -1; //【】刚开始不存在元素
    int two = nums.size();//【】刚开始不存在元素

    for(int i=0; i<two; )
    {
        if(nums[i] == 1)  ++i;
        else if(nums[i] == 2)
            swap(nums[i], nums[--two]);
        else 
            swap(nums[++zero], nums[i++]);
    }    
    }
};

类似思路 ：力扣 215 题

在未排序的数组中找到第 k 个最大的元素。请注意，你需要找的是数组排序后的第 k 个最大的元素，而不是第 k 个不同的元素。

https://leetcode-cn.com/problems/kth-largest-element-in-an-array/

力扣 167 数组中找两个数 和为target:

https://leetcode-cn.com/problems/two-sum-ii-input-array-is-sorted/

一 ： 暴力法
二 ： 二分查找O(logN)
三 ： 左右指针（夹逼法） O（N）

这里用 夹逼法来解决吧（对撞指针）

class Solution {
public:
    vector<int> twoSum(vector<int>& numbers, int target) {
        vector<int> res{-1,-2};
        int l =0, r = numbers.size()-1;
        if(r  < 1) return res;

        while(l < r)
        {
            if(numbers[l] + numbers[r] == target)
            {
                res[0] = l+1;//返回时下标从1 开始
                res[1] = r+1;//返回时下标从1 开始
                return res;
            } 
            else if(numbers[l] + numbers[r] < target)
                ++l;
            else 
                --r;
        }
        assert(false);//题目没说不存在怎么处理，我们可以抛出异常
        //return res; 
    }
};

下边来几道夹逼法的练习体会

力扣 ：125 题： 判断回文串

https://leetcode-cn.com/problems/valid-palindrome/

力扣11- 盛最多水的容器

https://leetcode-cn.com/problems/container-with-most-water/

给你 n 个非负整数 a1，a2，…，an，每个数代表坐标中的一个点 (i, ai) 。在坐标内画 n 条垂直线，垂直线 i 的两个端点分别为 (i, ai) 和 (i, 0)。找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。

解题思路仍然是夹逼法：

乍一看是暴力法： 暴力法肯定是不会让过的

换种思路： 影响容量的永远是短板

那么 夹逼法的思路 就比较清晰了 ：

class Solution {
private:
    int Area(int l, int r,vector<int>& height)
    {
        return (r -l) * min(height[l], height[r]);
    }

public:
    int maxArea(vector<int>& height) {

     int n = height.size();
     if (n < 2) return 0;

     int l =0, r =n-1;//【】
    
     int res = Area(l, r, height);

     while(l < r) //容积肯定不能重叠
    {
        if(height[l] <= height[r]) //=有无都对：只受短板影响，无论那边开始走，出现长板效果都是减小的。
             ++l;
        else  
            --r; 
        res = max(res, Area(l, r,height));
    }
    return res;
    }
};