数据结构之二叉树

最新推荐文章于 2024-07-11 15:49:26 发布
最新推荐文章于 2024-07-11 15:49:26 发布
阅读量630 收藏 1
点赞数 10
文章标签： 数据结构 c++ 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34762931/article/details/136114228
版权
本文详细介绍了如何在C++中定义二叉树结构，包括其节点类和二叉树类，以及提供了层序、先序、中序和后序遍历的方法。同时，还展示了如何将二叉树序列化和反序列化的过程。
摘要由CSDN通过智能技术生成

二叉树的定义及其相关算法

//header.h
#pragma once
#include <iostream>
#include <vector>
#include <stack>
#include <queue>
#include <string>

template<typename T>
struct TreeNode
{
	T Value;
	TreeNode* leftChild;
	TreeNode* rightChild;
	TreeNode(const T& value)
		: Value{ value }, leftChild{ nullptr }, rightChild{ nullptr }
	{
		//std::cout << "Creating TreeNode: " << Value << '\n';
	}

	~TreeNode()
	{
		//std::cout << "Destroying TreeNode: " << Value << '\n';
	}
};

template<typename T>
class BinaryTree
{
private:
	TreeNode<T>* root;

public:
	BinaryTree() : root{ nullptr } {}
	BinaryTree& insert(const T& value);
	//层序遍历
	const BinaryTree& hierarchicalTraversal() const;
	//先序遍历序列
	const BinaryTree& preOrderTraversal(std::vector<T>& preOrder) const;
	//中序遍历序列
	const BinaryTree& inOrderTraversal(std::vector<T>& inOrder) const;
	//后序遍历序列
	const BinaryTree& postOrderTraversal(std::vector<T>& postOrder) const;
	//从先序和中序遍历序列构建二叉树
	BinaryTree& buildTreeFromPreAndInOrder(std::vector<T>& preOrder, std::vector<T>& inOrder);
	//从中序和后续遍历序列构建二叉树
	BinaryTree& buildTreeFromInAndPostOrder(std::vector<T>& inOrder, std::vector<T>& postOrder);
	//从先序遍历序列序列化二叉树
	std::string serializeFromPreOrder() const;
	//从中序遍历序列序列化二叉树
	std::string serializeFromInOrder() const;
	//从后序遍历序列序列化二叉树
	std::string serializeFromPostOrder() const;
	//从先序遍历序列反序列化二叉树
	BinaryTree& deserializeFromPreOrder(std::string data);
	//从中序遍历序列反序列化二叉树
	BinaryTree& deserializeFromInOrder(std::string data);
	//从后序遍历序列反序列化二叉树
	BinaryTree& deserializeFromPostOrder(std::string data);
	~BinaryTree();
};

//二叉平凡树插入算法
template<typename T>
BinaryTree<T>& BinaryTree<T>::insert(const T& value)
{
	TreeNode<T>* newNode = new TreeNode<T>{ value };

	if (this->root == nullptr)
	{
		this->root = newNode;
		return *this;
	}

	TreeNode<T>* temp = nullptr;
	bool flag = true;
	std::queue<TreeNode<T>*> que{};
	que.push(this->root);

	while (flag)
	{
		int n = que.size();
		for (int i = 0; i < n; ++i)
		{
			temp = que.front();
			que.pop();

			if (temp->leftChild == nullptr)
			{
				temp->leftChild = newNode;
				flag = false;
				break;
			}
			else
			{
				que.push(temp->leftChild);
			}

			if (temp->rightChild == nullptr)
			{
				temp->rightChild = newNode;
				flag = false;
				break;
			}
			else
			{
				que.push(temp->rightChild);
			}
		}
	}
	return *this;
}

