二叉树进阶 --- 中

最新推荐文章于 2024-11-06 10:46:33 发布
最新推荐文章于 2024-11-06 10:46:33 发布
阅读量891 收藏 22
点赞数 20
分类专栏： C++ 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_62229058/article/details/138729161
版权

目录

1. find 的递归实现

2. insert 的递归实现

3. erase 的递归实现

3.1. 被删除的节点右孩子为空

3.2. 被删除的节点左孩子为空

3.3. 被删除的节点左右孩子都不为空

4. 析构函数的实现

5. copy constructor的实现

6. 赋值运算符重载

7. 搜索二叉树的完整实现

1. find 的递归实现

find的递归实现较为简单，思路是：根据当前节点的 key 与传入的 key 作比较：

  • 如果前者大于后者，那么当前节点往左子树走；
  • 如果前者小于后者，那么当前节点往右子树走；
  • 如果两者相等，返回true；
  • 走到空，返回false。

代码实现：

// 对外提供的
bool find_recursion(const T& key)
{
	return _find_recursion(_root, key);
}
// 类中私有的
bool _find_recursion(Node* root, const T& key)
{
	if (root == nullptr)
		return false;
	else
	{
		if (root->_key < key)
			return _find_recursion(root->_right, key);
		else if (root->_key > key)
			return _find_recursion(root->_left, key);
		else
			return true;
	}
}

2. insert 的递归实现

insert分为两个过程

  • 第一个过程：找到合适位置；
  • 第二个过程：构建新节点，并完成连接关系。

假如现在我们已经得到了合适的插入位置，那么如何连接呢？

例如，如下图所示：我们要插入13这个数据，现在的关键问题是，如何将15和13这两个节点连接起来呢？ 具体如下：

第一种方法：调用函数时，将父亲节点即这里的15也传进来。找到合适位置，创建节点并连接。

但是我们在这里提出一个较好玩的玩法，利用引用传参，如下所示：

// 对外提供的
bool insert_recursion(const T& key)
{    
	return _insert_recursion(_root, key);
}
// 类中私有的
bool _insert_recursion(Node*& root, const T& key)
{
	if (root == nullptr)
	{
		// 走到空, 说明找到了目标位置, 需要构建新节点, 并完成连接关系
        // 在这里, 我们用上图解释:
        // root就是15这个节点的左孩子的引用，即root就是15的左孩子
        // 给root new了一个node(key),等价于插入了这个节点,并连接了起来.
		root = new Node(key);
		return true;
	}
	else
	{
		if (root->_key < key)
			return _insert_recursion(root->_right, key);
		else if (root->_key > key)
			return _insert_recursion(root->_left, key);
		else
			return false;
	}
}

3. erase 的递归实现

对于erase的递归实现，其实也可以分为两个过程：

  • 第一个过程：找到这个要删除的特殊节点；
  • 第二个过程：可以分为三种情况(左孩子为空、右孩子为空、左右孩子都不为空)，根据不同情况进行删除。

假设我们现在已经得到了要删除节点的位置，该如何删除呢？

3.1. 被删除的节点右孩子为空

如图所示：我们要删除6号节点(其右孩子为空)，该如何删除：

 

由于 root 是4的右孩子的引用，且 root 的右孩子为空，那么root = root->_left，就可以将4的右孩子由6变更为5，我们在删除6即可，因此我们需要提前保存6节点，当指向变更之后，delete 6。

3.2. 被删除的节点左孩子为空

如图所示：我们要删除15号节点(其左孩子为空)，该如何删除：

由于 root 是8的右孩子的引用，且 root 没有左孩子，那么我们此时只需要更改 root 即可，让 root 到它的右孩子 (root = root->_right)，等价于将8连接了19，当然我们也需要提前将 root 节点进行保存，更改指向后，在释放 root 节点即可。

3.3. 被删除的节点左右孩子都不为空

较为复杂的就是第三种情况了，由于此时被删除节点有两个孩子，因此无法像上面两种情况进行处理。此时我们还是要利用循环实现的思路：

  • (1)：从被删除的节点开始，先找到左子树的最大节点or右子树的最小节点(我在这里称之为"合适节点")；
  • (2)：交换这个"合适结点"和被删除节点的key；
  • (3)：将删除原节点转化为删除我们后找的这个"合适节点"。

在这里我们用实例说明，如下图所示：如果我要删除下图中的4，该如何删除？

我在这里实现的"合适节点"是： 左子树的最大(右)节点

