STL(5)—set和map的使用与AVL树的插入(四种旋转情况)

已于 2022-05-21 10:52:10 修改
阅读量267 收藏
点赞数
分类专栏： C/C++学习 高级数据结构 文章标签： C++ 数据结构与算法 AVL树 STL
于 2022-05-16 16:48:15 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CS_COPy/article/details/124802936
版权

- 本人的LeetCode账号：Router，欢迎关注获取每日一题题解，快来一起刷题呀~

一、关联式容器

  STL容器中，底层为线性序列的数据结构的容器vector list deque forward_list，这些容器被称为序列式容器；

  关联式容器也是来存储数据的，插入元素时，数据是必须往固定的位置插入的，数据之间有着强烈的关联关系，因此数据的检索效率会更高。

二、key模型有序序列set

  原型：

  第二个参数是仿函数，用来给内部进行比较。

1 简单使用

  所有的容器都可以用范围for或迭代器来遍历，其中范围for的底层的原理就是迭代器。

int main()
{
	set<int> myset;
	myset.insert(1);
	myset.insert(3);
	myset.insert(-5);
	myset.insert(9);
	myset.insert(-10);
	auto it = myset.begin();
	while (it != myset.end())
	{
		cout << *it << ' ';
		++it;
	}
	return 0;
}

2 迭代器

  显然支持正向和反向迭代器的set的迭代器是一个双向迭代器。

3 修改容器

  它的删除支持给一个迭代器位置删除、给一个值删除、或者给一个迭代器区间删除：

  删除一个迭代器位置和删除一个值的区别：如果按迭代器位置删除，给的是一个无效迭代器，很可能会报错。

int main()
{
	set<int> myset;
	myset.insert(1);
	myset.insert(3);
	myset.insert(-5);
	myset.insert(9);
	myset.insert(-10);
	auto it = myset.begin();
	while (it != myset.end())
	{
		cout << *it << ' ';
		++it;
	}
	cout << endl;
	it = myset.find(10);
	myset.erase(it);
	for (auto e : myset)
	{
		cout << e << ' ';
	}
	return 0;
}

  而用值删除，如果目标元素不存在，我们直接删，它不会给我报错，会通过返回值告诉我被删除的数据的个数：

  对于set来说，返回1表示这个元素存在且被删除，返回0表示这个元素不存在。

  交换：

4 lower_bound和upper_bound

  set维护的是一个有序集合，其lower_bound(val)返回的是第一个不在val之前的元素的迭代器。（即如果set中有val，它可以是指向val的迭代器）。

  upper_bound(val)返回的是第一个在val之后的元素的迭代器，如果set中有val，它会指向它之后的一个元素。

二、multiset

  为了解决排序而不去重的需求，multiset容器应运而生。

  它的接口和set的接口都类似，区别在哪呢？

  它可以直接排序，并且元素重复时依然允许我们插入。

1 multiset的find

  既然multiset中可能有重复元素，那么我们find(重复元素)返回的迭代器到底是指向谁的?

  可见它找的是中序的第一个结点，返回的是中序的第一个值所在的结点的迭代器。

2 multiset的erase

  按迭代器删除只删除迭代器指向的节点，按值删除可以在multiset中删除所有值为val的结点。

  这里如果一个一个删除，那么也可能出现迭代器失效的问题，而C++98中没有用返回值来防止迭代器失效，C++11给了我们用返回值来防止这种迭代器失效的场景：

  如果不能用C++11，你可以提前储存下一个位置的迭代器来规避迭代器失效。

  不过一次性删除multiset中所有值为val的元素，我们可以按值删除。

  set没有像其他容器一样给我们提供专门的修改接口，就算通过迭代器也不能修改，*it在set中是常引用，无法修改。

  因为擅自修改一个值，很可能直接破坏了搜索树的结构，有的结构破坏了以后，没法通过旋转等操作弄回来。

三、key-value模型有序序列map

  每个结点除了存一个Key，还存了一个T,它是使用pair<const Key, T>键值对实现的。

