数据结构(二叉树,堆)

节点的度：一个节点含有的子树的个数称为该节点的度；如上图：A的为6
叶节点或终端节点：度为0的节点称为叶节点；如上图：B、C、H、I...等节点为叶节点
非终端节点或分支节点：度不为0的节点；如上图：D、E、F、G...等节点为分支节点
双亲节点或父节点：若一个节点含有子节点，则这个节点称为其子节点的父节点；如上图：A是B的父节点
孩子节点或子节点：一个节点含有的子树的根节点称为该节点的子节点；如上图：B是A的孩子节点
兄弟节点：具有相同父节点的节点互称为兄弟节点；如上图：B、C是兄弟节点
树的度：一棵树中，最大的节点的度称为树的度；如上图：树的度为6
节点的层次：从根开始定义起，根为第1层，根的子节点为第2层，以此类推；
树的高度或深度：树中节点的最大层次；如上图：树的高度为4
堂兄弟节点：双亲在同一层的节点互为堂兄弟；如上图：H、I互为兄弟节点
节点的祖先：从根到该节点所经分支上的所有节点；如上图：A是所有节点的祖先
子孙：以某节点为根的子树中任一节点都称为该节点的子孙。如上图：所有节点都是A的子孙
森林：由m（m>0）棵互不相交的树的集合称为森林

孩子兄弟表示法

保存值域，也要保存结点和结点之间的关系

typedef int DataType;
struct Node
{
struct Node* _firstChild1; // 第一个孩子结点
struct Node* _pNextBrother; // 指向其下一个兄弟结点
DataType _data; // 结点中的数据域
};

二叉树概念及结构

一棵二叉树是结点的一个有限集合，该集合:
1. 或者为空
2. 由一个根节点加上两棵别称为左子树和右子树的二叉树组成

1. 二叉树不存在度大于2的结点
2. 二叉树的子树有左右之分，次序不能颠倒，因此二叉树是有序树

特殊的二叉树

1. 满二叉树：一个二叉树，如果每一个层的结点数都达到最大值，则这个二叉树就是满二叉树。也就是说，如果一个二叉树的层数为K，且结点总数是2^k-1 ，则它就是满二叉树。
2. 完全二叉树：完全二叉树是效率很高的数据结构，完全二叉树是由满二叉树而引出来的。对于深度为K的，有n个结点的二叉树，当且仅当其每一个结点都与深度为K的满二叉树中编号从1至n的结点一一对应时称之为完全二叉树。要注意的是满二叉树是一种特殊的完全二叉树。前h-1层满的,最后一层从左到右必须是连续的

二叉树的性质

1. 若规定根节点的层数为1，则一棵非空二叉树的第i层上最多有2^(i-1) 个结点.
2. 若规定根节点的层数为1，则深度为h的二叉树的最大结点数是2^h-1 .

F(h)=2^0+2^1+2^2+2^3+....+2^(h-1)

F(h)=2^h-1

假设这棵树N个节点 F(h)=2^h-1=N h=log2(N+1)

3. 对任何一棵二叉树, 如果度为0其叶结点个数为n0 , 度为2的分支结点个数为n2 ,则有

n0＝n2 ＋1

4. 若规定根节点的层数为1，具有n个结点的满二叉树的深度，h=log2(n+1) (ps:log2(n+1) 是log以2为底，n+1为对数)
5. 对于具有n个结点的完全二叉树，如果按照从上至下从左至右的数组顺序对所有节点从0开始编号，则对于序号为i的结点有：

1. 若i>0，i位置节点的双亲序号：(i-1)/2；i=0，i为根节点编号，无双亲节点
2. 若2i+1<n，左孩子序号：2i+1，2i+1>=n否则无左孩子
3. 若2i+2<n，右孩子序号：2i+2，2i+2>=n否则无右孩子

二叉树的存储结构

顺序存储(完全二叉树,满二叉树)

顺序结构存储就是使用数组来存储，一般使用数组只适合表示完全二叉树
二叉树顺序存储在物理上是一个数组，在逻辑上是一颗二叉树。

链式存储

typedef int BTDataType;
// 二叉链
struct BinaryTreeNode
{

