【C++】二叉搜索数

news2024/11/17 16:16:47

目录

一、二叉搜索树的概念

二、二叉搜索树的模拟实现

1、定义节点

2、构造二叉树

3、析构二叉树

​4、拷贝二叉树

5、二叉树赋值

6、插入节点

🌟【非递归方式】

🌟【递归方式】

7、打印节点

 8、搜索节点

🌟【非递归方式】

🌟【递归方式】

9、删除节点（重要）

🌟【非递归方式】

🌟【递归方式】

10、完整代码

三、二叉搜索树的应用

K模型&&KV模型

一、二叉搜索树的概念

  • 二叉搜索树又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树:
  • 若它的左子树不为空，则左子树上所有节点的值都小于根节点的值
  • 若它的右子树不为空，则右子树上所有节点的值都大于根节点的值
  • 它的左右子树也分别为二叉搜索树

二、二叉搜索树的模拟实现

1、定义节点

首先需要确定二叉树的节点，有左节点、和右节点以及节点的值。

2、构造二叉树

3、析构二叉树

遍历左右二叉树，删除节点并将节点置为空。

 4、拷贝二叉树

拷贝二叉树，我们不能使用insert来一个一个插入，因为inset带有筛选的功能，最后结果顺序会不同的。
我们使用类似于前序遍历的方式，进行拷贝，遍历到哪就相当于拷贝到哪。
首先遇到空就返回。1.拷贝结点 2.递归拷贝左子树3.递归拷贝右子树。4.最后将拷贝结点返回。

5、二叉树赋值

6、插入节点

🌟【非递归方式】

过程：

a. 树为空，则直接新增节点，赋值给root指针

b. 树不空，按二叉搜索树性质查找插入位置，插入新节点 

步骤：

a.当插入的结点值key要比根结点大，则key需要到根的右树进行比较，当key的值比根结点小，则key需要到根的左树进行比较，当key的值与根结点相同时，则返回fasle，按照这样的方式循环下去，当要比较的结点为空时，则就可以将结点插入到这个位置上了。每次比较中都要记录父节点的位置，因为最后需要链接起来。
b.最后链接起来需要和父结点比较一下才能知道链接到父节点的左边还是右边。如果大于父节点则链接到右边，如果小于父节点则连接到左边。

 

🌟【递归方式】

递归实现方式的思想其实是一样的，如果节点为空，就创造一个节点。如果不为空，就比较节点与需要插入值的大小，如果比节点大就插入右边，如果比节点小就插入左边，遇到空就新建一个节点。当递归结束时，就可以将开辟好结点链接起来。(递归的过程就是不断的在创建结点，回来的过程就是不断地将结点链接起来)。这里不需要像非递归那样，每次比较都需要记录父节点的位置，我们这里用一个引用就可以轻松解决问题！我们的指针参数使用引用，即子函数的参数是递归函数参数的别名。

 

7、打印节点

运用递归，分别打印 root 左边和右边的数值，遇到空就返回。

 

 8、搜索节点

过程：

a.从根开始比较，查找，比根大则往右边走查找，比根小则往左边走查找。如果没有找到就返回 false.

b.最多查找高度次，走到到空，还没找到，这个值不存在。

🌟【非递归方式】

🌟【递归方式】

当所要找的节点小于根节点时，递归到左子树去找；当所要找的节点大于根节点时，递归到右节点去找。当等于所要找的节点时，返回真。如果一直找不到则返回假。

 

9、删除节点（重要）

首先查找元素是否在二叉搜索树中，如果不存在，则返回, 否则要删除的结点可能分下面四种情 况：

a. 要删除的结点无孩子结点

b. 要删除的结点只有左孩子结点

c. 要删除的结点只有右孩子结点

d. 要删除的结点有左、右孩子结点

看起来有待删除节点有4中情况，实际情况a可以与情况b或者c合并起来，因此真正的删除过程如下：

a.当删除结点没有孩子节点时，使用托孤法，将父节点与空链接起来。--直接删除
b.当删除结点只有一个孩子节点时，使用托孤法，将父节点与孤结点链接起来。--直接删除
c.当删除结点有两个孩子节点时，使用找保姆法，找一个可以替代本身的结点。交换这两个结点，删除这个替换结点。一般来说是将root节点和左子树的最大结点或者是右子树的最小结点相交换。--替换法删除