1 map的简单使用

  map的大部分操作和set都相同，除了这个operator[]：

  它的insert：

  它的value_type是pair去typedef出来的。

  它的遍历不能直接把pair输出出来，因为pair没有去重载operator<<，

void test_map1()
{
	map<string, string> dict;
	// 第一种插入方式
	pair<string, string> p1("sort", "排序");
	dict.insert(p1);
	// 第二种插入方式 匿名对象
	dict.insert(pair<string, string>("unique", "不同的"));
	// 还可使用make_pair 优势在于自动推导类型
	dict.insert(make_pair("value", "值"));
	// 还可以用{}
	dict.insert({ "type", "类型" });
	map<string, string>::iterator it = dict.begin();
	while (it != dict.end())
	{
		cout << '(' << (*it).first << ' ' << (*it).second << ')';
        // 还是operator->看起来正常
		cout << '(' << it->first << ' ' << it->second << ')';
		++it;
	}
	cout << endl;
    // 范围for
	for (auto& p : dict)
	{
		cout << '(' << p.first << ',' << p.second << ')' << endl;
	}
}

  这里排序是按key进行排序的。

  erase和find和set的类似，但是是只针对key做查找和删除。

2 map的operator[]

  map的key不支持修改，但是其value支持修改。

  如果我们朴素的去统计一个字典中单词出现的次数：

void test_map2()
{
	string arr[] = { "苹果", "香蕉", "菠萝", "香蕉", "苹果", "梨", "苹果" };
	map<string, int> cnt;
	for (auto& s : arr)
	{
		auto it = cnt.find(s);
		if (it == cnt.end()) cnt.insert(make_pair(s, 1));
		else
		{
			++(*it).second;
		}
	}
}

  这里还可以优化一下，cnt.find查找一次，cnt.insert再查找一次。

  我们先看这个insert的返回值：

  如果key已经存在了，返回值的第二个成员为true，第一个成员就是新位置的迭代器，如果已经存在了，那么第二个成员为false，第一个成员为就是已经存在的位置的迭代器。

  所以不用find了，直接用insert的返回值来搞就行了

void test_map2()
{
	string arr[] = { "苹果", "香蕉", "菠萝", "香蕉", "苹果", "梨", "苹果" };
	map<string, int> cnt;
	for (auto& s : arr)
	{
		// 如果是key第一次出现 直接就插入进去了 pb.second == true
		auto pb = cnt.insert(make_pair(s, 1));
		// 如果插入失败 说明key不是第一次出现 这时
		// 返回了一个迭代器指向已经出现的节点
		// 然后利用这个迭代器++其second(次数)
		if (pb.second == false)
		{
			pb.first->second++;
		}
	}
    for (auto& kv : cnt)
	{
		cout << kv.first << ':' << kv.second << endl;
	}
}

  但是其实更常用的做法是使用operator[]

void test_map2()
{
	string arr[] = { "苹果", "香蕉", "菠萝", "香蕉", "苹果", "梨", "苹果" };
	map<string, int> cnt;
	for (auto& s : arr)
	{
		++cnt[s];
	}
	for (auto& kv : cnt)
	{
		cout << kv.first << ':' << kv.second << endl;
	}
}

  以前的operator[]是数组行为，但这里operator[]是以关键字来返回value的引用，如果不存在则插入：

// 这是operator[]的简略等价版本
(*((this->insert(make_pair(k,mapped_type()))).first)).second

  含义就是this调用insert函数，插入make_pair(k,mapped_type())，然后得到其返回值pair<iteraot, bool>的first，即那个key位置的迭代器，然后解引用这个迭代器去访问其second，访问到value.

  所以这个operator[]同时做到了插入、查找、修改value的功能，如果[key]第一次出现，那么它会做到插入并且返回刚初始化的value的引用，如果[key]不是第一次出现，通过查找返回value的引用，然后可以通过其他运算修改这个值。

  operator的三种作用：

dict["string"];// 单纯插入
dict["sort"] = "排序"; // 插入加排序
dict["sort"] = "不想玩了"; // 修改

四、multimap

  它的用法和map的用法几乎一致，和multiset一样，如果key存在它仍然会继续插入。

  因此它就没有operator[]，因为key相同的可能有很多节点，我到底要返回哪一个呢？