	struct BinTreeNode* _pLeft; // 指向当前节点左孩子
	struct BinTreeNode* _pRight; // 指向当前节点右孩子
	BTDataType _data; // 当前节点值域
};
// 三叉链
struct BinaryTreeNode
{
	struct BinTreeNode* _pParent; // 指向当前节点的双亲
	struct BinTreeNode* _pLeft; // 指向当前节点左孩子
	struct BinTreeNode* _pRight; // 指向当前节点右孩子
	BTDataType _data; // 当前节点值域
};

二叉树链式结构

typedef int BTDataType;
typedef struct BinaryTreeNode
{
	BTDataType _data;
	struct BinaryTreeNode* _left;
	struct BinaryTreeNode* _right;
}BTNode;
BTNode* CreatBinaryTree()
{
	BTNode* node1 = BuyNode(1);
	BTNode* node2 = BuyNode(2);
	BTNode* node3 = BuyNode(3);
	BTNode* node4 = BuyNode(4);
	BTNode* node5 = BuyNode(5);
	BTNode* node6 = BuyNode(6);
	node1->_left = node2;
	node1->_right = node4;
	node2->_left = node3;
	node4->_left = node5;
	node4->_right = node6;
	return node1;
}

二叉树的遍历

前序、中序以及后序遍历

1. 前序遍历(Preorder Traversal 亦称先序遍历)——访问根结点的操作发生在遍历其左右子树之前。
2. 中序遍历(Inorder Traversal)——访问根结点的操作发生在遍历其左右子树之中（间）。
3. 后序遍历(Postorder Traversal)——访问根结点的操作发生在遍历其左右子树之后。

前序：根左子树右子树

中序：左子树根右子树

后序：左子树右子树根

前,中序确定数的形状

前序遍历

void PreOrder(BTNode* root)
{
	if (root == NULL)
	{
		printf("N ");
		return;
	}
	printf("%d ", root->data);
	PreOrder(root->left);
	PreOrder(root->right);
}

中序遍历

void InOrder(BTNode* root)
{
	if (root == NULL)
	{
		printf("N ");
		return;
	}
	InOrder(root->left);
	printf("%d ", root->data);
	InOrder(root->right);
}

后序遍历

void LaOrder(BTNode* root)
{
	if (root == NULL)
	{
		printf("N ");
		return;
	}
	LaOrder(root->left);
	LaOrder(root->right);
	printf("%d ", root->data);
}

前序和中序构建树

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    TreeNode* PreInTree(vector<int>& preorder, vector<int>& inorder,int& prei,int inbegin,int inend)
    {
        if(inbegin>inend) return nullptr;
        TreeNode* root=new TreeNode(preorder[prei]);
        int rooti=inbegin;
        while(rooti<=inend)
        {
            if(preorder[prei]==inorder[rooti]) break;
            else rooti++;
        }
        prei++;
        root->left=PreInTree(preorder,inorder,prei,inbegin,rooti-1);
        root->right=PreInTree(preorder,inorder,prei,rooti+1,inend);
        return root;
    }
    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
       int i=0;
       return PreInTree(preorder,inorder,i,0,inorder.size()-1);
    }
};

中序和后序构建树

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    TreeNode* InPosTree(vector<int>& inorder, vector<int>& postorder,int& posi,int inbegin,int inend)
    {
        if(inbegin>inend) return nullptr;
        TreeNode* root=new TreeNode(postorder[posi]);
        
        int rooti=inbegin;
        while(rooti<=inend)
        {
            if(postorder[posi]==inorder[rooti])
            break;
            else 
            rooti++;
        }
        posi--;
        
        root->right=InPosTree(inorder,postorder,posi,rooti+1,inend);
        root->left=InPosTree(inorder,postorder,posi,inbegin,rooti-1);

        return root;
    }
    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
       int size = postorder.size();
        int posi = size - 1; // 初始化 posi 为后序遍历的最后一个索引
        return InPosTree(inorder, postorder, posi, 0, size - 1);
    }
};

不知道你又没注意到前中序和后中序构建左右子树的顺序不同？，前中序先构建左子树，而后中序先构建右子树，我的理解是：前中序先构建左子树时因为前序是(根左子树右子树)，而后序是(左子树右子树根)，前序左子树会出现新的根，故先遍历左子树找到所有的根，故后中序同理

posi 必须在递归过程中动态更新，以确保每次访问正确的后序遍历节点。

