【数据结构】树 的基本代码

最新推荐文章于 2024-04-06 12:01:41 发布
最新推荐文章于 2024-04-06 12:01:41 发布
阅读量568 收藏
点赞数
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43724601/article/details/102635237
版权

文章目录

1. 树的表示法

  1. 广义表表示法
  2. 双亲表表示法
  3. 左孩子右兄弟表示法
  4. 孩子链表表示法
    本文采用孩子链表表示法

2. 树的基本结构及函数总览

template<class T>
class Tree
{
	T* NA;
	list<int>* HL;
	int root;
	int sizeN, sizeC;
	int maxN;
public:
	Tree(int n = 100) :root(-1), sizeN(0), sizeC(0), maxN(n)
	{
		NA = new T[n];
		HL = new list<int>[n];
	}
	~Tree() { delete[]NA; delete[]HL; }
	int Empty()const { return (sizeN == 0); }
	int Full()const { return (sizeN == maxN); }
	int SizeN() const{ return sizeN; }
	int SizeC() const{ return sizeC; }
	
	int FindNode(const T& node)const; //已知node找下标
	bool FindeNode(T& node, int pos)const; //已知下标返node
	
	bool InsertN(const T& node); //插入节点
	bool InsertC(const T& parent, const T& child); //插入孩子
	
	void ReadTree(const char* filename); //重载输入运算符
	void WriteTree(const char* filename); //重载输出运算符
    
    void BFS(list<T>& L)const; //广度优先遍历
	void DFS(list<T>& L, int t)const; //深度优先遍历（先根遍历）

    template<class T>//在模板函数的声明前要加此句
	friend istream& operator>>(istream& istr, Tree<T>& t);//重载输入运算符
	template<class T>//在模板函数的声明前要加此句
	friend ostream& operator<<(ostream& ostr, const Tree<T>& t);
};

3. 树的基本操作

//已知node找下标
template<class T>
int Tree<T>::FindNode(const T& node)const
{
	for (int i = 0; i < sizeN; i++)
		if (NA[i] == node)
			return i;
	return -1;
}
//已知下标返node
template<class T>
bool Tree<T>:: FindeNode(T& node, int pos)const
{
	if (pos<0||pos >= sizeN)
		return 0;
	node = NA[pos];
	return 1;
}

//插入节点
template<class T>
bool Tree<T>::InsertN(const T& node)
{
	if (sizeN == maxN)
		return 0;
	NA[sizeN] = node;
	sizeN++;
	return 1;
}
//插入孩子
template<class T>
bool Tree<T>::InsertC(const T& parent, const T& child)
{
	int pi = FindNode(parent), cj = FindNode(child);
	if (pi == -1 || cj == -1 || pi == cj)
		return 0;
	HL[pi].insert(HL[pi].end(), cj);
	sizeC++;
	return 1;
}

//重载输入运算符
template <class T>
istream& operator>>(istream& istr, Tree<T>& t)
{
	int i;
	int n;
	char str[50];
	T parent, child;
	istr >> str >> n;
	istr >> str >> parent;
	t.InsertN(parent);
	t.root = t.sizeN - 1;  //reson
	istr >> str;
	for (i = 1; i <n ;++i)
	{
		istr >> child;
		t.InsertN(child);
	}
	istr >> str >> n;
	for (i = 1; i <= n; ++i)
	{
		istr >> parent >> child;
		t.InsertC(parent, child);
	}
	return istr;
}
//重载输出运算符
template <class T>
ostream& operator<<(ostream& ostr, const Tree<T>& t)
{
	for (int i = 0; i < t.sizeN; i++)
	{
		ostr << i << '-' << t.NA[i] << ':';
		list<int>::iterator first = t.HL[i].begin(), last = t.HL[i].end();
		for (; first != last; ++first)
			ostr << '(' << *first << ')' << ' ';
		ostr << endl;
	}
	return ostr;
}

4. 树的遍历