void test_map3()
{
	multimap<string, string> mdict;
	mdict.insert(make_pair("排序", "sort"));
	mdict.insert(make_pair("排序", "mysort"));
	for (auto& e : mdict)
	{
		cout << e.first << ' ' << e.second << endl;
	}
}

  它支持count，会返回关键字等于key的节点的个数。

  erase和multiset也是一样，传迭代器就删除一个结点，传键值就删除所有键值为key的结点。

  对于topk问题，数据量不大时，我们可以用map<string, int>计数，然后vector<map<string, int>::iterator>加函数对象排序；

  也可以用multimap<int, string>把<次数, 关键字>存进来并排序，降序的话搞个greater<int>进去就行。

五、平衡二叉树—AVL树

  前面对map/multimap/set/multiset进行了简单的介绍，在其文档介绍中发现，这几个容器有个共同点是： 其底层都是按照二叉搜索树来实现的，但是二叉搜索树有其自身的缺陷，假如往树中插入的元素有序或者接 近有序，二叉搜索树就会退化成单支树，时间复杂度会退化成O(N)，因此map、set等关联式容器的底层结构 是对二叉树进行了平衡处理，即采用平衡树来实现。

  AVL树又称高度平衡二叉搜索树，以高度来控制二叉搜索树的平衡。

  二叉搜索树虽可以缩短查找的效率，但如果数据有序或接近有序二叉搜索树将退化为单支树，查找元素相当 于在顺序表中搜索元素，效率低下。因此，两位俄罗斯的数学家G.M.Adelson-Velskii和E.M.Landis在1962年 发明了一种解决上述问题的方法：当向二叉搜索树中插入新结点后，如果能保证每个结点的左右子树高度之 差的绝对值不超过1(需要对树中的结点进行调整)，即可降低树的高度，从而减少平均搜索长度。

  AVL树有很多实现方法，其中一种比较经典的实现方式就是去使用平衡因子（右子树高度减左子树高度），这种情况下，AVL树要求：

  • 它的左右子树都是AVL树
  • 左右子树高度之差(简称平衡因子)的绝对值不超过1(-1/0/1)

  如果一棵二叉搜索树是高度平衡的，它就是AVL树。如果它有n个结点，其高度可保持在 ，搜索时间复杂度O(logN)，效率就非常高，如果往AVL树中插入10亿个结点，它最多查找30次。

1 基础结构

template<class K, class V>
struct AVLTreeNode
{
	AVLTreeNode<K, V>* _left;
	AVLTreeNode<K, V>* _right;
	AVLTreeNode<K, V>* _parent;// 三叉链
	pair<K, V> _kv;

	int _bf;// 平衡因子
	// 不加平衡因子需要用递归实现 不好理解
	// 新增结点平衡因子为0
	AVLTreeNode(const pair<K, V>& kv = pair<K, V>()) 
		: _kv(kv), _left(nullptr), _right(nullptr), _parent(nullptr), _bf(0)
	{}
};
template<class K, class V>
class AVLTree
{
	typedef AVLTreeNode<K, V> Node;
public:
	AVLTree() : _root(nullptr) {}
private:
	Node* _root;
};

2 插入

  插入时，要更新祖先的平衡因子（更新到根也会结束），更新逻辑：

  1. cur == parent->left，parent->bf--。
  2. cur == parent->right，parent->bf++。
  3. 如果更新后parent->bf == 0，说明更新前parent的bf是1或-1，现在变成0，说明填上了矮的那边，parent所在的子树高度不变，自然更新结束。
  4. 更新以后，parent->bf == 1 / -1，当前parent所在子树是平衡的，但是要继续往上更新新插入结点的影响，说明更新前parent的bf是0，新插入的节点使得高度变高了，需要继续往上更新。
  5. 更新以后，parent->bf == 2 / -2，则说明parent所在的子树已经不平衡了，需要旋转处理

  我们提供一下插入的总框架：