如果您在调用 InPosTree 时将 posi 直接设为 size - 1，而不进行递减，您将无法正确构建树，因为您无法访问到后续的根节点。

节点个数

void TreeSize(BTNode* root, int* psize)
{
	if (root == NULL)
		return 0;
	else
		++(*psize);

	TreeSize(root->left, psize);
	TreeSize(root->right, psize);
}

	int size = 0;
	TreeSize(root, &size);
	printf("TreeSize:%d\n", size);

空:0个

不为空:左子树+右子树+1

int TreeSize(BTNode* root)
{
	return root == NULL ? 0 :
		TreeSize(root->left) + TreeSize(root->right) + 1;
}

叶子节点

int TreeLeafSize(BTNode* root)
{
	if (root == NULL)
		return 0;

	if (root->left == NULL && root->right == NULL)
		return 1;

	return TreeLeafSize(root->left)
		+ TreeLeafSize(root->right);
}

二叉树高度

空:0

不为空: 左子树高度右子树高度大的那个+1

int TreeHeight(BTNode* root)
{
	if (root == NULL)
		return 0;

	int leftHeight = TreeHeight(root->left);
	int rightHeight = TreeHeight(root->right);

	return leftHeight > rightHeight ?
		leftHeight + 1 : rightHeight + 1;
}

// 有效率问题  重复计算
int TreeHeight(BTNode* root)
{
	if (root == NULL)
		return 0;

	return TreeHeight(root->left) > TreeHeight(root->right) ?
		TreeHeight(root->left) + 1 : TreeHeight(root->right) + 1;
}

第k层节点个数

空：0

非空且k==1 :返回1

非空且k>1 :左子树的第k-1层 + 右子树的第k-1层

int TreeLevelKSize(BTNode* root, int k)
{
	if (root == NULL)
		return 0;

	if (k == 1)
		return 1;

	// 子问题
	return TreeLevelKSize(root->left, k - 1)
		+ TreeLevelKSize(root->right, k - 1);
}

查找值为x的节点

BTNode* TreeFind(BTNode* root, BTDataType x)
{
	if (root == NULL)
		return NULL;

	if (root->data == x)
		return root;

	BTNode* ret1 = TreeFind(root->left, x);
	if (ret1)
		return ret1;

	BTNode* ret2 = TreeFind(root->right, x);
	if (ret2)
		return ret2;

	return NULL;
}

前序遍历的数组"ABD##E#H##CF##G##"构建二叉树

二叉树销毁

void TreeDestory(BTNode* root)
{
	if (root == NULL)
		return;

	TreeDestory(root->left);
	TreeDestory(root->right);
	free(root);
}

层序遍历 --- 上一层带下一层

从所在二叉树的根节点出发，首先访问第一层的树根节点，然后从左到右访问第2层上的节点，接着是第三层的节点，以此类推，自上而下，自左至右逐层访问树的结点的过程

void TreeLevelOrder(BTNode* root)
{
	Queue q;
	QueueInit(&q);
	if (root)
		QueuePush(&q, root);

	while (!QueueEmpty(&q))
	{
		BTNode* front = QueueFront(&q);
		QueuePop(&q);//删除的是队列的节点

		printf("%d ", front->data);

		if(front->left)
			QueuePush(&q, front->left);

		if (front->right)
			QueuePush(&q, front->right);
	}

	QueueDestroy(&q);
}

判断二叉树是否是完全二叉树

bool TreeComplete(BTNode* root)
{
	Queue q;
	QueueInit(&q);
	if (root)
		QueuePush(&q, root);

	while (!QueueEmpty(&q))
	{
		BTNode* front = QueueFront(&q);
		QueuePop(&q);

		// 遇到第一个空，就可以开始判断，如果队列中还有非空，就不是完全二叉树
		if (front == NULL)
		{
			break;
		}

		QueuePush(&q, front->left);
		QueuePush(&q, front->right);
	}

	while (!QueueEmpty(&q))
	{
		BTNode* front = QueueFront(&q);
		QueuePop(&q);

		// 如果有非空，就不是完全二叉树
		if (front)
		{
			QueueDestroy(&q);
			return false;
		}
	}

	QueueDestroy(&q);
	return true;
}

二叉搜索树

