# 【排序算法】【二叉树】【滑动窗口】LeetCode220: 存在重复元素 III

## 题目

i != j,

abs(i - j) <= indexDiff

abs(nums[i] - nums[j]) <= valueDiff

i != j --> 0 != 3

abs(i - j) <= indexDiff --> abs(0 - 3) <= 3

abs(nums[i] - nums[j]) <= valueDiff --> abs(1 - 1) <= 0

2 <= nums.length <= 105

-109 <= nums[i] <= 109

1 <= indexDiff <= nums.length

0 <= valueDiff <= 109

## 多键二叉树+滑动窗口

(i,j)和(j,i)完全相同，所以只需要判断一个，不是一般性，假定i

[it,ij)是值大于等于nums[j]-valueDiff且小于等于nums[j]+valueDiff。

**注意：

setRang不能直接删除值，那样重复值会一起删除。

multiset是多键二叉树，由于可能有重复元素，所以不能用单键二叉树。

## 代码

### 核心代码

class Solution {
public:
bool containsNearbyAlmostDuplicate(vector<int>& nums, int indexDiff, int valueDiff) {
std::multiset<int> setRang;
for (int right = 0; right < nums.size(); right++)
{
const int iDelIndex = right - indexDiff - 1;
if (iDelIndex >= 0)
{
setRang.erase(setRang.find(nums[iDelIndex]));
}
auto it = setRang.lower_bound(nums[right] - valueDiff);
auto ij = setRang.upper_bound(nums[right] + valueDiff);
if (it != ij)
{
return true;
}
setRang.emplace(nums[right]);
}
return false;
}
};

### 测试用例

template<class T>
void Assert(const T& t1, const T& t2)
{
assert(t1 == t2);
}
template<class T>
void Assert(const vector<T>& v1, const vector<T>& v2)
{
if (v1.size() != v2.size())
{
assert(false);
return;
}
for (int i = 0; i < v1.size(); i++)
{
Assert(v1[i], v2[i]);
}
}
int main()
{
vector<int> nums;
int indexDiff,  valueDiff;
{
Solution sln;
nums = { 1, 2, 3, 1 }, indexDiff = 3, valueDiff = 0;
auto res = sln.containsNearbyAlmostDuplicate(nums, indexDiff, valueDiff);
Assert(true, res);
}
{
Solution sln;
nums = { 1, 5, 9, 1, 5, 9 }, indexDiff = 2, valueDiff = 3;
auto res = sln.containsNearbyAlmostDuplicate(nums, indexDiff, valueDiff);
Assert(false, res);
}
}

## 2023年4月版

class Solution {
public:
bool containsNearbyAlmostDuplicate(vector& nums, int indexDiff, int valueDiff) {
std::multiset setHas;
for (int i = 0; i < nums.size(); i++)
{
const int iDelIndex = i - indexDiff - 1;
if (iDelIndex >= 0)
{
auto it = setHas.find(nums[iDelIndex]);
setHas.erase(it);
}
auto it1 = setHas.lower_bound(nums[i] - valueDiff);
auto it2 = setHas.upper_bound(nums[i] + valueDiff);
if (it1 != it2)
{
return true;
}
setHas.emplace(nums[i]);
}
return false;
}
};

## 桶排序算法

class Solution {
public:
bool containsNearbyAlmostDuplicate(vector& nums, int k, int t) {
unordered_map mp;
int n = nums.size();
for (int i = 0; i < n; i++)
{
const int curValue = nums[i];
int inx = GetBucketIndex(curValue, t + 1);
if (mp.count(inx))
{
return true;
}
if (mp.count(inx - 1) && (abs(curValue - mp[inx - 1]) <= t))
{
return true;
}
if (mp.count(inx + 1) && (abs(curValue - mp[inx + 1]) <= t))
{
return true;
}
mp[inx] = curValue;
if (i>= k)
{
const int iEraseIndex = GetBucketIndex(nums[i - k ],t+1);
mp.erase(iEraseIndex);
}
}
return false;
}
int GetBucketIndex(int value, int iBuckCap)
{
return value >= 0 ? (value / iBuckCap) : ((value + 1) / iBuckCap - 1);
}
};

## 扩展阅读

#### 视频课程

https://edu.csdn.net/course/detail/38771

https://edu.csdn.net/lecturer/6176

#### 测试环境

|
1月前
|

【算法】滑动窗口——最大连续1的个数
【算法】滑动窗口——最大连续1的个数
42 0
|
1月前
|

【算法】滑动窗口——将x减到0的最小操作数
【算法】滑动窗口——将x减到0的最小操作数
44 0
|
1月前
|

【算法】滑动窗口——串联所有单词的子串
【算法】滑动窗口——串联所有单词的子串
29 0
|
1月前
|

【算法】二分查找——在排序数组中查找元素的第一个和最后一个位置
【算法】二分查找——在排序数组中查找元素的第一个和最后一个位置
45 0
|
1月前
|

【算法】滑动窗口——最小覆盖子串
【算法】滑动窗口——最小覆盖子串
32 0
|
1月前
|

【算法】滑动窗口——找到字符串中所有字母异位词
【算法】滑动窗口——找到字符串中所有字母异位词
30 0
|
1月前
|

【算法】滑动窗口——无重复字符的最长子串
【算法】滑动窗口——无重复字符的最长子串
23 0
|
1月前
|

【算法】滑动窗口——长度最小的子数组
【算法】滑动窗口——长度最小的子数组
41 0
|
24天前
|

42 1
|
30天前
|

LeetCode第83题删除排序链表中的重复元素

26 2