template<typename T>
const BinaryTree<T>& BinaryTree<T>::hierarchicalTraversal() const
{
	if (this->root == nullptr)
	{
		std::cout << "This binary tree is empty!!! Can not hierarchicalTraversal!!!\n";
		return *this;
	}

	std::cout << "HierarchicalTraversal as belows:\n";
	TreeNode<T>* temp = nullptr;
	std::queue<TreeNode<T>*> helper;
	helper.push(this->root);

	while (!helper.empty())
	{
		int n = helper.size();
		//for循环可以清晰地看出是层上的遍历
		for (int i = 0; i < n; ++i)
		{
			temp = helper.front();
			helper.pop();
			std::cout << temp->Value << '\t';

			if (temp->leftChild)
				helper.push(temp->leftChild);
			if (temp->rightChild)
				helper.push(temp->rightChild);
		}
	}
	std::cout << '\n';
	return *this;
}

template<typename T>
const BinaryTree<T>& BinaryTree<T>::preOrderTraversal(std::vector<T>& preOrder) const
{
	if (this->root == nullptr)
	{
		std::cout << "This binary tree is empty!!! Can not preOrderTraversal!!!\n";
		return *this;
	}

	std::cout << "PreOrderTraversal as belows:\n";
	TreeNode<T>* temp = this->root;
	std::stack<TreeNode<T>*> stk{};

	while (temp != nullptr || !stk.empty())
	{
		//这个循环会持续找左孩子节点直到到达底部
		while (temp)
		{
			//入栈的时候先入根节点，再入左孩子节点，所以打印二叉树的前序遍历
			std::cout << temp->Value << '\t';
			preOrder.emplace_back(temp->Value);
			stk.push(temp);
			temp = temp->leftChild;
		}
		//到底部时temp == nullptr，所以不会进行上面的内层循环
		//持续外层循环并弹出栈顶节点直到该节点有右孩子节点为止(遍历完左子树弹出根节点后开始遍历右子树)
		temp = stk.top();
		stk.pop();
		temp = temp->rightChild;
	}
	std::cout << '\n';
	return *this;
}

template<typename T>
const BinaryTree<T>& BinaryTree<T>::inOrderTraversal(std::vector<T>& inOrder) const
{
	if (this->root == nullptr)
	{
		std::cout << "This binary tree is empty!!! Can not inOrderTraversal!!!\n";
		return *this;
	}

	std::cout << "InOrderTraversal as belows:\n";
	TreeNode<T>* temp = this->root;
	std::stack<TreeNode<T>*> stk{};

	while (temp != nullptr || !stk.empty())
	{
		while (temp)
		{
			stk.push(temp);
			temp = temp->leftChild;
		}
		//先弹出左孩子节点，再弹出根节点，所以打印二叉树的中序遍历
		temp = stk.top();
		stk.pop();
		std::cout << temp->Value << '\t';
		inOrder.emplace_back(temp->Value);
		temp = temp->rightChild;
	}
	std::cout << '\n';
	return *this;
}

template<typename T>
const BinaryTree<T>& BinaryTree<T>::postOrderTraversal(std::vector<T>& postOrder) const
{
	if (this->root == nullptr)
	{
		std::cout << "This binary tree is empty!!! Can not postOrderTraversal!!!\n";
		return *this;
	}

	std::cout << "PostOrderTraversal as belows:\n";
	std::stack<TreeNode<T>*> stk;
	TreeNode<T>* temp = this->root;
	TreeNode<T>* prev = nullptr;

	while (temp != nullptr || !stk.empty())
	{
		while (temp != nullptr)
		{
			stk.push(temp);
			temp = temp->leftChild;
		}
		temp = stk.top();
		stk.pop();

		if (temp->rightChild == nullptr || temp->rightChild == prev)
		{
			std::cout << temp->Value << '\t';
			postOrder.emplace_back(temp->Value);
			prev = temp;
			temp = nullptr;
		}
		else
		{
			stk.push(temp);
			temp = temp->rightChild;
		}
	}
	std::cout << '\n';
	return *this;
}