• 若它的左⼦树不为空，则左⼦树上所有结点的值都⼩于等于根结点的值

• 若它的右⼦树不为空，则右⼦树上所有结点的值都⼤于等于根结点的值

• 它的左右⼦树也分别为⼆叉搜索树

最优情况下，⼆叉搜索树为完全⼆叉树(或者接近完全⼆叉树)，其⾼度为：O(log2 N)
最差情况下，⼆叉搜索树退化为单⽀树(或者类似单⽀)，其⾼度为：O(N/2)
所以综合⽽⾔⼆叉搜索树增删查改时间复杂度为：O(N)

⼆分查找也可以实现O(logN) 级别的查找效率，但是⼆分查找有两⼤缺陷：
1. 需要存储在⽀持下标随机访问的结构中，并且有序。
2. 插⼊和删除数据效率很低，因为存储在下标随机访问的结构中，插⼊和删除数据⼀般需要挪动数据。

二叉搜索树的插入

插⼊的具体过程如下：
1. 树为空，则直接新增结点，赋值给root指针
2. 树不空，按⼆叉搜索树性质，插⼊值⽐当前结点⼤往右⾛，插⼊值⽐当前结点⼩往左⾛，找到空位置，插⼊新结点。
3. 如果⽀持插⼊相等的值，插⼊值跟当前结点相等的值可以往右⾛，也可以往左⾛，找到空位置，插⼊新结点。（要注意的是要保持逻辑⼀致性，插⼊相等的值不要⼀会往右⾛，⼀会往左⾛）

⼆叉搜索树的查找

1. 从根开始⽐较，查找x，x⽐根的值⼤则往右边⾛查找，x⽐根值⼩则往左边⾛查找。
2. 最多查找⾼度次，⾛到到空，还没找到，这个值不存在。
3. 如果不⽀持插⼊相等的值，找到x即可返回
4. 如果⽀持插⼊相等的值，意味着有多个x存在，⼀般要求查找中序的第⼀个x。如下图，查找3，要找到1的右孩⼦的那个3返回

⼆叉搜索树的删除

⾸先查找元素是否在⼆叉搜索树中，如果不存在，则返回false。
如果查找元素存在则分以下四种情况分别处理：（假设要删除的结点为N）
1. 要删除结点N左右孩⼦均为空
2. 要删除的结点N左孩⼦位空，右孩⼦结点不为空
3. 要删除的结点N右孩⼦位空，左孩⼦结点不为空
4. 要删除的结点N左右孩⼦结点均不为空
对应以上四种情况的解决⽅案：
1. 把N结点的⽗亲对应孩⼦指针指向空，直接删除N结点（情况1可以当成2或者3处理，效果是⼀样的）
2. 把N结点的⽗亲对应孩⼦指针指向N的右孩⼦，直接删除N结点
3. 把N结点的⽗亲对应孩⼦指针指向N的左孩⼦，直接删除N结点
4. ⽆法直接删除N结点，因为N的两个孩⼦⽆处安放，只能⽤替换法删除。找N左⼦树的值最⼤结点R(最右结点)或者N右⼦树的值最⼩结点R(最左结点)替代N，因为这两个结点中任意⼀个，放到N的位置，都满⾜⼆叉搜索树的规则。替代N的意思就是N和R的两个结点的值交换，转⽽变成删除R结点，R结点符合情况2或情况3，可以直接删除。

template<class K, class V>
	struct BSTNode
	{
		K _key;
		V _value;

		BSTNode<K, V>* _left;
		BSTNode<K, V>* _right;

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

	// Binary Search Tree
	// Key/value
	template<class K, class V>
	class BSTree
	{
		//typedef BSTNode<K> Node;
		using Node = BSTNode<K, V>;
	public:
		// 强制生成构造
		BSTree() = default;

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

		BSTree& operator=(BSTree tmp)
		{
			swap(_root, tmp._root);
			return *this;
		}

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

		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
				{
					// 删除
					// 左为空
					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;

					}
					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* replaceParent = cur;
						Node* replace = cur->_right;
						while (replace->_left)
						{
							replaceParent = replace;
							replace = replace->_left;
						}

						cur->_key = replace->_key;

						if (replaceParent->_left == replace)
							replaceParent->_left = replace->_right;
						else
							replaceParent->_right = replace->_right;

						delete replace;
					}

					return true;
				}
			}

			return false;
		}

		void InOrder()
		{
			_InOrder(_root);
			cout << endl;
		}
	private:
		void _InOrder(Node* root)
		{
			if (root == nullptr)
			{
				return;
			}

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

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

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

		Node* Copy(Node* root)
		{
			if (root == nullptr)
				return nullptr;

			Node* newRoot = new Node(root->_key, root->_value);
			newRoot->_left = Copy(root->_left);
			newRoot->_right = Copy(root->_right);
			return newRoot;
		}
	private:
		Node* _root = nullptr;
	};
}