不管怎么删除都要遵循先查找后删除的原则，当要删除的数字比root大，就往右边查找；当要删除的数字比root小就往左边查找。 

🌟【非递归方式】

 1）当只有右孩子节点时，左孩子节点为空时

首先要判断父节点是不是 root，然后判断要删除的节点时父节点的左孩子节点还是右孩子节点，如果是左孩子节点就将删除节点的孩子节点链接上父节点的左边；如果是右孩子节点就将删除节点的孩子节点链接上父节点的右边。

 2）当只有左孩子节点时，右孩子节点为空时

 3）当存在两个孩子节点时

如果我们直接删除，那可能需要改变树的结构，这样会很复杂。我们可以找到需要删除节点的左边最大值，右边最小值相交换，然后再删除。

 【测试运行】

🌟【递归方式】

当key比根结点大的时候，递归到右子树进行比较，当key比根结点值小的时候，递归到左子树进行比较，当key跟结点值相同时，表明找到了。找到后就要分三种情况讨论。

【当存在一个孩子结点时】
不同于非递归版本需要记录父节点，递归版本不需要记录父节点，因为一个引用，让我们省去了很多麻烦。root 就是父节点的左指针或者右指针。托孤直接托孤给root即可。因为root就是父节点的左右指针指向。
当右子树不存在时，直接将要删除结点的左子树托孤给root。当左子树不存在时，直接将要删除结点的右子树托孤给root。

【当存在两个孩子结点时】
当存在两个孩子结点时，还是需要使用保姆法，首先找到保姆结点，然后将要删除结点的值与保姆结点值交换。这样就转化成子问题了。从整棵树来看，因为保姆结点和删除结点交换，而改变了搜索二叉树的特性。不能使用了。
但从左子树来看，还是完整的二叉搜索树，并且要删除结点就只有一个孩子，直接转化为上面的问题。

10、完整代码

#define  _CRT_SECURE_NO_WARNINGS
#pragma once

template<class K>
struct BSTreeNode
{
	BSTreeNode<K>* _left;
	BSTreeNode<K>* _right;
	K _key;

	//初始化
	BSTreeNode(const K& key)
		:_left(nullptr)
		, _right(nullptr)
		, _key(key)
	{}
};

template<class K>
class BSTree
{
	typedef BSTreeNode<K> Node;
public:
	/*BSTree()
		:_root(nullptr)
		{}*/

	BSTree() = default; // 制定强制生成默认构造

	BSTree(const BSTree<K>& t)
	{
		_root = Copy(t._root);
	}

	BSTree<K>& operator=(BSTree<K> t)
	{
		swap(_root, t._root);
		return *this;
	}

	//~BSTree()
	//{
	//	Destroy(_root);
	//	//_root = nullptr;
	//}

	//非递归方式
	bool Insert(const K& key)
	{
		//当树为空时
		if (_root == nullptr)
		{
			_root = new Node(key);
			return true;
		}
		//当树不为空时
		Node* parent = nullptr;
		Node* cur = _root;
		while (cur)
		{
			if (cur->_key < key)
			{
				parent = cur;
				cur = cur->_right;
			}
			else if (cur->_key > key)
			{
				parent = cur;
				cur = cur->_left;
			}
			else
			{
				return false;
			}
		}

		cur = new Node(key);
		// 链接
		if (parent->_key < key)
		{
			parent->_right = cur;
		}
		else
		{
			parent->_left = cur;
		}

		return true;
	}

	//递归方式
	bool InsertR(const K& key)
	{
		return _InsertR(_root, key);
	}

	bool _InsertR(Node*& root, const K& key)
	{
		if (root == nullptr)
		{
			root = new Node(key);
			return true;
		}

		if (root->_key < key)
		{
			return _InsertR(root->_right, key);
		}
		else if (root->_key > key)
		{
			return _InsertR(root->_left, key);
		}
		else
		{
			return false;
		}
	}

	//非递归方式
	bool Find(const K& key)
	{
		Node* cur = _root;
		while (cur)
		{
			if (cur->_key < key)
			{
				cur = cur->_right;
			}
			else if (cur->_key > key)
			{
				cur = cur->_left;
			}
			else
			{
				return true;
			}
		}

		return false;
	}
	//递归方式
	bool FindR(const K& key)
	{
		return _FindR(_root, key);
	}
	bool _FindR(Node* root, const K& key)
	{
		if (root == nullptr)
			return false;

		if (root->_key == key)
			return true;

		if (root->_key < key)
			return _FindR(root->_right, key);
		else
			return _FindR(root->_left, key);
	}

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