template<typename T>
BinaryTree<T>& BinaryTree<T>::buildTreeFromPreAndInOrder(std::vector<T>& preOrder, std::vector<T>& inOrder)
{
	if (preOrder.size() == 0)
	{
		return *this;
	}

	this->root = new TreeNode<T>{ preOrder[0] };
	std::stack<TreeNode<T>*> stk;
	stk.push(this->root);
	int inOrderIndex = 0;
	int preOrderSize = preOrder.size();
	for (int i = 1; i < preOrderSize; ++i)
	{
		int preOrderVal = preOrder[i];
		TreeNode<T>* node = stk.top();
		if (node->Value != inOrder[inOrderIndex])
		{
			node->leftChild = new TreeNode<T>(preOrderVal);
			stk.push(node->leftChild);
		}
		else
		{
			while (!stk.empty() && stk.top()->Value == inOrder[inOrderIndex])
			{
				node = stk.top();
				stk.pop();
				++inOrderIndex;
			}
			node->rightChild = new TreeNode<T>{ preOrderVal };
			stk.push(node->rightChild);
		}
	}
	return *this;
}

template<typename T>
BinaryTree<T>& BinaryTree<T>::buildTreeFromInAndPostOrder(std::vector<T>& inOrder, std::vector<T>& postOrder)
{
	if (postOrder.size() == 0)
	{
		return *this;
	}

	this->root = new TreeNode<T>{ postOrder[postOrder.size() - 1] };
	std::stack<TreeNode<T>*> stk;
	stk.push(this->root);
	int inOrderIndex = inOrder.size() - 1;
	int postOrderSize = postOrder.size();
	for (int i = postOrderSize - 2; i >= 0; i--)
	{
		int postOrderVal = postOrder[i];
		TreeNode<T>* node = stk.top();
		if (node->Value != inOrder[inOrderIndex])
		{
			node->rightChild = new TreeNode<T>{ postOrderVal };
			stk.push(node->rightChild);
		}
		else
		{
			while (!stk.empty() && stk.top()->Value == inOrder[inOrderIndex])
			{
				node = stk.top();
				stk.pop();
				inOrderIndex--;
			}
			node->leftChild = new TreeNode<T>{ postOrderVal };
			stk.push(node->leftChild);
		}
	}
	return *this;
}

template<typename T>
std::string serializationFromPreOrder(TreeNode<T>* node)
{
	if (!node)
	{
		return "X";
	}

	std::string left = "(" + serializationFromPreOrder(node->leftChild) + ")";
	std::string right = "(" + serializationFromPreOrder(node->rightChild) + ")";
	return std::to_string(node->Value) + left + right;
}

template<typename T>
std::string serializationFromInOrder(TreeNode<T>* node)
{
	if (!node)
	{
		return "X";
	}

	std::string left = "(" + serializationFromInOrder(node->leftChild) + ")";
	std::string right = "(" + serializationFromInOrder(node->rightChild) + ")";
	return left + std::to_string(node->Value) + right;
}

template<typename T>
std::string serializationFromPostOrder(TreeNode<T>* node)
{
	if (!node)
	{
		return "X";
	}

	std::string left = "(" + serializationFromPostOrder(node->leftChild) + ")";
	std::string right = "(" + serializationFromPostOrder(node->rightChild) + ")";
	return left + right + std::to_string(node->Value);
}

template<typename T>
std::string BinaryTree<T>::serializeFromPreOrder() const
{
	std::cout << "Serialize from pre order as belows:\n";
	return serializationFromPreOrder(this->root);
}

template<typename T>
std::string BinaryTree<T>::serializeFromInOrder() const
{
	std::cout << "Serialize from in order as belows:\n";
	return serializationFromInOrder(this->root);
}

template<typename T>
std::string BinaryTree<T>::serializeFromPostOrder() const
{
	std::cout << "Serialize from post order as belows:\n";
	return serializationFromPostOrder(this->root);
}

template<typename T1, typename T2>
int parseInt(const T1& data, T2& ptr)
{
	int x = 0;
	int sign = 1;
	if (!isdigit(data[ptr]))
	{
		sign = -1;
		++ptr;
	}
	while (isdigit(data[ptr]))
	{
		x = x * 10 + data[ptr++] - '0';
	}
	return x * sign;
}