// 插入
bool Insert(const pair<K, V> &kv)
{
    if (_root == nullptr)
    {
        _root = new Node(kv);
        return true;
    }
    Node *parent = nullptr;
    Node *cur = _root;
    while (cur)
    {
        if (cur->_kv.first > kv.first)
        {
            parent = cur;
            cur = cur->_left;
        }
        else if (cur->_kv.first < kv.first)
        {
            parent = cur;
            cur = cur->_right;
        }
        else
            return false;
    }
    // 插入一个结点 只会影响它的祖先的平衡因子
    cur = new Node(kv);
    cur->_parent = parent;
    if (parent->_kv.first > cur->_kv.first)
    {
        parent->_left = cur;
    }
    else
    {
        parent->_right = cur;
    }
    // 控制平衡
    // 1、更新平衡因子
    // 2、出现异常的平衡因子(2, -2)，那么需要“旋转平衡树"
    while (parent)
    {
        if (parent->_left == cur)
        {
            --parent->_bf;
        }
        else
        {
            ++parent->_bf;
        }

        if (parent->_bf == 0)
        {
            break; // 平衡因子变成0的情况 直接停止更新
        }
        else if (abs(parent->_bf) == 1)
        {
            // 平衡因子没有破坏平衡
            // 继续往上更新
            cur = parent;
            parent = parent->_parent;
        }
        else if (abs(parent->_bf) == 2)
        {
            // 旋转处理
            if (parent->_bf == -2 && cur->_bf == -1)
            {
                // 这种情况就是右单旋转
                RotateR(parent);
            }
            // 左单选
            else if (parent->_bf == 2 && cur->_bf == 1)
            {
                RotateL(parent);
            }
            // 左右双旋
            else if (parent->_bf == -2 && cur->_bf == 1)
            {
                RotateLR(parent);
            }
            // 右左双旋
            else if (parent->_bf == 2 && cur->_bf == -1)
            {
                RotateRL(parent);
            }
            break;
        }
        else
        {
            // 说明插入平衡因子之前这个位置就出问题了
            // assert断掉
            assert(false);
        }
    }
    return true;
}

3 旋转的情况

I 右单旋(左边高)

  注意这个过程要控制三叉链，结合下面的图，我们写出代码：

// 右单旋
void RotateR(Node* parent)
{
    Node* subL = parent->_left;
	Node* subLR = subL->_right;
    Node* parentParent = parent->_parent;
	subL->_right = parent;
    parent->_parent = subL;
	parent->_left = subLR;
    if (subLR)
		subLR->_parent = parent;
    if (parent == —_root)
	{
        _root = subL;
		subL->_parent = nullptr;
	}
    else
	{
        if (parentParent->_left == parent) parentParent->_left = subL;
		else parentParent->_right = subL;
		subL->_parent = parentParent;
    }
	subL->_bf = parent->_bf = 0;
}

II 左单旋(右边高)

  同理，这里就是反过来了，parent的平衡因子是2，cur的平衡因子是1，只要画出图来，注意维护三叉链，很快就能写出来：

// 左单旋 平衡因子为parent == 2 cur == 1
// 转后平衡因子为0,0
void RotateL(Node* parent)
{
    Node* subR = parent->_right;
	Node* subRL = subR->_left;
    Node* parentParent = parent->_parent;
	parent->_parent = subR;
    subR->_left = parent;
	parent->_right = subRL;
    if (subRL) subRL->_parent = parent;
	if (parent == _root)
    {
		_root = subR;
        subR->_parent = nullptr;
	}
	else
    {
		if (parentParent->_left == parent)
        {
			parentParent->_left = subR;
		}
        else parentParent->_right = subR;
		subR->_parent = parentParent;
	}
    subR->_bf = parent->_bf = 0;
}

III 左右双旋和右左双旋

// 左右双旋
void RotateLR(Node *parent)
{
    // 先选parent的左孩子 进行左旋
    RotateL(parent->_left);
    // 再把parent进行右旋
    RotateR(parent);
    // 平衡因子更新：
}
// 右左双旋
void RotateRL(Node *parent)
{
    // 先旋parent的右孩子 进行右旋
    RotateR(parent->_right);
    // 再把parent进行左旋
    RotateL(parent);
    // 平衡因子更新
}

  如何在左右双旋的情况下更新平衡因子我们稍后讨论。