	void _InOrder(Node* root)
	{
		if (root == nullptr)
			return;

		_InOrder(root->_left);
		cout << root->_key << " ";
		_InOrder(root->_right);
	}

	//非递归方式
	bool Erase(const K& key)
	{
		Node* parent = nullptr;
		Node* cur = _root;

		while (cur)
		{
			if (cur->_key < key)
			{
				parent = cur;
				cur = cur->_right;
			}
			else if (cur->_key > key)
			{
				parent = cur;
				cur = cur->_left;
			}
			else
			{
				// 删除
				// 1、左为空
				if (cur->_left == nullptr)
				{
					//如果cur是根节点，直接删除根节点，更改root值
					if (cur == _root)
					{
						_root = cur->_right;
					}
					else
					{
						//判断cur 是父节点的左孩子还是右孩子
						if (parent->_left == cur)
						{
							parent->_left = cur->_right;
						}
						else
						{
							parent->_right = cur->_right;
						}
					}

					delete cur;

				} // 2、右为空
				else if (cur->_right == nullptr)
				{
					if (cur == _root)
					{
						_root = cur->_left;
					}
					else
					{
						if (parent->_left == cur)
						{
							parent->_left = cur->_left;
						}
						else
						{
							parent->_right = cur->_left;
						}
					}

					delete cur;
				}
				else
				{
					// 找右树最小节点替代，也可以是左树最大节点替代
					Node* pminRight = cur;
					Node* minRight = cur->_right;
					while (minRight->_left)
					{
						pminRight = minRight;
						minRight = minRight->_left;
					}

					cur->_key = minRight->_key;

					if (pminRight->_left == minRight)
					{
						pminRight->_left = minRight->_right;
					}
					else
					{
						pminRight->_right = minRight->_right;
					}

					delete minRight;
				}

				return true;
			}
		}

		return false;
	}

	//递归方式
	bool EraseR(const K& key)
	{
		return _EraseR(_root, key);
	}
	bool _EraseR(Node*& root, const K& key)
	{
		if (root == nullptr)
			return false;

		if (root->_key < key)
		{
			return _EraseR(root->_right, key);
		}
		else if (root->_key > key)
		{
			return _EraseR(root->_left, key);
		}
		else
		{
			Node* del = root;

			// 开始准备删除
			if (root->_right == nullptr)
			{
				root = root->_left;
			}
			else if (root->_left == nullptr)
			{
				root = root->_right;
			}
			else
			{
				Node* maxleft = root->_left;
				while (maxleft->_right)
				{
					maxleft = maxleft->_right;
				}

				swap(root->_key, maxleft->_key);

				return _EraseR(root->_left, key);
			}

			delete del;

			return true;
		}
	}

	~BSTree()
	{
		Destroy(_root);
		//_root = nullptr;
	}
	void Destroy(Node*& root)
	{
		if (root == nullptr)
			return;

		Destroy(root->_left);
		Destroy(root->_right);

		delete root;
		root = nullptr;
	}
	BSTree(const BSTree<K>& t)
	{
		_root = Copy(t._root);
	}
	Node* Copy(Node* root)
	{
		if (root == nullptr)
			return nullptr;

		Node* newRoot = new Node(root->_key);
		newRoot->_left = Copy(root->_left);
		newRoot->_right = Copy(root->_right);
		return newRoot;
	}

	BSTree<K>& operator=(BSTree<K> t)
	{
		swap(_root, t._root);
		return *this;
	}
private:
	Node* _root = nullptr;
};

三、二叉搜索树的应用

K模型&&KV模型

K模型即只有key作为关键码，结构中只需要存储Key即可，关键码即为需要搜索到的值。

比如：给一个单词word，判断该单词是否拼写正确，具体方式如下： 以词库中所有单词集合中的每个单词作为key，构建一棵二叉搜索树 在二叉搜索树中检索该单词是否存在，存在则拼写正确，不存在则拼写错误。

KV模型：每一个关键码key，都有与之对应的值Value，即的键值对。该种方式在现实生活中非常常见： 比如英汉词典就是英文与中文的对应关系，通过英文可以快速找到与其对应的中文，英文单词与其对应的中文就构成一种键值对； 再比如统计单词次数，统计成功后，给定单词就可快速找到其出现的次数，单词与其出现次数就是就构成一种键值对。