相信前两个过程是没有困难的，最后一步可能不好实现，但是当我们经过了前两个过程，我们发现被删除节点变成了我们找到的"合适节点"，而且这个"合适节点"很有特征，如果它是左子树的最大值，那么它一定不会有右子树，反之，如果他是右子树的最小节点，那么它一定不会有左子树。因此我们可以在递归一次，如果"合适节点"是左子树的最大节点，那么我们递归树的左子树即可，反之如果是右子树的最小节点，那么我们递归树的右子树即可。

代码如下：

// 对外提供的
bool erase_recursion(const T& key)
{
	return _erase_recursion(_root, key);
}
// 类中私有的
bool _erase_recursion(Node*& root, const T& key)
{
	if (!root)
		return false;
	else
	{
		// 如果当前节点的key > 目标key，那么递归它的左子树即可
		if (root->_key > key)
			return _erase_recursion(root->_left, key);
		// 如果当前节点的key < 目标key，那么递归它的右子树即可
		else if (root->_key < key)
			return _erase_recursion(root->_right, key);
		// 如果找到了,进行删除
		else
		{
			// 此时的root就是要删除的节点
			Node* del = root;
			// a. 左子树为空
			if (root->_left == nullptr)
				root = root->_right;
			// b. 右子树为空
			else if (root->_right == nullptr)
				root = root->_left;
			// c. 左右子树都不为空
			else
			{
				// 左子树的最右节点
				Node* left_max = root->_left;
				while (left_max->_right)
					left_max = left_max->_right;
				// 交换"合适节点"和"被删除节点"的key
				std::swap(left_max->_key, root->_key);
				// 在这里递归左子树即可
				return _erase_recursion(root->_left, key);
			}
			delete del;
			del = nullptr;
			return true;
		}
	}
}

4. 析构函数的实现

析构函数的实现我们依据的是后序的思想(LRN)，先析构左子树、然后是右子树、最后才是根。这种实现的原因是是少了许多的记录信息，例如在这里我们就不用记录下一个节点。因为我们释放的就是当前的叶子节点。

具体实现如下：

~BinarySearchTree()
{
	_BSTDestroy(_root);
}
// 注意我们这里传递的是根的引用
void _BSTDestroy(Node*& root)
{
	if (root == nullptr)
		return;
	else
	{
		// 依据后序的思想
		_BSTDestroy(root->_left);
		_BSTDestroy(root->_right);
		delete root;
		root = nullptr;
	}
}

5. copy constructor的实现

老生常谈的问题，如果我们没有显示实现拷贝构造函数，那么编译器默认生成的拷贝构造会对内置类型按照字节序的方式进行拷贝，对自定义类型成员属性会去调用它的拷贝构造函数。而字节序的方式进行拷贝会带来两个问题：

  • 其一，其中一个对象的修改会影响另一个对象；
  • 其二，同一空间会被析构两次，进程crash。

因此，我们在这里必须要实现深拷贝，那如何实现呢？我们可以借助前序的思想(NLR)。从根节点开始进行构造节点，然后递归构造它的左子树和右子树。注意构造的时候需要它们的连接关系。

代码如下：

BinarySearchTree(const BinarySearchTree<T>& copy)
{
	_root = _creat_new_root(copy._root);
}
Node* _creat_new_root(Node* root)
{
	// 如果遇到空了,就不用构造了
	if (root == nullptr)
		return nullptr;
	else
	{
		// 根据前序的思想(NLR),依次构造它的根、左子树、右子树   
		// 同时将它们连接起来
		Node* new_root = new Node(root->_key);
		new_root->_left = _creat_new_root(root->_left);
		new_root->_right = _creat_new_root(root->_right);
		return new_root;
	}
}

6. 赋值运算符重载

赋值运算符重载就比较简单了，因为我们已经实现了copy constructor，在这里利用传值传参会进行拷贝构造的特性实现我们的赋值

代码如下：

// 传值传参会进行拷贝构造
BinarySearchTree<T>& operator=(BinarySearchTree<T> copy)
{
	std::swap(_root, copy._root);
	return *this;
}

7. 搜索二叉树的完整实现

代码如下：

#ifndef _BINARY_SEARCH_TREE_HPP_
#define _BINARY_SEARCH_TREE_HPP_

#include <iostream>

namespace Xq
{

	template<class T>
	struct BinarySearchTreeNode
	{
		BinarySearchTreeNode<T>* _left;
		BinarySearchTreeNode<T>* _right;
		T _key;