template<typename T1, typename T2>
TreeNode<T2>* parseSubTreeFromPreOrder(const T1& data, T2& ptr)
{
	++ptr;
	TreeNode<T2>* subTree = parseFromPreOrder(data, ptr);
	++ptr;
	return subTree;
}

template<typename T1, typename T2>
TreeNode<T2>* parseFromPreOrder(const T1& data, T2& ptr)
{
	if (data[ptr] == 'X')
	{
		ptr++;
		return nullptr;
	}

	TreeNode<T2>* cur = new TreeNode<T2>{ 0 };
	cur->Value = parseInt(data, ptr);
	cur->leftChild = parseSubTreeFromPreOrder(data, ptr);
	cur->rightChild = parseSubTreeFromPreOrder(data, ptr);

	return cur;
}

template<typename T>
BinaryTree<T>& BinaryTree<T>::deserializeFromPreOrder(std::string data)
{
	int ptr = 0;
	this->root = parseFromPreOrder(data, ptr);
	return *this;
}

template<typename T1, typename T2>
TreeNode<T2>* parseSubTreeFromInOrder(const T1& data, T2& ptr)
{
	++ptr;
	TreeNode<T2>* subTree = parseFromInOrder(data, ptr);
	++ptr;
	return subTree;
}

template<typename T1, typename T2>
TreeNode<T2>* parseFromInOrder(const T1& data, T2& ptr)
{
	if (data[ptr] == 'X')
	{
		ptr++;
		return nullptr;
	}

	TreeNode<T2>* cur = new TreeNode<T2>{ 0 };
	cur->leftChild = parseSubTreeFromInOrder(data, ptr);
	cur->Value = parseInt(data, ptr);
	cur->rightChild = parseSubTreeFromInOrder(data, ptr);

	return cur;
}

template<typename T>
BinaryTree<T>& BinaryTree<T>::deserializeFromInOrder(std::string data)
{
	int ptr = 0;
	this->root = parseFromInOrder(data, ptr);
	return *this;
}

template<typename T1, typename T2>
TreeNode<T2>* parseSubTreeFromPostOrder(const T1& data, T2& ptr)
{
	++ptr;
	TreeNode<T2>* subTree = parseFromPostOrder(data, ptr);
	++ptr;
	return subTree;
}

template<typename T1, typename T2>
TreeNode<T2>* parseFromPostOrder(const T1& data, T2& ptr)
{
	if (data[ptr] == 'X')
	{
		ptr++;
		return nullptr;
	}

	TreeNode<T2>* cur = new TreeNode<T2>{ 0 };
	cur->leftChild = parseSubTreeFromPostOrder(data, ptr);
	cur->rightChild = parseSubTreeFromPostOrder(data, ptr);
	cur->Value = parseInt(data, ptr);

	return cur;
}

template<typename T>
BinaryTree<T>& BinaryTree<T>::deserializeFromPostOrder(std::string data)
{
	int ptr = 0;
	this->root = parseFromPostOrder(data, ptr);
	return *this;
}

template<typename T>
BinaryTree<T>::~BinaryTree()
{
	if (this->root == nullptr)
	{
		std::cout << "This binary tree is empty!!! No need to delete!!!\n";
		return;
	}

	TreeNode<T>* temp = nullptr;
	std::queue<TreeNode<T>*> helper;
	helper.push(this->root);

	while (!helper.empty())
	{
		temp = helper.front();
		helper.pop();
		if (temp->leftChild)
			helper.push(temp->leftChild);
		if (temp->rightChild)
			helper.push(temp->rightChild);

		delete temp;
		temp = nullptr;
	}
}