4 验证平衡

  手动验证未免过于麻烦，我们遍历每个点，如果每个点的左右子树的高度差小于一即说明平衡，否则说明不平衡。

bool _isBalance(Node *root)
{
    if (root == nullptr)
        return true;
    int leftheight = _height(root->_left);
    int rightheight = _height(root->_right);

    // 检查平衡因子是否异常
    if (rightheight - leftheight != root->_bf)
    {
        cout << root->_kv.first << "现在是" << root->_bf << endl;
        cout << root->_kv.first << "应该是" << rightheight - leftheight << endl;
        return false;
    }

    return abs(leftheight - rightheight) < 2 && _isBalance(root->_left) && _isBalance(root->_right);
}

int _height(Node *root)
{
    if (root == nullptr)
        return 0;
    int leftheight = _height(root->_left);
    int rightheight = _height(root->_right);
    return 1 + max(leftheight, rightheight);
}

  发现这组测试用例:{4, 2, 6, 1, 3, 5, 15, 7, 16, 14}通过不了验证：

void TestAVLTree1()
{
	AVLTree<int, int> t;
	//int a[] = { 5, 4, 3, 2, 1 };
	// int a[] = { 16, 3, 7, 11, 9, 26, 18, 14, 15 };
	// int a[] = { 1, 2, 3, 4, 5 };
	int a[] = { 4, 2, 6, 1, 3, 5, 15, 7, 16, 14 };
	for (auto& e : a)
	{
		t.Insert(make_pair(e, e));
		if (!t.isBalance())
		{
			cout << "插入" << e << "出问题了" << endl;
		} 
	}
	t.Inorder();
	if (!t.isBalance()) cout << "该树异常" << endl;
}

  它的问题在于我们右左双旋时，平衡因子都是按照单旋时的平衡因子更新，没有做对应的平衡因子更新

5 右左双旋平衡因子更新

  触发右左双旋的三个场景如下，并且它们引发的不同平衡因子更新变化结果如下：

  方法是去识别60的平衡因子，插入结点后，旋转前，第一种情况“60”的平衡因子是1，第二种情况“60”的平衡因子是-1，第三种情况60的平衡因子是0.

// 左右双旋
void RotateLR(Node *parent)
{
    Node *subL = parent->_left;
    Node *subLR = subL->_right;
    int checkbf = subLR->_bf;
    // 先选parent的左孩子 进行左旋
    RotateL(parent->_left);
    // 再把parent进行右旋
    RotateR(parent);
    // 平衡因子更新：
    if (checkbf == -1)
    {
        // 图1
        parent->_bf = 1;
        subLR->_bf = subL->_bf = 0;
    }
    else if (checkbf == 1)
    {
        // 图2
        subL->_bf = -1;
        subLR->_bf = parent->_bf = 0;
    }
    else
    {
        // 图3
        subL->_bf = subLR->_bf = parent->_bf = 0;
    }
}

6 左右双旋平衡因子更新

  仿照右左双旋平衡因子更新的方法，画出图来：

// 左右双旋
void RotateLR(Node *parent)
{
    Node *subL = parent->_left;
    Node *subLR = subL->_right;
    int checkbf = subLR->_bf;
    // 先选parent的左孩子 进行左旋
    RotateL(parent->_left);
    // 再把parent进行右旋
    RotateR(parent);
    // 平衡因子更新：
    if (checkbf == -1)
    {
        // 图1
        parent->_bf = 1;
        subLR->_bf = subL->_bf = 0;
    }
    else if (checkbf == 1)
    {
        // 图2
        subL->_bf = -1;
        subLR->_bf = parent->_bf = 0;
    }
    else
    {
        // 图3
        subL->_bf = subLR->_bf = parent->_bf = 0;
    }
}

7 通过验证