namespace key
{
	template<class K>
	struct BSTNode
	{
		K _key;
		BSTNode<K>* _left;
		BSTNode<K>* _right;

		BSTNode(const K& key)
			:_key(key)
			, _left(nullptr)
			, _right(nullptr)
		{}
	};

	// Binary Search Tree
	// Key
	template<class K>
	class BSTree
	{
		//typedef BSTNode<K> Node;
		using Node = BSTNode<K>;
	public:

		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 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 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
				{
					// 删除
					// 左为空
					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;

					}
					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* replaceParent = cur;
						Node* replace = cur->_right;
						while (replace->_left)
						{
							replaceParent = replace;
							replace = replace->_left;
						}

						cur->_key = replace->_key;

						if (replaceParent->_left == replace)
							replaceParent->_left = replace->_right;
						else
							replaceParent->_right = replace->_right;

						delete replace;
					}

					return true;
				}
			}

			return false;
		}

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

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

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

	private:
		Node* _root = nullptr;
	};

二叉树c++实现刷题

606.根据二叉树创建字符串

to_string(转化为字符串)

102.二叉树的层序遍历

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> vv;//二维数组
        queue<TreeNode*> ret; // 存放节点的队列
        int levelsize=0;
        if (root) {//二叉树不为空
            ret.push(root);
            levelsize = 1;
        }
        while (ret.size()) {//出一层
            vector<int> v;//每层的数组
            while (levelsize--) {
                TreeNode* r = ret.front();
                ret.pop();
                v.push_back(r->val);
                if (r->left)
                    ret.push(r->left);
                if(r->right)
                    ret.push(r->right);
            }
            levelsize=ret.size();

            vv.push_back(v);
        }
        return vv;
    }
};

107.二叉树的层序遍历||

将二叉搜索树转换为排序的双向链表

/*
// Definition for a Node.
class Node {
public:
    int val;
    Node* left;
    Node* right;

    Node() {}

    Node(int _val) {
        val = _val;
        left = NULL;
        right = NULL;
    }

    Node(int _val, Node* _left, Node* _right) {
        val = _val;
        left = _left;
        right = _right;
    }
};
*/
class Solution {
public:
    void LRTree(Node* cur,Node*& prv)
    {

        if(cur==nullptr) return;
        LRTree(cur->left,prv);//中序遍历
        
        cur->left=prv;
        if(prv) prv->right=cur;
        prv=cur;

        LRTree(cur->right,prv);
    }
    Node* treeToDoublyList(Node* root) {
        if(root==nullptr) return nullptr;
        Node* prv=nullptr;
        LRTree(root,prv);
        Node* head=root;
        while(head->left)
        {
            head=head->left;
        }
        prv->right=head;//头和尾的处理
        head->left=prv;
        return head;
    }
};

二叉树的最近公共祖先

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    bool IsInTree(TreeNode* root,TreeNode* x)
    {
        if(root==nullptr) return false;
        
        return root==x||IsInTree(root->left,x)||IsInTree(root->right,x);

    }
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        if(root==nullptr) return nullptr;//空树
        if(root==p||root==q) return root;//p或q为根节点
        bool pInLeft,pInRight,qInLeft,qInRight;//判断左右树
        pInLeft=IsInTree(root->left,p);
        pInRight=!pInLeft;

        qInLeft=IsInTree(root->left,q);
        qInRight=!qInLeft;

        if((pInLeft&&qInRight)||(pInRight&&qInLeft)) return root;
        if(pInLeft&&qInLeft) return lowestCommonAncestor(root->left,p,q);
        if(pInRight&&qInRight) return lowestCommonAncestor(root->right,p,q);
        return NULL;
    }
};