		BinarySearchTreeNode(const T& key) :_key(key), _left(nullptr), _right(nullptr) {}
	};

	template<class T>
	class BinarySearchTree
	{
	private:
		typedef BinarySearchTreeNode<T> Node;
	public:
		BinarySearchTree(Node* root = nullptr) :_root(root) {}

		bool insert(const T& key)
		{
			// 1. 如果是空树,直接对_root赋值即可,插入成功并返回true
			if (_root == nullptr)
			{
				_root = new Node(key);
				return true;
			}
			else
			{
				// step 1: 先找目标位置
				Node* cur = _root;
				// 为了更好的连接新节点, 因此记录父节点
				Node* parent = nullptr;

				while (cur)
				{
					// 如果当前节点的Key大于目标Key
					// 当前节点应该向左子树走
					if (cur->_key > key)
					{
						parent = cur;
						cur = cur->_left;
					}
					// 如果当前节点的Key小于目标Key
					// 当前节点应该向右子树走
					else if (cur->_key < key)
					{
						parent = cur;
						cur = cur->_right;
					}
					else
					{
						// 找到了相同的 key, 在这里不插入
						return false;
					}
				}

				// cur 走到了空, 即 cur 就是合适的位置
				cur = new Node(key);
				// 我们需要判断cur是parent的左节点还是右节点
				// 如果key小于parent的key,那么插入左节点
				if (key < parent->_key)
					parent->_left = cur;
				// 反之连接到右节点
				else
					parent->_right = cur;
				return true;
			}
		}

		bool find(const T& key)
		{
			// 1. 从根节点开始
			Node* cur = _root;
			while (cur)
			{
				// 2. 如果当前关键字大于目标关键字,那么向左子树走
				if (cur->_key > key)
					cur = cur->_left;
				// 3. 如果小于目标关键字,那么向右子树走
				else if (cur->_key < key)
					cur = cur->_right;
				// 4. 相等，就返回true
				else
					return true;
			}
			// 5. 循环结束,说明没找到, 返回false
			return false;
		}

		bool erase(const T& key)
		{
			// 先找要删除的节点
			Node* del = _root;
			Node* del_parent = nullptr;

			while (del)
			{
				if (del->_key < key)
				{
					del_parent = del;
					del = del->_right;
				}
				else if (del->_key > key)
				{
					del_parent = del;
					del = del->_left;
				}
				else
				{
					// 锁定了要删除的节点
					// 分三种情况:
					// case 1: 左子树为空
					if (del->_left == nullptr)
					{
						// 如果要删除的节点是根
						if (del == _root)
						{
							Node* newroot = del->_right;
							delete _root;
							_root = newroot;
						}
						else
						{
							// 托孤法删除
							if (del_parent->_left == del)
								del_parent->_left = del->_right;
							else
								del_parent->_right = del->_right;
							delete del;
							del = nullptr;
						}
					}
					// case 2: 右子树为空
					else if (del->_right == nullptr)
					{
						if (_root == del)
						{
							Node* newroot = del->_left;
							delete _root;
							_root = newroot;
						}
						else
						{
							if (del_parent->_left == del)
								del_parent->_left = del->_left;
							else
								del_parent->_right = del->_left;
							delete del;
							del = nullptr;
						}
					}
					// case 3: 左右子树都不为空
					else
					{
						// 从被删除节点开始, 找右子树的最小(左)节点 || 找左子树的最大(右)节点
						if (del->_right)
							_erase_right_min_node(del);
						else
							_erase_left_max_node(del);
					}
					return true;
				}
			}

			return false;
		}

		bool find_recursion(const T& key)
		{
			return _find_recursion(_root, key);
		}

		bool insert_recursion(const T& key)
		{
			return _insert_recursion(_root, key);
		}

		bool erase_recursion(const T& key)
		{
			return _erase_recursion(_root, key);
		}

		~BinarySearchTree()
		{
			_BSTDestroy(_root);
		}

		BinarySearchTree(const BinarySearchTree<T>& copy)
		{
			_root = _creat_new_root(copy._root);
		}

		// 传值传参会进行拷贝构造
		BinarySearchTree<T>& operator=(BinarySearchTree<T> copy)
		{
			std::swap(_root, copy._root);
			return *this;
		}

		void InOrder()
		{
			_InOrder(_root);
			std::cout << std::endl;
		}