【测试代码】 

template<class K, class V>
	struct BSTreeNode
	{
		BSTreeNode<K, V>* _left;
		BSTreeNode<K, V>* _right;
		K _key;
		V _value;


		BSTreeNode(const K& key, const V& value)
			:_left(nullptr)
			, _right(nullptr)
			, _key(key)
			, _value(value)
		{}
	};

	template<class K, class V>
	class BSTree
	{
		typedef BSTreeNode<K, V> Node;
	public:

		bool Insert(const K& key, const V& value)
		{
			if (_root == nullptr)
			{
				_root = new Node(key, value);
				return true;
			}

			Node* parent = nullptr;
			Node* cur = _root;
			while (cur)
			{
				if (cur->_key < key)
				{
					parent = cur;
					cur = cur->_right;
				}
				else if (cur->_key > key)
				{
					parent = cur;
					cur = cur->_left;
				}
				else
				{
					return false;
				}
			}

			cur = new Node(key, value);
			// 链接
			if (parent->_key < key)
			{
				parent->_right = cur;
			}
			else
			{
				parent->_left = cur;
			}

			return true;
		}

		Node* Find(const K& key)
		{
			Node* cur = _root;
			while (cur)
			{
				if (cur->_key < key)
				{
					cur = cur->_right;
				}
				else if (cur->_key > key)
				{
					cur = cur->_left;
				}
				else
				{
					return cur;
				}
			}

			return nullptr;
		}

		bool Erase(const K& key)
		{
			Node* parent = nullptr;
			Node* cur = _root;

			while (cur)
			{
				if (cur->_key < key)
				{
					parent = cur;
					cur = cur->_right;
				}
				else if (cur->_key > key)
				{
					parent = cur;
					cur = cur->_left;
				}
				else
				{
					// 删除
					// 1、左为空
					if (cur->_left == nullptr)
					{
						if (cur == _root)
						{
							_root = cur->_right;
						}
						else
						{
							if (parent->_left == cur)
							{
								parent->_left = cur->_right;
							}
							else
							{
								parent->_right = cur->_right;
							}
						}

						delete cur;

					} // 2、右为空
					else if (cur->_right == nullptr)
					{
						if (cur == _root)
						{
							_root = cur->_left;
						}
						else
						{
							if (parent->_left == cur)
							{
								parent->_left = cur->_left;
							}
							else
							{
								parent->_right = cur->_left;
							}
						}

						delete cur;
					}
					else
					{
						// 找右树最小节点替代，也可以是左树最大节点替代
						Node* pminRight = cur;
						Node* minRight = cur->_right;
						while (minRight->_left)
						{
							pminRight = minRight;
							minRight = minRight->_left;
						}

						cur->_key = minRight->_key;

						if (pminRight->_left == minRight)
						{
							pminRight->_left = minRight->_right;
						}
						else
						{
							pminRight->_right = minRight->_right;
						}

						delete minRight;
					}

					return true;
				}
			}

			return false;
		}


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

	protected:
		void _InOrder(Node* root)
		{
			if (root == nullptr)
				return;

			_InOrder(root->_left);
			cout << root->_key << ":" << root->_value << endl;
			_InOrder(root->_right);
		}
	private:
		Node* _root = nullptr;
	};

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1571306.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

rt-thread的nfs如何实现软硬件对接

rt-thread的nfs如何实现软硬件对接

rt-thread&#xff08;下面简称rtt&#xff09;有一个封装好的的虚拟文件系统&#xff0c;提供了一套通用的io文件接口例如 open,write,read这些&#xff0c;从没看过rtt的代码也没用过&#xff0c;文件系统在刚毕业的时候只是用过fatfs但没去纠结过。今年1月份听同事说只需要打…
阅读更多...
Java学习之面向对象三大特征

Java学习之面向对象三大特征

目录 继承 作用 实现 示例 instanceof 运算符 示例 要点 方法的重写(Override) 三个要点 示例 final关键字 作用 继承和组合 重载和重写的区别 Object类详解 基本特性 补充&#xff1a;IDEA部分快捷键 " "和equals()方法 示例 Super关键字 示例 …
阅读更多...
redis进阶入门主从复制与哨兵集群

redis进阶入门主从复制与哨兵集群