4.1 广度优先遍历
//广度优先遍历
template<class T>
void Tree<T>:: BFS(list<T>& L)const
{
	if (sizeN == 0)
		return;
	int t;
	queue<int> Q;
	Q.push(root);
	list<int>::const_iterator first, last;
	while (Q.empty())
	{
		t = Q.front();
		Q.pop();
		L.push_back(NA[t]);
		first = HL[t].begin();
		last = HL[t].end();
		for (; first != last; first++)
		{
			Q.push(*first);
		}
	}
}
4.2 深度优先遍历（先根遍历）
//深度优先遍历（先根遍历）
template<class T>
void Tree<T>::DFS(list<T>& L,int t)const
{
	if (t<0||t>=sizeN)
		return;
	L.push_back(t);
	list<int>::const_iterator first, last;
	first = HL[t].begin();
	last = HL[t].end();
	for (; first != last; first++)
		DFS(L, *first);
}

5. 基本代码汇总及测试

private部分和友元函数的申明曾出现过问题，现已解决
具体看帖：https://bbs.csdn.net/topics/394772306

#include <iostream>
#include <list>
#include <fstream>
#include <vector>
#include <queue>
#include <stack>
using namespace std;

template<class T>
class Tree
{
//public://
	T* NA;
	list<int>* HL;
	int root;
	int sizeN, sizeC;
	int maxN;
public:
	Tree(int n = 100) :root(-1), sizeN(0), sizeC(0), maxN(n)
	{
		NA = new T[n];
		HL = new list<int>[n];
	}
	~Tree() { delete[]NA; delete[]HL; }
	int Empty()const { return (sizeN == 0); }
	int Full()const { return (sizeN == maxN); }
	int SizeN() const{ return sizeN; }
	int SizeC() const{ return sizeC; }/
	int FindNode(const T& node)const;
	bool FindeNode(T& node, int pos)const;
	
	bool InsertN(const T& node);
	bool InsertC(const T& parent, const T& child);
	
	void ReadTree(const char* filename);
	void WriteTree(const char* filename);

	void BFS(list<T>& L)const;
	void DFS(list<T>& L, int t)const;
	
	template<class T>在模板函数的声明前加此句
	friend istream& operator>>(istream& istr, Tree<T>& t);//重载输入运算符
	template<class T>///在模板函数的声明前加此句
	friend ostream& operator<<(ostream& ostr, const Tree<T>& t);
};

//已知node找下标
template<class T>
int Tree<T>::FindNode(const T& node)const
{
	for (int i = 0; i < sizeN; i++)
		if (NA[i] == node)
			return i;
	return -1;
}
//已知下标返node
template<class T>
bool Tree<T>:: FindeNode(T& node, int pos)const
{
	if (pos<0||pos >= sizeN)
		return 0;
	node = NA[pos];
	return 1;
}

//插入节点
template<class T>
bool Tree<T>::InsertN(const T& node)
{
	if (sizeN == maxN)
		return 0;
	NA[sizeN] = node;
	sizeN++;
	return 1;
}
//插入孩子
template<class T>
bool Tree<T>::InsertC(const T& parent, const T& child)
{
	int pi = FindNode(parent), cj = FindNode(child);
	if (pi == -1 || cj == -1 || pi == cj)
		return 0;
	HL[pi].insert(HL[pi].end(), cj);
	sizeC++;
	return 1;
}

//重载输入运算符
template <class T>
istream& operator>>(istream& istr, Tree<T>& t)
{
	int i;
	int n;
	char str[50];
	T parent, child;
	istr >> str >> n;
	istr >> str >> parent;
	t.InsertN(parent);
	t.root = t.sizeN - 1;  //reson
	istr >> str;
	for (i = 1; i <n ;++i)
	{
		istr >> child;
		t.InsertN(child);
	}
	istr >> str >> n;
	for (i = 1; i <= n; ++i)
	{
		istr >> parent >> child;
		t.InsertC(parent, child);
	}
	return istr;
}