int BinaryTreeTest()
{
	BinaryTree<int> tree;
	std::vector<int> preOrder;
	std::vector<int> inOrder;
	std::vector<int> postOrder;
	for (int i = 65; i < 91; i++)
	{
		tree.insert(i);
	}
	tree.preOrderTraversal(preOrder);
	tree.inOrderTraversal(inOrder);
	tree.postOrderTraversal(postOrder);

	BinaryTree<int> TreeSerializeFromPreOrder;
	std::string dataFromPreOrder;
	TreeSerializeFromPreOrder.buildTreeFromPreAndInOrder(preOrder, inOrder);
	std::cout << (dataFromPreOrder = TreeSerializeFromPreOrder.serializeFromPreOrder()) << '\n';

	BinaryTree<int> TreeDeserializeFromPreOrder;
	TreeDeserializeFromPreOrder.deserializeFromPreOrder(dataFromPreOrder);
	TreeDeserializeFromPreOrder.hierarchicalTraversal();

	BinaryTree<int> TreeSerializeFromInOrder;
	std::string dataFromInOrder;
	TreeSerializeFromInOrder.buildTreeFromPreAndInOrder(preOrder, inOrder);
	std::cout << (dataFromInOrder = TreeSerializeFromInOrder.serializeFromInOrder()) << '\n';

	BinaryTree<int> TreeDeserializeFromInOrder;
	TreeDeserializeFromInOrder.deserializeFromInOrder(dataFromInOrder);
	TreeDeserializeFromInOrder.hierarchicalTraversal();

	BinaryTree<int> TreeSerializeFromPostOrder;
	std::string dataFromPostOrder;
	TreeSerializeFromPostOrder.buildTreeFromPreAndInOrder(preOrder, inOrder);
	std::cout << (dataFromPostOrder = TreeSerializeFromPostOrder.serializeFromPostOrder()) << '\n';

	BinaryTree<int> TreeDeserializeFromPostOrder;
	TreeDeserializeFromPostOrder.deserializeFromPostOrder(dataFromPostOrder);
	TreeDeserializeFromPostOrder.hierarchicalTraversal();

	return 0;
}


#include "header.h"
int main()
{
	BinaryTreeTest();
	return 0;
}

测试结果：
在这里插入图片描述
参考：
The C++ Programming Language 3rd Edition, Bjarne.Stroustrup
C++ How to Program 9th Edition, Paul Deitel
Starting Out with C++ Early Objects Seventh Edition, Tony Gaddis, Judy Walters, Godfrey Muganda
C++ Templates The Complete Guide SECOND EDITION, David Vandevoorde, Nicolai M. Josuttis, Douglas Gregor
102. 二叉树的层序遍历
144. 二叉树的前序遍历
94. 二叉树的中序遍历
145. 二叉树的后序遍历
105. 从前序与中序遍历序列构造二叉树
106. 从中序与后序遍历序列构造二叉树
LCR 156. 序列化与反序列化二叉树