class Solution {
public:
	bool GetPath(TreeNode* root, TreeNode* x, stack<TreeNode*>& path)
	{
		if (root == nullptr)
			return false;
		// 前序遍历的思路，找x结点的路径
		// 遇到root结点先push⼊栈，因为root就算不是x，但是root可能是根->x路径中⼀个分
		⽀结点
			path.push(root);
		if (root == x)
			return true;
		if (GetPath(root->left, x, path))
			return true;
		if (GetPath(root->right, x, path))
			return true;
		// 如果左右⼦树都没有x，那么说明上⾯⼊栈的root不是根->x路径中⼀个分⽀结点
		// 所以要pop出栈，回退，继续去其他分⽀路径进⾏查找
		path.pop();
		return false;
	}
	TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
		stack<TreeNode*> pPath, qPath;
		GetPath(root, p, pPath);
		GetPath(root, q, qPath);
		// 模拟链表相交，两个路径找交点
		// ⻓的先⾛差距步，再⼀起⾛找交点
		while (pPath.size() != qPath.size())
		{
			if (pPath.size() > qPath.size())
				pPath.pop();
			else
				qPath.pop();
		}
		while (pPath.top() != qPath.top())
		{
			pPath.pop();
			qPath.pop();
		}
		return pPath.top();
	}
};

堆(适用于完全二叉树,满二叉树)

大堆:

a.完全二叉树

b.任何一个父亲>=孩子

小堆:

a.完全二叉树

b.任何一个父亲<=孩子

堆的性质：
堆中某个节点的值总是不大于或不小于其父节点的值；
堆总是一棵完全二叉树。

堆的实现

把它的所有元素按完全二叉树的顺序存储方式存储在一个一维数组中

堆的创建

给出一个数组，这个数组逻辑上可以看做一颗完全二叉树，但是还不是一个堆

1. 建堆
升序：建大堆
降序：建小堆
2. 利用堆删除思想来进行排序

堆向下调整算法

从根节点开始的向下调整算法可以把它调整成一个小堆。向下调整算法有一个前提：

左右子树必须是一个堆，才能调整

int array[] = {27,15,19,18,28,34,65,49,25,37}; o(logN)