	private:
		void _InOrder(Node* root)
		{
			if (root)
			{
				_InOrder(root->_left);
				std::cout << root->_key << " ";
				_InOrder(root->_right);
			}

		}

		bool _find_recursion(Node* root, const T& key)
		{
			if (root == nullptr)
				return false;
			else
			{
				if (root->_key < key)
					return _find_recursion(root->_right, key);
				else if (root->_key > key)
					_find_recursion(root->_left, key);
				else
					return true;
			}
		}

		bool _insert_recursion(Node*& root, const T& key)
		{
			if (root == nullptr)
			{
				root = new Node(key);
				return true;
			}
			else
			{
				if (root->_key < key)
					return _insert_recursion(root->_right, key);
				else if (root->_key > key)
					return _insert_recursion(root->_left, key);
				else
					return false;
			}
		}

		void _erase_right_min_node(Node* del)
		{
			// 从被删除结点开始, 找右子树的最小(左)节点
			Node* right_min = del->_right;
			// 并记录这个节点的父亲节点, 让其从del开始
			Node* right_min_parent = del;
			while (right_min->_left)
			{
				right_min_parent = right_min;
				right_min = right_min->_left;
			}
			// 交换这个节点和要删除节点的 key
			std::swap(del->_key, right_min->_key);

			// 将删除 del 转化为删除 right_min (托孤法删除)
			if (right_min_parent->_left == right_min)
				right_min_parent->_left = right_min->_right;
			else
				right_min_parent->_right = right_min->_right;
			delete right_min;
			right_min = nullptr;
		}

		void _erase_left_max_node(Node* del)
		{
			// 从被删除节点开始, 找左子树的最大(右)节点
			Node* left_max = del->_left;
			// 并记录这个节点的父亲节点, 让其从del开始
			Node* left_max_parent = del;
			while (left_max->_right)
			{
				left_max_parent = left_max;
				left_max = left_max->_right;
			}
			// 交换这个节点和要删除节点的 key
			std::swap(del->_key, left_max->_key);

			// 将删除 del 转化为删除 left_max (托孤法删除)
			if (left_max_parent->_left == left_max)
				left_max_parent->_left = left_max->_left;
			else
				left_max_parent->_right = left_max->_left;
			delete left_max;
			left_max = nullptr;
		}

		bool _erase_recursion(Node*& root, const T& key)
		{
			if (!root)
				return false;
			else
			{
				// 如果当前节点的key > 目标key，那么递归它的左子树即可
				if (root->_key > key)
					return _erase_recursion(root->_left, key);
				// 如果当前节点的key < 目标key，那么递归它的右子树即可
				else if (root->_key < key)
					return _erase_recursion(root->_right, key);
				// 如果找到了,进行删除
				else
				{
					// 此时的root就是要删除的节点
					Node* del = root;
					// a. 左子树为空
					if (root->_left == nullptr)
						root = root->_right;
					// b. 右子树为空
					else if (root->_right == nullptr)
						root = root->_left;
					// c. 左右子树都不为空
					else
					{
						// 左子树的最右节点
						Node* left_max = root->_left;
						while (left_max->_right)
							left_max = left_max->_right;
						// 交换"合适节点"和"被删除节点"的key
						std::swap(left_max->_key, root->_key);
						// 在这里递归左子树即可
						return _erase_recursion(root->_left, key);
					}
					delete del;
					del = nullptr;
					return true;
				}
			}
		}

		Node* _creat_new_root(Node* root)
		{
			// 如果遇到空了,就不用构造了
			if (root == nullptr)
				return nullptr;
			else
			{
				// 根据前序的思想(NLR),依次构造它的根、左子树、右子树   
				// 同时将它们连接起来
				Node* new_root = new Node(root->_key);
				new_root->_left = _creat_new_root(root->_left);
				new_root->_right = _creat_new_root(root->_right);
				return new_root;
			}
		}

		// 注意我们这里传递的是根的引用
		void _BSTDestroy(Node*& root)
		{
			if (root == nullptr)
				return;
			else
			{
				// 依据后序的思想
				_BSTDestroy(root->_left);
				_BSTDestroy(root->_right);
				delete root;
				root = nullptr;
			}
		}

	private:
		Node* _root;
	};
}

#endif

二叉树进阶 --- 中，结束。