一、主从复制 1.1背景 一般来说&#xff0c;要将 Redis用于工程项目中&#xff0c;只使用一台 Redist是万万不能的&#xff0c;原因如下&#xff1a; 从结构上&#xff0c;单个 Redist服务器会发生单点故障&#xff0c;井且一台服务器需要处理所有的请求负載&#xff0c;压力…
阅读更多...
重读Java设计模式: 适配器模式解析

重读Java设计模式: 适配器模式解析

引言 在软件开发中&#xff0c;经常会遇到不同接口之间的兼容性问题。当需要使用一个已有的类&#xff0c;但其接口与我们所需的不兼容时&#xff0c;我们可以通过适配器模式来解决这一问题。适配器模式是一种结构型设计模式&#xff0c;它允许接口不兼容的类之间进行合作。本…
阅读更多...
使用Python转换图片中的颜色

使用Python转换图片中的颜色

说明&#xff1a;最近在看梵高的画册&#xff0c;我手上的这本画册&#xff08;《文森特梵高》杨建飞 主编&#xff09;书中说&#xff0c;梵高用的颜料里有不耐久的合成颜料&#xff0c;原本的紫色褪成了我们现在所看到的灰蓝色。于是我想&#xff0c;能不能用程序将画中的颜色…
阅读更多...
Javascript 插值搜索-迭代与递归（Interpolation Search）

Javascript 插值搜索-迭代与递归（Interpolation Search）

给定一个由 n 个均匀分布值 arr[] 组成的排序数组&#xff0c;编写一个函数来搜索数组中的特定元素 x。 线性搜索需要 O(n) 时间找到元素&#xff0c;跳转搜索需要 O(? n) 时间&#xff0c;二分搜索需要 O(log n) 时间。 插值搜索是对实例二分搜索的改进&#xff0c;…
阅读更多...
AI绘画：使用ComfyUI结合LCM进行实时绘图：开启AI艺术创作新篇章

AI绘画：使用ComfyUI结合LCM进行实时绘图：开启AI艺术创作新篇章

在数字艺术的世界里&#xff0c;ComfyUI和LCM&#xff08;Latent Contextual Modulation&#xff09;的结合为艺术家和设计师们提供了一个强大的实时绘图工具。LCM是一种先进的技术&#xff0c;它能够实时地将用户的输入和反馈融入到图像生成过程中&#xff0c;从而创造出动态变…
阅读更多...
Web3 革命：揭示区块链技术的全新应用

Web3 革命：揭示区块链技术的全新应用

随着数字化时代的不断发展&#xff0c;区块链技术作为一项颠覆性的创新正在改变着我们的世界。而在这一技术的进步中&#xff0c;Web3正逐渐崭露头角&#xff0c;为区块链技术的应用带来了全新的可能性。本文将探讨Web3革命所揭示的区块链技术全新应用&#xff0c;并展望其未来…
阅读更多...
第1讲——预备知识

第1讲——预备知识

一、视觉SLAM十四讲在讲些啥 SLAM&#xff1a;Simultaneous Localization and Mapping 翻译&#xff1a;同时定位与地图构建 搭载特定传感器的主体&#xff0c;在没有环境先验信息的情况下&#xff0c;于运动过程中建立环境的模型&#xff0c;同时估计自己的运动。 当特定传感…
阅读更多...
构建开源可观测平台

构建开源可观测平台

企业始终面临着确保 IT 基础设施和应用程序全年可用的压力。现代架构&#xff08;容器、混合云、SOA、微服务等&#xff09;的复杂性不断增长&#xff0c;产生大量难以管理的日志。我们需要智能应用程序性能管理 (APM) 和可观察性工具来实现卓越生产并满足可用性和正常运行时间…
阅读更多...
基于SpringBoot+微信小程序的防诈骗平台

基于SpringBoot+微信小程序的防诈骗平台

一、项目背景介绍&#xff1a; 社会背景随着互联网的高速发展&#xff0c;网络和手机的普及率也大大提高&#xff0c;这也衍生出一系列问题&#xff1a;用户信息泄露、不法分子电话诈骗等…现越来越多的老年人甚至年轻人经历过电信诈骗并被骗了大量金额。该产品正是基于这样的社…
阅读更多...
揭秘SCQL：隐私计算的未来之路

揭秘SCQL：隐私计算的未来之路