8 AVL树的删除

  因为AVL树也是二叉搜索树，可按照二叉搜索树的方式将节点删除，然后再更新平衡因子，只不错与删除不 同的时，删除节点后的平衡因子更新，最差情况下一直要调整到根节点的位置。

  因为比较复杂，这里不做讲解，详细可以参考《算法导论》或者《数据结构-用面向对象方法与C++描述》殷人昆版。

9 AVL树的性能

  AVL树是一棵绝对平衡的二叉搜索树，其要求每个节点的左右子树高度差的绝对值都不超过1，这样可以保证查询时高效的时间复杂度，即logN 。但是如果要对AVL树做一些结构修改的操作，性能非常低下，比如： 插入时要维护其绝对平衡，旋转的次数比较多，更差的是在删除时，有可能一直要让旋转持续到根的位置。 因此：如果需要一种查询高效且有序的数据结构，而且数据的个数为静态的(即不会改变)，可以考虑AVL树， 但一个结构经常修改，就不太适合。

  我们来测试一下AVL树插入1e9个结点的速度和它的高度。

  可以看到AVL树的插入的效率还是很不错的。

魔术师的徒弟
关注
专栏目录
【C++】使用AVL平衡树实现一个类似STL的Map
icykitty的博客
11-09 794
我才学完AVL，感觉AVL好像能实现类似map这样的功能，于是做了这样一个模板类。（后来知道stl的map也是用平衡树实现的，但是是用内建的红黑树，更高级一点） #include &lt;iostream&gt; #include &lt;cstdio&gt; #include &lt;string&gt; using namespace std; /* Map使用起来就像一个强大的数组，但...
STL之AVL树
HN_gsf的博客
08-16 1774
关联式容器 之所以说是关联式容器，每笔数据都有一个键值和一个实值，当元素插入关联式容器时，容器会按照键值大小， 依据特定规则（set，multiset，map，multimap是红黑书，hash是hash表）将元素放在特定位置； 所以关联式容器就不会有push_back( )  pop_back( ) push_front( ) pop_front( )等操作； 首先了解一下树的深
STL容器之map和set的补充——AVL树
qq_33093885的博客
03-05 1167
AVL树的原理以及模拟实现
AVL树和红黑树（map和set的底层实现）
海盗船长y的博客
04-26 1299
map和set的概念及使用 map和set的底层结构 map和set其底层都是按照二叉搜索树来实现的，但是二叉搜索树有其自身的缺陷，假如往树中插入的元素有序或者接近有序，二叉搜索树就会退化成单支树，时间复杂度会退化成O(N)，因此map、set等关联式容器的底层结构是对二叉树进行了平衡处理，即采用平衡树来实现。 AVL树 AVL树的概念 二叉搜索树虽可以缩短查找的效率，但如果数据有序或接近有序二叉...
Stl中map、set 容器（数据结构：AVL树、红黑树）--C++
qq_63412763的博客
09-24 2295
Stl的容器中，map和set都是用的树状数据结构----二叉树！但实际上用的并不是普普通通的树状结构，而是一种设计好的，规律性极强的树状数据结构：红黑树（二叉树的一种，细节下面讲）对于map和set来讲，中序遍历依旧是有序的，而这和之前讲的二叉搜索树有点相似。
STL容器之map和set的补充——红黑树
qq_33093885的博客
03-06 1106
c++红黑树的学习和模拟实现
C++STL之map、set的使用和模拟实现
溟洵的博客
01-29 1527
本章主要讲了map、set是如何使用的，以及map、set如何底层实现相较于前面的章节本章更加考验你的逻辑能力来进行封装，还能帮助对大体框架的有更加好的了解。
STL map / set 底层机制: 红黑树完全剖析
专注游戏研发
08-21 3023
前言： 在 STL 的容器中两大阵营 (vector deque list forward_list) 顺序容器 与 关联容器 （map set unorder_map unorder_set） 。 关联容器指的是以关键字匹配指定数据的一种关联数据结构的集合， 在关联容器中通过关键字去查找对应的数据是非常块的， 下面我们会彻底地去剖析其底层实现机制 ： 红黑树。 由基础树 到 二叉搜索树 介绍红黑树之前，容许我介绍树的概念。 1. 树（tree）， 在计算机科学中，是十分基础的数据结构： .
STL(6)—红黑树的简易实现(仅插入功能)与set和map的封装实现
CS_boy的博客
05-21 370
简单模拟实现set和map
STL AVL map/set library-开源
04-26
总的来说，这个开源的STL AVL map/set库提供了一种高效且与g++兼容的替代方案，尤其对于那些需要快速查找和高度平衡的二叉搜索树应用来说。通过使用AVL树，开发者可以期待更稳定的性能，尤其是在大型数据集和频繁...
AVL_Tree实现STL中的map, set, multimap和multiset
01-10
用AVL-tree数据结构作为底层机制，以STL底层空间配置器和iterator_traits编程技法实作出一个独立的关联式容器(map, set, multimap, multiset)，并对外提供接口实现和STL完全兼容的容器。
C语言版的STL，包含set,list,map等基本数据结构和算法.zip
06-17
在C语言版的STL中，set可能被实现为红黑树或者哈希表，用于快速查找和插入元素。Set通常用于存储不重复的数据，例如去重操作。 2. **List**: List通常是一个双向链表，允许在列表中的任何位置进行插入和删除操作，...
HashMap为什么线程不安全？
rnnf_yyds的博客
11-03 655
HashMap底层是基于数组 + 链表（在 Java 8 以后，当链表长度超过一定阈值时会转换为红黑树）的数据结构。在多线程环境下，当多个线程同时对HashMap进行put操作时，可下面这种情况：假设两个线程 A 和 B 同时执行put操作，它们计算出的插入位置相同（假设为index线程 A 先获取到了当前index位置的节点，在它还没来得及将新节点插入链表（或树）时，线程 B 也获取到了这个位置的节点。
DFS求解迷宫最长移动路线
安祝老师的博客
11-05 1255
来源：十四届蓝桥杯STEMA考试Python真题试卷第二套第五题。本文给出了C++实现代码，介绍了 STL 中容器`vector`，`pair`，`unordered_set` 的应用，供信奥选手参考。**迷宫类问题**适合用**DFS算法**解决，本文最后总结了DFS算法的两种常见实现方式——**递归实现、栈实现**，应用场景——**迷宫类问题、图的连通性、树的遍历、拓朴排序、排列组合**，以及主要优缺点。
CSP/信奥赛C++刷题训练：经典深搜例题（1）：洛谷1605 ：迷宫
weixin_66461496的博客
11-02 1026
CSP/信奥赛C++刷题训练：经典深搜例题（1）：洛谷1605 ：迷宫
模拟退火算法求解TSP问题
m0_56408077的博客
11-04 365
模拟退火算法（Simulated Annealing, SA）是一种通用的随机优化算法，适合解决组合优化问题，如旅行商问题（TSP）。TSP 问题的目标是给定一组城市，找到一条闭合路径，使得旅行商从一个城市出发，访问每个城市恰好一次并最终返回起点，同时路径总长度最短。
实习冲刺Day11
2301_78814687的博客
11-02 319
c++中字符串有两种存储方式，一种是存储在char[]数组中，一种是存储在c++封装的string类中。在C中也可以使用字符指针来访问一个字符串,通过字符指针指向存放字符串数组的首元素地址来进行访问.在C中，并没有字符串这个数据类型，而是使用。char[]来保存字符串。二叉树的先序遍历根左右。二叉树的后序遍历左右根。
爬台阶问题
小杏儿的小家
11-05 543
爬楼梯问题的分析，思考，解析以及如何动手用代码进行实践。
牛客网剑指Offer-树篇-JZ36 二叉搜索树与双向链表
最新发布
技术卷的博客
11-05 386
输入一棵二叉搜索树，将该二叉搜索树转换成一个排序的双向链表。要求空间O(1)
map和set的底层为什么使用红黑树，而不使用AVL树
03-25
map和set使用红黑树的主要原因是红黑树的平衡性能相对较好且实现比较简单，而AVL树的平衡性能更好但实现相对较为复杂。在实际使用中，红黑树的优越性能已经足够满足大部分的需求，因此STL中的map和set选择了红黑树...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值