//重载输出运算符
template <class T>
ostream& operator<<(ostream& ostr, const Tree<T>& t)
{
	for (int i = 0; i < t.sizeN; i++)///
	{
		ostr << i << '-' << t.NA[i] << ':';
		list<int>::iterator first = t.HL[i].begin(), last = t.HL[i].end();
		for (; first != last; ++first)
			ostr << '(' << *first << ')' << ' ';
		ostr << endl;
	}
	return ostr;
}

//广度优先遍历
template<class T>
void Tree<T>:: BFS(list<T>& L)const
{
	if (sizeN == 0)
		return;
	int t;
	queue<int> Q;
	Q.push(root);
	list<int>::const_iterator first, last;
	while (!Q.empty())
	{
		t = Q.front();
		Q.pop();
		L.push_back(NA[t]);
		first = HL[t].begin();
		last = HL[t].end();
		for (; first != last; first++)
		{
			Q.push(*first);
		}
	}
}

//深度优先遍历（先序遍历）
template<class T>
void Tree<T>::DFS(list<T>& L,int t)const
{
	if (t<0||t>=sizeN)
		return;
	L.push_back(NA[t]);
	list<int>::const_iterator first, last;
	first = HL[t].begin();
	last = HL[t].end();
	for (; first != last; first++)
		DFS(L, *first);
}

template<class T>
void Tree<T>::ReadTree(const char* filename)
{
	ifstream fin;
	fin.open(filename, ios::in || ios::_Nocreate);
	if (!fin)
	{
		cout << "1cannot open " << filename << endl;
		exit(1);
	}
	fin >> *this;
	
}

template<class T>
void Tree<T>::WriteTree(const char* filename)
{
	ofstream fout;
	fout.open(filename, ios::out);
	if (!fout)
	{
		cout << "2cannot open " << filename << endl;		
		exit(1);
	}
	fout << *this;
}

template <class iterator>
void Display(iterator first,iterator last)
{
	for (; first != last; first++)
		cout << *first << "   ";
}

int main()
{
	Tree<char> a(20);
	
	/法一：
	/*ifstream fin;
	fin.open("D:\\VS代码\\treein.txt", ios::in || ios::_Nocreate);
	if (!fin)
	{
		cout << "1cannot open D:\\VS代码\\treein.txt. \n " << endl;
		exit(1);
	}
	fin >> a;
	ofstream fout;
	fout.open("D:\\VS代码\\treeout.txt", ios::out);
	if (!fout)
	{
		cout << "2cannot open D:\\VS代码\\treeout.txt. \n";
		exit(1);
	}
	fout << a;*/
	//法二;
	/*
	cin >> a;
	cout << a;//在屏幕上确认是否为预想结果
	return 0;
	*/
	///法三：
	a.ReadTree("D:\\VS代码\\treein.txt");
	a.WriteTree("D:\\VS代码\\treeout.txt");
	
	list<char> L;
	
	a.DFS(L,0);
	cout << "DFS called" << endl;
	Display(L.begin(), L.end());
	cout << endl;
	L.clear();
	
	a.BFS(L);
	cout << "BFS called" << endl;
	Display(L.begin(), L.end());
	cout << endl;
	L.clear();

}

6. 八皇后

自己写八皇后出现过一些问题，已解决，详细看帖：https://bbs.csdn.net/topics/394782997

#include<iostream>
#include<conio.h>//getch
#include <stdlib.h>//exit
using namespace std;

