数组中的问题其实最常见。
排序:选择排序;插入排序;归并排序;快速排序
查找:二分查找法
数据结构:栈;队列;堆
1、二分查找法
template<typename T>
int binarySearch( T arr[], int n, T target )
{
int l = 0, r = n-1; // 在[l...r]的范围里寻找target:前闭后闭
while( l <= r )
{
// 只要还有可以查找的内容。当 l == r时,区间[l...r]依然是有效的
int mid = l + (r-l)/2;
if( arr[mid] == target )
return mid; //mid已经判断过了
if( target > arr[mid] )
l = mid + 1; // target在[mid+1...r]中; [l...mid]一定没有target
else // target < arr[mid]
r = mid - 1; // target在[l...mid-1]中; [mid...r]一定没有target
}
return -1;
}
改变变量的定义,依然可以写出正确的算法
template<typename T>
int binarySearch( T arr[], int n, T target )
{
int l = 0, r = n; // target在[l...r)的范围里,这样设置才能保证长度为n
while( l < r )
{
// 当 l == r时,区间[l...r)是一个无效区间 [42,43)
int mid = l + (r-l)/2;
if( arr[mid] == target )
return mid;
if( target > arr[mid] )
l = mid + 1; // target在[mid+1...r)中; [l...mid]一定没有target
else// target < arr[mid]
r = mid; // target在[l...mid)中; [mid...r)一定没有target
}
return -1;
}
80. 删除排序数组中的重复项 II
给定一个排序数组,你需要在原地删除重复出现的元素,使得每个元素最多出现两次,返回移除后数组的新长度。
不要使用额外的数组空间,你必须在原地修改输入数组并在使用 O(1) 额外空间的条件下完成。
示例 1:
给定 nums = [1,1,1,2,2,3],
函数应返回新长度 length = 5, 并且原数组的前五个元素被修改为 1, 1, 2, 2, 3 。
你不需要考虑数组中超出新长度后面的元素。
示例 2:
给定 nums = [0,0,1,1,1,1,2,3,3],
函数应返回新长度 length = 7, 并且原数组的前五个元素被修改为 0, 0, 1, 1, 2, 3, 3 。
你不需要考虑数组中超出新长度后面的元素。
class Solution {
public:
int removeDuplicates(vector<int>& nums) {
int n = nums.size();
if(n <= 2)
return n;
int i = 1, k = 1;
while(i < n)
{
if(nums[i] != nums[i-1])
{
nums[k++] = nums[i];
i++;
}
else
{
nums[k++] = nums[i];
while(i < n && nums[i] == nums[i-1])
i++;
}
}
return k;
}
};
75. 颜色分类
给定一个包含红色、白色和蓝色,一共 n 个元素的数组,原地对它们进行排序,使得相同颜色的元素相邻,并按照红色、白色、蓝色顺序排列。
此题中,我们使用整数 0、 1 和 2 分别表示红色、白色和蓝色。
注意:
不能使用代码库中的排序函数来解决这道题。
示例:
输入: [2,0,2,1,1,0]
输出: [0,0,1,1,2,2]
进阶:
一个直观的解决方案是使用计数排序的两趟扫描算法。
首先,迭代计算出0、1 和 2 元素的个数,然后按照0、1、2的排序,重写当前数组。
你能想出一个仅使用常数空间的一趟扫描算法吗?
(1)计数排序,时间复杂度O(n)
class Solution {
public:
void sortColors(vector<int>& nums) {
int n = nums.size();
if(n <= 1)
return;
vector<int> count(3, 0);
for(int i = 0; i < n; i++)
count[nums[i]]++;
int k = 0;
for(int i = 0; i < 3; i++)
{
while(count[i] > 0)
{
nums[k++] = i;
count[i]--;
}
}
}
};
(3)三路快排,空间复杂度O(1)
设置三个索引
class Solution {
public:
void sortColors(vector<int>& nums) {
int n = nums.size();
if(n <= 1)
return;
int start = -1, end = n;
int i = 0;
while(i < end)
{
if(nums[i] == 1)
i++;
else if(nums[i] == 0)
{
swap(nums[++start], nums[i++]);
}
else
swap(nums[--end], nums[i]);
}
}
};
215. 数组中的第K个最大元素
在未排序的数组中找到第 k 个最大的元素。请注意,你需要找的是数组排序后的第 k 个最大的元素,而不是第 k 个不同的元素。
示例 1:
输入: [3,2,1,5,6,4] 和 k = 2
输出: 5
示例 2:
输入: [3,2,3,1,2,4,5,5,6] 和 k = 4
输出: 4
说明:
你可以假设 k 总是有效的,且 1 ≤ k ≤ 数组的长度。
(1)第一种方法,使用堆排序方法
建立一个大小为k的最小堆,时间复杂度klogk。然后将剩余的n-k个数和堆顶比较,如果大于堆顶则放入堆中,并调整最小堆。时间复杂度O((n-k)logk),总的时间复杂度O(nlogk)。
class Solution {
public:
void adjust(vector<int> &MinHeap, int p, int N)
{
int parent, child;
int temp = MinHeap[p];
for(parent = p; (2*parent+1) < N; parent = child)
{
child = 2*parent+1;
if(child+1 < N && MinHeap[child] > MinHeap[child+1])
child++;
if(temp < MinHeap[child])
break;
else
MinHeap[parent] = MinHeap[child];
}
MinHeap[parent] = temp;
}
int findKthLargest(vector<int>& nums, int k) {
int n = nums.size();
if(n == 0 && n < k)
return -1;
vector<int> MinHeap(k);
for(int i = 0; i < k; i++)
MinHeap[i] = nums[i];
for(int i = k/2-1; i >=0 ;i--)
adjust(MinHeap, i, k);
for(int i = k;i < n; i++)
{
if(nums[i] > MinHeap[0])
{
MinHeap[0] = nums[i];
adjust(MinHeap, 0, k);
}
}
return MinHeap[0];
}
};
(2)快排,但不需要全部排序,只要partition就可以了
class Solution {
public:
int partition(vector<int> &nums, int start, int end, int k)
{
int pivot = nums[start];
int i = start, j =end;
while(i < j)
{
while(i < j && nums[j] >= pivot)
j--;
nums[i] = nums[j];
while(i < j && nums[i] < pivot)
i++;
nums[j] = nums[i];
}
nums[i] = pivot;
if(i == k)
return nums[i];
else if(i < k)
return partition(nums, i+1, end, k);
else
return partition(nums, start, i-1, k);
}
int findKthLargest(vector<int>& nums, int k) {
int n = nums.size();
if(n == 0 && n < k)
return -1;
return partition(nums, 0, n-1, n-k);
}
};
11. 盛最多水的容器
给定 n 个非负整数 a1,a2,...,an,每个数代表坐标中的一个点 (i, ai) 。在坐标内画 n 条垂直线,垂直线 i 的两个端点分别为 (i, ai) 和 (i, 0)。找出其中的两条线,使得它们与 x 轴共同构成的容器可以容纳最多的水。
说明:你不能倾斜容器,且 n 的值至少为 2。
图中垂直线代表输入数组 [1,8,6,2,5,4,8,3,7]。在此情况下,容器能够容纳水(表示为蓝色部分)的最大值为 49。
示例:
输入: [1,8,6,2,5,4,8,3,7]
输出: 49
使用双指针
class Solution {
public:
int maxArea(vector<int>& height) {
int n = height.size();
if(n < 2)
return 0;
int left = 0, right = n-1;
int res = 0;
while(left < right)
{
int temp =(right - left)*(height[left] < height[right] ? height[left]:height[right]);
if(temp > res)
res = temp;
if(height[left] > height[right])
right--;
else
left++;
}
return res;
}
};
3. 无重复字符的最长子串
给定一个字符串,请你找出其中不含有重复字符的 最长子串 的长度。
示例 1:
输入: "abcabcbb"
输出: 3
解释: 因为无重复字符的最长子串是 "abc",所以其长度为 3。
示例 2:
输入: "bbbbb"
输出: 1
解释: 因为无重复字符的最长子串是 "b",所以其长度为 1。
示例 3:
输入: "pwwkew"
输出: 3
解释: 因为无重复字符的最长子串是 "wke",所以其长度为 3。
请注意,你的答案必须是 子串 的长度,"pwke" 是一个子序列,不是子串。
class Solution {
public:
int lengthOfLongestSubstring(string s) {
int n = s.length();
if(n < 2)
return n;
int num[256] = {0};
int left = -1, right = -1, res = 0;
while(right < (n-1))
{
if(num[s[right+1]] == 0)
{
++right;
num[s[right]]++;
}
else
{
res = max(res, right-left);
++left;
num[s[left]]--;
}
}
res = max(res, right-left);
return res;
}
};
438. 找到字符串中所有字母异位词
给定一个字符串 s 和一个非空字符串 p,找到 s 中所有是 p 的字母异位词的子串,返回这些子串的起始索引。
字符串只包含小写英文字母,并且字符串 s 和 p 的长度都不超过 20100。
说明:
字母异位词指字母相同,但排列不同的字符串。
不考虑答案输出的顺序。
示例 1:
输入:
s: "cbaebabacd" p: "abc"
输出:
[0, 6]
解释:
起始索引等于 0 的子串是 "cba", 它是 "abc" 的字母异位词。
起始索引等于 6 的子串是 "bac", 它是 "abc" 的字母异位词。
示例 2:
输入:
s: "abab" p: "ab"
输出:
[0, 1, 2]
解释:
起始索引等于 0 的子串是 "ab", 它是 "ab" 的字母异位词。
起始索引等于 1 的子串是 "ba", 它是 "ab" 的字母异位词。
起始索引等于 2 的子串是 "ab", 它是 "ab" 的字母异位词。
(1)第一种方法
维护一个长度为字符串p的窗口, 每次向右移动一个单位。同时每次都要比较两者的内容是否相等,时间复杂度O(26n)
class Solution {
public:
vector<int> findAnagrams(string s, string p) {
int m = s.length();
int n = p.length();
vector<int>index;
if(n > m)
return index;
vector<int>nump(26, 0);
vector<int>nums(26, 0);
for(int i = 0; i < n; i++)
{
nump[p[i]-'a']++;
nums[s[i]-'a']++;
}
int left = 0, right = n;
while(right < m)
{
if(nump == nums)
index.push_back(left);
nums[s[left]-'a']--;
nums[s[right]-'a']++;
left++;
right++;
}
if(nump == nums)
index.push_back(left);
return index;
}
};
(2)第二种方法
双指针滑动窗口,加上一个计数器len,时间复杂度O(n)
class Solution {
public:
vector<int> findAnagrams(string s, string p) {
int m = s.length();
int n = p.length();
vector<int>index;
if(n > m)
return index;
vector<int>count(26, 0);
for(int i = 0; i < n; i++)
count[p[i]-'a']++;
int left = 0, right = 0;
int len = 0;
while(right < m)
{
count[s[right]-'a']--;
if(count[s[right]-'a'] >= 0)
len++;
right++;
while(len == n)
{
if(right - left == n)
index.push_back(left);
count[s[left]-'a']++;
if(count[s[left]-'a'] > 0)
len--;
left++;
}
}
return index;
}
};
76. 最小覆盖子串
给你一个字符串 S、一个字符串 T,请在字符串 S 里面找出:包含 T 所有字母的最小子串。
示例:
输入: S = "ADOBECODEBANC", T = "ABC"
输出: "BANC"
说明:
如果 S 中不存这样的子串,则返回空字符串 ""。
如果 S 中存在这样的子串,我们保证它是唯一的答案。
此题和上面一题类似,双指针维护一个窗口,只是窗口大小不固定,用一个计数器len来确定窗口是否含有指定的字符串。
class Solution {
public:
string minWindow(string s, string t) {
int m = s.length();
int n = t.length();
string res = "";
if(n > m)
return res;
int count[256] = { 0 };
for(int i =0; i < n; i++)
count[t[i]]++;
int left = 0, right = 0, len = 0, minlength = INT_MAX;
while(right < m)
{
count[s[right]]--;
if(count[s[right]] >= 0)
len++;
right++;
while(len == n)
{
if(minlength > (right - left))
{
minlength = right - left;
res = s.substr(left, right - left);
}
count[s[left]]++;
if(count[s[left]] > 0)
len--;
left++;
}
}
return res;
}
};