文祐
关注
  • 10
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
数据结构之二叉树实验
// 在校菜鸟大学生的日常学习博客
09-01 4441
二叉树实验实验目的实验环境实验要求实验内容源代码运行结果 实验目的 通过实验掌握二叉树的基本存储结构； 掌握二叉树的建立与遍历的基本算法，并加以应用； 实验环境 CodeBlocks 实验要求 熟悉c语言的语法知识； 掌握二叉树的链式存储结构—二叉链表的定义、构造、遍历等基本操作； 实验内容 完成二叉树的二叉链表的存储结构的定义、创建、前序遍历、中序遍历、后序遍历、求叶子数和求深度等函数的编写。完成以下函数的编写： (1) 编写一个函数输出结点的值。visit( BiTree T) (2)编写一个函
数据结构之二叉树（JAVA实现）
weixin_38419670的博客
02-22 1904
1. 什么是二叉树 满足以下两个条件的树称之为二叉树： 1. 本质上为有序树； 2. 每个结点的度不能超过2，即结点的度仅能为0，1，2。 2. 二叉树的性质 性质1：二叉树第i层的结点数最多为2^(i-1) (i>=1)。 性质2：深度为k的二叉树最多有2^k - 1个结点。 性质3：在任意一颗二叉树中，若终端结点（叶子结点）的个数为n0，度为2的结点树为n2，则n0=n2+1。 证明：设二叉树中度为1的结点数为n1，结点总数为n，则n = n0 + n1 +n2。同时，度为2的子结
Java数据结构之二叉树
fear_wolf的博客
10-25 2298
二叉树的创建很简单，但是难就难在操作上，我们为了简便，先自己手动创建一个简陋的二叉树的结构，着重介绍二叉树的操作，先创建一棵二叉树。我们有前面的概念可以看出，二叉树定义是递归式的，因此后序基本操作中基本都是按照递归实现的。完全二叉树：完全二叉树是效率很高的数据结构，完全二叉树是从满二叉树中引出来的，对于。的数据结构，它是由n（n >= 0）个有限节点组成的一个具有层次关系的集合，遍历是二叉树上最重要的操作之一，是二叉树进行其他运算的基础。称之为完全二叉树，由此可知，满二叉树是一种特殊的完全二叉树。
数据结构之二叉树(概念)
chuxinchangcun的博客
11-23 1783
传送门点击跳转特殊的树-二叉树2.1概念：满二叉树和完全二叉树满二叉树完全二叉树二叉树的性质习题练习二叉树的存储结构1.顺序存储经典结论：2.链式存储 特殊的树-二叉树 2.1概念： 一棵二叉树是结点的一个有限集合，该集合: 1.或者为空 2.由一个根节点加上两棵别称为左子树和右子树的二叉树组成 注意：二叉树的度不一定为2 如： 空树：度为0 只有一个结点：度为0 有两个结点：度为1 满二叉树和完全二叉树 满二叉树 满二叉树：一个二叉树，如果每一个层的结点数都达到最大值，则这个二叉树就是满二
数据结构之二叉树的创建
顾小豆的博客
02-24 9万+
文章开头首先要感谢一下国嵌嵌入式教育的工作者们。创建二叉树 二叉树不仅比通用树结构简练，而且同时拥有通用树相同的操作。要想创建二叉树，首先就得了解一下二叉树的存储结构。已知二叉树的存储结构分为顺序存储结构和链式存储结构。其中链式存储结构又分为二叉链表和三叉链表。1. 顺序存储结构：按照顺序存储结构的定义，在此约定用一组地址连续的存储单元一次自上而下、自左至右存储完全二叉树上的节点元素，即将完全二叉...
数据结构——二叉树先序、中序、后序及层次四种遍历（C语言版）
热门推荐
正弦定理的博客
12-09 35万+
数据结构——二叉树先序、中序、后序三种遍历二叉树先序、中序、后序三种遍历三、代码展示： 二叉树先序、中序、后序三种遍历 先序遍历：3 2 2 3 8 6 5 4 中序遍历：2 2 3 3 4 5 6 8 后序遍历: 2 3 2 4 5 6 8 3 三种遍历不同之处在，输出数据放在不同之处 三、代码展示： #include<stdio.h> #include<stdlib.h> typedef struct Tree{ int
数据结构之二叉树基本概念
lspdd的博客
02-13 1884
二叉树的基本概念 二叉树（Binary tree）是树形结构的一个重要类型。许多实际问题抽象出来的数据结构往往是二叉树形式，即使是一般的树也能简单地转换为二叉树，而且二叉树的存储结构及其算法都较为简单，因此二叉树显得特别重要。二叉树特点是每个结点最多只能有两棵子树，且有左右之分 来自百度词条 二叉树的基本形态： 1.空的二叉树： 其实就是指向空的指针 2.只有根节点的二叉树： 也就是一个指针指向一个节点，这个节点是根节点 3.只有左子树和右子树： 只有左子树和右子树（又称斜树，其实也就成了链表）：如下图：
数据结构之二叉树（C语言附详细代码）
m0_68210771的博客
07-23 1万+
关于树的简要概念和二叉树的重点内容，以及二叉树的操作代码，前中后序遍历代码以及层次遍历代码
Day6：数据结构之二叉树
weixin_46873777的博客
08-16 3874
二叉树前言树的基本概念1、树的定义2、树的相关术语二叉树的基本概念1、二叉树的定义2、二叉树的性质3、特殊的二叉树二叉树的实现方式二叉树的基本操作头文件1、先序建立二叉树2、先序遍历3、中序遍历4、后序遍历5、先序遍历（广义表）6、二叉树的深度（高度）7、二叉树的结点数8、二叉树的叶结点个数9、度为1的结点个数10、度为2的结点个数11、返回每条叶结点到根结点的路径12、交换左右结点13、双序遍历14、销毁树二叉树的注意事项 目录 目录 顺序表 单链表（不带附加头结点） 双链表（带附加头
数据结构之二叉树.rar
12-05
本资料“数据结构之二叉树.rar”深入探讨了如何使用数组来实现二叉树的各种操作，包括插入、删除以及遍历，采用C++语言进行编程，并体现了面向对象的设计思想。 首先，我们要理解二叉树的基本概念。二叉树是由节点...
数据结构之二叉树-思路清晰纯C
09-12
二叉树的创建 二叉树的层次遍历 二叉树的非递归遍历 线索二叉树的实现 二叉排序树的实现 平衡二叉树的实现 哈夫曼树的实现 内容学习于 ...
Python数据结构之二叉树查、删、修
12-21
Python数据结构之二叉树增、查、删、修 增加 ​ 　一层一层添加数据（层序遍历原则），使用队列对结点进行存储，从左向右增加结点，最终可形成完全二叉树。 def add(self, val): """添加树节点实现完全二叉树""" ...
数据结构第14节 加权图
hummhumm的专栏
07-07 1331
( V ) 是顶点的集合。( E ) 是边的集合，每条边连接 ( V ) 中的一对顶点。( W ) 是一个函数，将每条边映射到一个实数上，即 ( W: E \rightarrow \mathbb{R} )。
D1.排序
2302_79232710的博客
07-07 216
快速排序和归并排序
数据结构——顺序表
最新发布
2301_80373479的博客
07-11 363
是的的。...逻辑上线性结构，也就说是连续的⼀条直线。但是在， 线性表在物理上存储时，通常以的形式存储。顺序表还会封装对数据元素的将顺序表里的不是覆盖原先数据，插入数据的结果造成部分数据后移返回下标。
6、Redis系统-数据结构-03-压缩列表
qq_29434541的博客
07-07 2398
由于压缩列表需要进行空间扩展操作，这就需要重新分配内存，因此连锁更新一旦发生，会导致压缩列表占用的内存空间多次重新分配，直接影响到压缩列表的访问性能。因此，虽然压缩列表紧凑型的内存布局能节省内存开销，但是如果保存的元素数量增加，或元素变大，会导致内存重新分配，最糟糕的是会引发「连锁更新」的问题。因此，虽然压缩列表紧凑型的内存布局能节省内存开销，但是如果保存的元素数量增加，或元素变大，会导致内存重新分配，最糟糕的是会引发「连锁更新」的问题。而当新插入的元素较大时，可能会导致后续元素的。
【数据结构】线性表----栈详解
Skrrapper的博客
07-08 1204
栈（Stack）是一种常见的数据结构，它具有**后进先出（Last In, First Out, LIFO）**的特点。栈的运作类似于物理世界中的叠盘子：最新放上去的盘子最先被拿走，而最底部的盘子最后才能被取出。如果你先拿底下的盘子，那么就有可能出现整个盘子组全部倒塌碎落一地——这也就是所谓的栈出错。栈有着的特点。所以它的出栈和入栈也遵循着这个特点。我们在存取元素的时候，一般是在进行——也就是所谓的盘子顶；而另一端称为，一般就是数据结构的头结点。入栈出栈的顺序只需记住：顺序必须有规律，例如。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值