1.SCQL使用/集成最佳实践 隐语隐私计算中SCQL&#xff08;Secure Collaborative Query Language&#xff09;的设计旨在提供一种便捷且安全的方式来处理多方参与下的隐私敏感数据查询与分析&#xff0c;而无需暴露原始数据给任何一方。以下是基于以上所记录信息的SCQL使用和集…
阅读更多...
Linux文件IO(3):使用文件IO进行文件的打开、关闭、读写、定位等相关操作

Linux文件IO(3):使用文件IO进行文件的打开、关闭、读写、定位等相关操作

目录 1. 文件IO的概念 2. 文件描述符概念 3. 函数介绍 3.1 文件IO-open函数 3.2 文件IO-close函数 3.3 文件IO-read函数 3.4 文件IO-write函数 3.5 文件IO-lseek函数 4. 代码练习 4.1 要求 4.2 具体实现代码 4.3 测试结果 5. 总结 1. 文件IO的概念 posix(可移植操作系统接…
阅读更多...
vulhub中Struts2-008 远程代码执行漏洞复现

vulhub中Struts2-008 远程代码执行漏洞复现

影响版本: 2.1.0 - 2.3.1 原理 > S2-008 涉及多个漏洞&#xff0c;Cookie 拦截器错误配置可造成 OGNL 表达式执行&#xff0c;但是由于大多 Web 容器&#xff08;如 Tomcat&#xff09;对 Cookie 名称都有字符限制&#xff0c;一些关键字符无法使用使得这个点显得比较鸡肋…
阅读更多...
深入了解 Python 中标准排序算法 Timsort

深入了解 Python 中标准排序算法 Timsort

&#x1f349; CSDN 叶庭云&#xff1a;https://yetingyun.blog.csdn.net/ Timsort&#xff1a;一个非常快速的、时间复杂度为 O ( n l o g n ) O (n \ log\ n) O(n log n)、稳健&#xff08;即不改变等值元素间的相对顺序&#xff09;的排序算法&#xff0c;在处理真实世界数…
阅读更多...
ModuleNotFoundError: No module named ‘einops‘解决办法

ModuleNotFoundError: No module named ‘einops‘解决办法

安装对应的库就好 pip install einops -i https://pypi.tuna.tsinghua.edu.cn/simple 拓展——在python中einops模块有什么作用 einops 是一个 Python 库&#xff0c;它提供了一种简洁、易读的方式来操作多维数组&#xff08;通常是 NumPy 数组或 PyTorch 张量&#xff09;。e…
阅读更多...
移动端基础

移动端基础

移动端基础 一.了解二.视口1.视口形式2.视口标签3.viewport设置 三.二倍图1.像素比2.多倍图3.背景缩放及使用&#xff08;background-size&#xff09;4.多倍图切图 四.移动端开发选择1.单独制作2.响应式3.总结 五.移动端技术解决方案1.初始化2.盒子模型3.特殊样式 六.常见布局…
阅读更多...
铸铁平台的平面度

铸铁平台的平面度

铸铁平台的平面度是指平台的表面平整程度&#xff0c;即平台表面与其理论平面之间的最大偏差。平台的平面度通常使用国际标准符号GD&T中的平面度符号&#xff08;ⓨ&#xff09;表示&#xff0c;单位为毫米&#xff08;mm&#xff09;或微米&#xff08;μm&#xff09;。 …
阅读更多...
【数据分析面试】10. 计算平均通勤时间（SQL：timestampdiff() 和datediff()区别）

【数据分析面试】10. 计算平均通勤时间（SQL：timestampdiff() 和datediff()区别）

题目 假设你在Uber工作。rides表包含了关于Uber用户在美国各地的行程信息。 编写一个查询&#xff0c;以获取纽约&#xff08;NY&#xff09;每位通勤者的平均通勤时间&#xff08;以分钟为单位&#xff09;&#xff0c;以及纽约所有通勤者的平均通勤时间&#xff08;以分钟为…
阅读更多...
Codeforces Round 836 (Div. 2) D. Range = √Sum

Codeforces Round 836 (Div. 2) D. Range = √Sum

题目 思路&#xff1a; #include <bits/stdc.h> using namespace std; #define int long long #define pb push_back #define fi first #define se second #define lson p << 1 #define rson p << 1 | 1 const int maxn 1e6 5, inf 1e18, maxm 4e4 5; c…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023