//AdjustDown(php->a, php->size, 0);
void AdjustDown(HPDataType* a, int n, int parent)
{
	int child = (parent + 1) / 2;
	while (child < n)
	{
		if (child+1<n&&a[child + 1] < a[child])
		{
			++child;
		 }
		if (a[child] < a[parent])
		{
			swap(&a[child], &a[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}

堆的插入---向上调整

先插入一个10到数组的尾上，再进行向上调整算法，直到满足堆。

void AdjustUp(HPDataType* a, int child)
{
	int parent = (child - 1) / 2;
	//while(parent>=0)  当child=0时,parent=(0-1)/2=0,但程序能跑通
	while (child > 0)
	{
		if (a[child] < a[parent])
		{
			swap(&a[child], &a[parent]);
			child = parent;
			parent = (child - 1) / 2;
		}
		else
		{
			break;
		}
	}
}//小堆

堆的删除

删除堆是删除堆顶的数据，将堆顶的数据跟最后一个数据一换，然后删除数组最后一个数据，再进行向下调整算法 (小堆时需要保证左右子树均为堆)

//AdjustDown(php->a, php->size, 0);
void AdjustDown(HPDataType* a, int n, int parent)
{
	int child = (parent + 1) / 2;
	while (child < n)
	{
		if (child+1<n&&a[child + 1] < a[child])
		{
			++child;
		 }
		if (a[child] < a[parent])
		{
			swap(&a[child], &a[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}

建堆

**向上调整时间复杂度 o(N*logN)**

//int a[] = { 6,95,56,4,57,555 };
for(int i = 1; i < n; i++)
{
	AdjustUp(a, i);//约等于插入数据，向上排序
 }
void AdjustUp(HPDataType* a, int child)
{
	int parent = (child - 1) / 2;
	//while(parent>=0)  当child=0时,parent=(0-1)/2=0,但程序能跑通
	while (child > 0)
	{
		if (a[child] < a[parent])
		{
			swap(&a[child], &a[parent]);
			child = parent;
			parent = (child - 1) / 2;
		}
		else
		{
			break;
		}
	}
}

向下调整 ---- 先确保调整数左右均为堆时间复杂度o(N)

for (int i = (n - 1 - 1) / 2; i >= 0; i--)
{
	AdjustDown(a, n, i);
}
//AdjustDown(php->a, php->size, 0);
void AdjustDown(HPDataType* a, int n, int parent)
{
	int child = (parent + 1) / 2;
	while (child < n)
	{
		if (child+1<n&&a[child + 1] < a[child])
		{
			++child;
		 }
		if (a[child] < a[parent])
		{
			swap(&a[child], &a[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}

从5开始向下调整，最后调整到根节点时，左右均为堆

升序，降序排序 **堆排序时间复杂度:o(N*logN)**

升序，建大堆

降序，建小堆

void HeapSort(int* a, int n)
{
	for (int i = 1; i < n; i++)
	{
		AdjustUp(a, i);//降序，建小堆
	}
	int end = n - 1;
	while (end > 0)
	{
		Swap(&a[0], &a[end]);
		AdjustDown(a, end, 0);
		--end;
	}
}

void HeapSort(int* a, int n)
{
    //建堆
	for (int i = (n - 1 - 1) / 2; i >= 0; i--)
    {
	    AdjustDown(a, n, i);
    }
    //排序   o(N*logN)
	int end = n - 1;
	while (end > 0)
	{
		Swap(&a[0], &a[end]);
		AdjustDown(a, end, 0);
		--end;
	}
}

Top-k

求数据结合中前K个最大的元素或者最小的元素，一般情况下数据量都比较大。

如果数据量非常大，排序就不太可取(可能数据都不能一下子全部加载到内存中)
1. 用数据集合中前K个元素来建堆 o(K)
前k个最大的元素，则建小堆
前k个最小的元素，则建大堆
2. 用剩余的N-K个元素依次与堆顶元素来比较，不满足则替换堆顶元素覆盖根位置，向下调整 o(logK*(N-K))
将剩余N-K个元素依次与堆顶元素比完之后，堆中剩余的K个元素就是所求的前K个最小或者最大的元素。

合计:o(N)

// 建K个数的小堆
	for (int i = (k-1-1)/2; i>=0 ; i--)
	{
		AdjustDown(kminheap, k, i);
	}

	// 读取剩下的N-K个数
	int x = 0;
	while (fscanf(fout, "%d", &x) > 0)
	{
		if (x > kminheap[0])
		{
			kminheap[0] = x;
			AdjustDown(kminheap, k, 0);
		}
	}

	printf("最大前%d个数：", k);
	for (int i = 0; i < k; i++)
	{
		printf("%d ", kminheap[i]);
	}
	printf("\n");
}

数据结构(二叉树,堆)

孩子兄弟表示法

二叉树概念及结构

特殊的二叉树

二叉树的性质

二叉树的存储结构

顺序存储(完全二叉树,满二叉树)

链式存储

二叉树链式结构

二叉树的遍历

前序、中序以及后序遍历

前,中序确定数的形状

前序遍历

中序遍历

后序遍历

前序和中序构建树

中序和后序构建树

节点个数

叶子节点

二叉树高度

第k层节点个数

查找值为x的节点

前序遍历的数组"ABD##E#H##CF##G##"构建二叉树

二叉树销毁

层序遍历 --- 上一层带下一层

判断二叉树是否是完全二叉树

二叉搜索树

二叉搜索树的插入

⼆叉搜索树的查找

⼆叉搜索树的删除

二叉树c++实现刷题

606.根据二叉树创建字符串

102.二叉树的层序遍历

107.二叉树的层序遍历||

将二叉搜索树转换为排序的双向链表

二叉树的最近公共祖先

堆(适用于完全二叉树,满二叉树)

堆的实现

堆的创建

堆向下调整算法

堆的插入---向上调整

堆的删除

建堆

向上调整 时间复杂度 o(N*logN)

向下调整 ---- 先确保调整数左右均为堆 时间复杂度o(N)

升序，降序排序 堆排序 时间复杂度:o(N*logN)

Top-k

猜你喜欢

**向上调整时间复杂度 o(N*logN)**

向下调整 ---- 先确保调整数左右均为堆时间复杂度o(N)

升序，降序排序 **堆排序时间复杂度:o(N*logN)**