//八皇后
void display(const int* Y, int n)
{
	int k;
	int x, y;
	static int total = 1;
	for (y = 0; y < n; y++)
	{
		if (y % n == 0)
			cout << total++ << endl;
		for (x = 0; x< n; x++)
		{
			if (x== Y[y]) //不要再把=当==!
				cout << " @ ";
			else
				cout << " # ";
		}
		cout << endl;
	}
	cout << "Press any key to see" << endl;
	k=_getch(); //若想去除: 警告C6031 返回值被忽略 : “_getch”, 则如大佬所言，把 getch返回值赋给一个变量
}
void Queen(int y)
{
	int x;
	static int A[22], B[22], C[22], Y[8];
	if (y < 0 || y>8)
	{
		cout << "y ellage";
		exit(1);
	}
	if (y == 8)
	{
		display(Y,8);
		return;
	}
	for (x = 0; x < 8; x++)
	{
		if (!A[x + 7] && !B[x + y + 7] && !C[x - y + 7])
		{
			Y[y] = x;
			A[x + 7] = B[x + y + 7] = C[x - y + 7] = 1;
			Queen(y + 1);
			A[x + 7] = B[x + y + 7] = C[x - y + 7] = 0;
		}
	}
}

int main()
{
	Queen(0);
	return 0;
}
@宁兰
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构---树（用C++代码实现）
suoyudong的博客
04-01 5537
树 基本概念 分类: 1)空树. n=0时称为空树 2)非空树. 特点: (1)有且只有一个特定的称为根的结点. (2)其余结点分为m个互不相交的有限集,并且称为根的子树. 树的深度:树中结点的最大层次称为树的深度或高度. 结点的度:结点拥有的子树数称为结点的度. 二叉树:由一个根结点和两个互不相交的子树组成. 结点的数=总分支数+1 特点: (1)每个结点最多有两颗子树 (2)左子树和...
数据结构--树（c 代码部分）（王道书、考研适用）
m0_73918713的博客
08-02 250
【代码】数据结构--树（c 代码部分）
数据结构04--树（知识点+代码版）
weixin_62737397的博客
04-06 1035
一. 树的定义和基本术语一. 树的定义和基本术语。
数据结构-二叉树的代码实现（详解）
weixin_73142957的博客
07-11 3321
内容：二叉树的前、中，后序遍历，层序遍历，二叉树节点个数，叶子节点个数，二叉树高度，第k层节点的个数，查找某个节点，二叉树销毁，判断是否为完全二叉树
数据结构——哈夫曼树的实现以及编码（C语言实现）
热门推荐
欢迎来到Gorit的博客
11-29 5万+
1、问题描述       利用哈夫曼编码进行通信可以大大提高信道利用率，缩短信息传输时间，降低传输成本。构造哈夫曼树时，首先将由n个字 符形成的n个叶子结点存放到数组HuffNode的前n个分量中，然后根据哈夫曼方法的基本思想，不断将两个较小的子树合并为一个 较大的子树，每次构成的新子树的根结点顺序放到HuffNode数组中的前n个分量的后面。        通俗的来讲，哈弗曼树就是一种广...
数据结构实验代码3.doc
12-02
"数据结构实验代码3" 数据结构实验代码3是一个关于赫夫曼编码的实现，通过对二叉树的操作来解决应用问题。下面是该实验代码的知识点总结： 1.赫夫曼编码的基本概念：赫夫曼编码是一种 Variable-Length Prefix Code...
java数据结构之树基本概念解析及代码示例
08-28
Java 数据结构之树基本概念解析及代码示例 树是一种抽象数据类型（ADT）或是实作这种抽象数据类型的数据结构，用来模拟具有树状结构性质的数据集合。它是由n（n＞0）个有限节点组成一个具有层次关系的集合。把 它...
数据结构之伸展树详解
09-04
在实现伸展树时，通常会使用C++或其他编程语言的数据结构来表示节点，并定义旋转操作的函数。代码中会包含旋转的具体实现，如在给定的描述中提到的`Rotate(node *x, int d)`函数，用于执行左旋或右旋。 相比于传统...
常用的数据结构树算法代码总结
01-01
数据结构树算法是计算机科学中的一种基本算法，广泛应用于各个领域。该算法的代码实现是非常重要的。本文档总结了常用的树算法代码，包括递归和非递归遍历算法、深度优先搜索（DFS）和广度优先搜索（BFS）的实现，...
《数据结构》经典算法代码.zip
12-30
这些代码不仅能帮助你理解数据结构的基本概念，而且能让你明白如何在实际情况中应用这些数据结构。 笔记：详细且系统的笔记，涵盖了数据结构的各个方面，从基础概念到复杂的数据结构如堆、B树等。这些笔记有助于你...
决策树代码。机器学习实战代码
02-28
机器学习实战代码，里面的test.py是运行文件，treePlotter.py是画决策树的代码，decisionTree是构造决策树的代码。直接运行test.py就可以得出结果
树的实现代码
07-07
包含了树的实现，以及树的前序遍历、后序遍历和层序遍历
生成树的代码
05-24
给初学者的，如果在数据结构方面存在问题，不防来看看。
数据结构【树】相关代码（数据结构笔试、复测、Leecode、牛客）
weixin_44177594的博客
04-20 794
图基础介绍树基础二叉树的前序遍历二叉树的中序遍历二叉树的后序遍历二叉树的层次遍历按之字形顺序打印二叉树二叉树的最大深度二叉树中和为某一值的路径(一)二叉搜索树与双向链表对称的二叉树合并二叉树二叉树的镜像判断是不是二叉搜索树判断是不是完全二叉树判断是不是平衡二叉树二叉搜索树的最近公共祖先在二叉树中找到两个节点的最近公共祖先进阶 基础介绍 树 二叉树主要性质： 非空二叉树上叶子结点数等于双分支结点数加1。 二叉树的第i层上最多有2i−1(i≥1)2^{i-1}(i≥1)2i−1(i≥1)个结点。 高度（或深度
树的代码，慢慢汇总
qq_43016111的博客
12-30 1011
文章目录1.二叉树深度 [必会]2.该树是否为平衡二叉树 [必会]3.权路径长度WPL [必会]4.层次遍历二叉树 [必会]5.二叉树从根节点到叶结点的最长路径上的所有结点6.给定两个整数，输出两者所在层数间隔数（非递归函数实现）7.用先序遍历二叉树的每一个结点的深度并输出8.哈夫曼树的叶子结点的个数（递归实现）9.找树中的key值点10.往二叉排序树插入新节点 [掌握]11.求二叉平衡树的平衡因子 [掌握]12.二叉树中的所有结点个数13.二叉树所有叶子结点个数14.两个二叉树是否相似15.二叉树
树代码（递归）
ShawnWang1994的博客
07-22 799
#include<stdio.h> #include<stdlib.h> #include<malloc.h> typedef struct Btreenode{ char data; struct Btreenode *lchlid; struct Btreenode *rchlid; }BiNode,*BiTree; //递归方法创建树 BiTree...
数据结构：B树、B+树数据结构及操作代码实现
cyq6239075的博客
04-29 2748
B树的定义： B树（B-tree）是一种树状数据结构，它能够存储数据、对其进行排序并允许以O(log n)的时间复杂度运行进行查找、顺序读取、插入和删除的数据结构。 B树结构如下： 其中，m是B树的阶，m>=3，par是指向父节点指针。 K1,K2...Kn是从小到大顺序排列的关键字。n是变化的： （1），对于非树根节点：m/2-1 （2），对于根节点：1
数据结构之通用树结构的实现
顾小豆的博客
02-17 8488
之前我们讲了树的定义和操作，这节我们讲一下如何实现这些操作。既然要考虑如何实现，那就得说说树的存储结构。大家都知道树是非线性数据结构，显然我们无法用数组来表示树的逻辑结构。那我们应该怎么办呢？通过什么来表示呢？其实可以设计结构体数组对结点间的关系进行表述。如下图所示：从上图发现，将根结点的双亲定义为-1，表示其没有双亲；将根的孩子结点的双亲定义为0，表示其双亲是根结点；将根结点孩子1的孩子结点的双...
数据结构B树完整代码
最新发布
06-06
这里我将简要介绍B树的基本概念和常见的C++实现框架，但请注意完整的代码会涉及到大量的细节和模板元编程，这里不会列出全部代码。 B树的主要特点： 1. **范围查询**: B树的每个节点可以包含多个关键字，这使得它...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值