---徐乾---
关注
专栏目录
C++进阶--二叉树进阶
weixin_74792326的博客
09-19 675
请你采用前序遍历的方式，将二叉树转化为一个由括号和整数组成的字符串，返回构造出的字符串。4、InOrder不需要返回值的原因：只需要在原树上对指针的指向进行改变，就好了，而且不需要在此函数中拿到头节点。在二叉搜索树中检索该单词是否存在，存在则拼写正确，不存在则拼写错误。、从根开始比较，查找，比根大则往右边走查找，比根小则往左边走查找。、最多查找高度次，走到到空，还没找到，这个值不存在。，统计成功后，给定单词就可快速找到其出现的次数，，通过英文可以快速找到与其对应的中文，英。，或者是具有以下性质的二叉树。
二叉树进阶--AVL树
wer24_25的博客
09-19 891
二叉树进阶--AVL树,万字讲解AVL树,想要彻底理解AVL树,看这一篇就够了!!!
二叉树进阶-二叉搜索树
klausur31的博客
11-03 936
二叉搜索树也叫二叉排序数（因为按照中序遍历是有序的），对于非空二叉树满足以下性质a.非空左子树的所有键值（key）都小于根节点的键值；b.非空右子树的所有健值都大于根节点的键值c.根节点的左右子树都是二叉搜索树。如图就是一颗二叉搜索树。
二叉树进阶 --- 上
m0_62229058的博客
05-11 912
假如现在我们要删除4所在的节点，可以发现，4所在的节点有两个孩子，因此无法托孤，那么我们需要采用替代法删除，替代法删除就是在左子树或者右子树找一个"合适节点"，将4所在的节点的key进行覆盖，将删除4所在的节点转化为删除我们找的这个"合适节点"。同时，我们发现，最后进行托孤法删除时，我们也进行了判断，这样的原因是因为这个"合适节点"既可能是父节点的左孩子，也可能是父节点的右孩子，因此必须判断。如果被删除节点是父亲节点的左孩子，那么在这里就是父亲节点的左孩子指向被删除节点的非空节点。
【C++】：二叉树进阶 --- 搜索二叉树
2301_77900444的博客
07-15 1813
二叉树在前面C数据结构阶段已经讲过，本节取名二叉树进阶是因为：(1)map和set特性需要先铺垫二叉搜索树，而二叉搜索树也是一种树形结构(2) 二叉搜索树的特性了解，有助于更好的理解map和set的特性因此本节借二叉树搜索树，对二叉树部分进行收尾总结。
【二叉树进阶】--- 根据二叉树创建字符串
2301_79448270的博客
08-14 1525
假设有颗满二叉树，当根结点入队时顺便此时他的左右结点也顺便入队，此时队列中结点的个数就是2，此时这两个结点对应层数就是2；类似地当第二层的两结点一父带两娃时，此时入队了4个结点，这一层也是有4个结点。1.了解思路一后，我们发现思路一维护每个结点的层数比较麻烦，我们能否另寻他路，一口气把每层的结点push进数组里？4.为了效率，我们可以先计算总的高度，提前开好二维数组所需要的层数；.我们按上面流程得到的是从上到下的层序遍历，从下往上我们可以使用。的思想(即一个父亲入队的时候，它的两个孩子也一起入队)实现。
【二叉树进阶】--- 前中后序遍历非递归
2301_79448270的博客
08-30 1324
当我们还面临一个问题当取到左路结点的右子树时，我们需要想办法标记判断右子树是否已经访问过了，如果访问过就直接访问根，没有访问过就访问右子树。中序是对左路结点时不能先访问，而是先依次入栈，入栈完左路结点后再访问这些左路结点，再依次访问他们各自的右子树。后序跟前序的思路也是完全一致，毕竟模拟的是递归展开过程，只不过后序是左子树-右子树-根，最后再访问根结点，也就是说要左右子树都访问完之后才能访问根并出栈。3.如果左路节点右子树不为空，右子树已经访问过，那么上一个访问节点应该是右子树的根，
二叉树进阶--二叉搜索树
weixin_72068014的博客
02-13 833
二叉搜索树的学习以及相关题目的解决
二叉树进阶题------最近公共祖先
weixin_46708745的博客
12-01 558
最近公共祖先思路代码 二叉树进阶题 给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。（最近公共祖先的定义为：“对于有根树 T 的两个节点 p、q，最近公共祖先表示为一个节点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。”） p 和 q 均存在于给定的二叉树中。 思路 自上而下的深度遍历DFS。理解下面这个图，然后看代码注释。 代码 public TreeNode lowestCommonAncestor(TreeNode root, TreeNode
变量进阶-数据结构和算法-归并排序
08-31
包括（变量进阶 高级变量类型），（函数进阶 面向对象），（函数进阶 面向对象），（面向对象 文件操作），（栈，循环队列，二叉树，排序算法），（堆排 归并）
MySQL进阶 -- 索引
weixin_42603304的博客
03-11 1899
文章目录一、索引优缺点二、索引结构2.1、B+Tree索引2.2、Hash索引三、索引分类四、索引语法五、SQL性能分析5.1、SQL执行频率5.2、慢查询日志5.3、profile详情5.4、explain六、索引使用6.1、最左前缀法则6.2、索引失效情况6.2.1、索引列运算6.2.2、字符串不加引号6.2.3、模糊查询6.2.4、or 连接条件6.2.5、范围查询6.2.6、数据分布影响6.3、SQL提示6.4、覆盖索引6.5、前缀索引6.6、单列索引与联合索引6.7、索引设计原则 一、索引优缺点
数据结构——二叉树进阶
New_learner55的博客
12-28 389
在我看来，在数据结构中，存在三个最经典的树型结构，他们分别是二叉排序树（BST），二叉平衡树（AVL） 和 红黑树（BRT）。 二叉排序树又叫做二叉搜索树，它可以是一棵空树，也可以是具有三个性质的一棵二叉树。 性质一：若它的左子树不为空，则左子树上的所有结点的值均小于它的根结点的值 性质二： 若它的右子树不为空，则右子树上的所有结点的值均大于它的根结点的值 性质三： 左右子树也是二叉排序树。 构造二叉搜索树的目的是提高查找和插入删除关键字的速度。因为二叉排序树是一个排序好的有序数据集，查找的速度肯定是快于无
【二叉树进阶】AVLTree - 平衡二叉搜索树
codewinter的博客
06-20 2763
二叉搜索树的插入和删除操作都必须先查找，查找效率代表了二叉搜索树中各个操作的效率。但是二叉搜索树有其自身的缺陷，假如往树中插入的元素有序或者接近有序，二叉搜索树就会退化成单支树，时间复杂度为O(N)，因此 map、set 等关联式容器的底层结构是对二叉树进行了平衡处理，即采用平衡二叉搜索树来实现。最优情况下，有 n 个结点的二叉搜索树为完全二叉树，查找效率为：O(log2N)最差情况下，有 n 个结点的二叉搜索树退化为单支树，查找效率为：O(N)平衡二叉搜索树（Self-balancing binary s
Python解题技巧与算法进阶-从LeetCode双人赛开始
- 树: 掌握二叉树及其遍历方法。 - 排序和搜索: 包括常见的排序算法和二分搜索技术。 - 动态规划: 解决需要最优子结构和重复子问题的问题。 - 设计问题: 解决需要创造性思维和清晰设计的问题。 - 数学: 算法中...
算法基础-链表
August的专栏
11-05 212
当链表的长度为偶数时，head找到的中点是靠后的，因为fast相对slow移动只快了1步，而head.next找到的中点是靠前的，因为fast相对slow移动快了2步。这2种方式寻找链表的结点主要区别是 当链表的长度为奇偶数时，找到链表中点的位置一个靠后，一个靠前。使用快慢指针寻找链表的中点有2种方式，分别是fast=head;当链表为奇数时 [1->2->3->4->5]当链表长度为奇数时，找到的中点2种方式是一样的。当链表为偶数时 [1->2->3->4]
字符串-06-整数与ip地址之间的转换
qq_45480682的博客
11-04 311
华为od算法——HJ33
【LeetCode】【算法】160.相交链表
passer__jw767的博客
11-05 279
Leetcode 160. 相交链表
【算法】（Python）贪心算法
yannan20190313的博客
11-04 1928
【算法】（Python）贪心算法（最大单元数，买卖股票最佳时机，最低加油次数）
LeetCode每日一题3254---长度为 K 的子数组的能量值 I
最新发布
niulinbiao的博客
11-06 308
输入：nums = [1,2,3,4,3,2,5], k = 3。输入：nums = [3,2,3,2,3,2], k = 2。输入：nums = [2,2,2,2,2], k = 4。[3, 4, 3] 中元素 不是 连续的。[4, 3, 2] 中元素 不是 上升的。[3, 2, 5] 中元素 不是 连续的。[1, 2, 3] 中最大元素为 3。[2, 3, 4] 中最大元素为 4。的，那么能量值为 最大 的元素。输出：[3,4,-1,-1,-1]输出：[-1,3,-1,3,-1]
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值