数据结构实验8-二叉树遍历及应用
二叉树的基本概念：
树的定义：
树（Tree）是n（n>=0）个结点的有限集，当n=0时称为空树，在任意一颗非空树中：
（1） 有且仅有一个特定的称为根（root）的结点；
（2）当n>1时，其余结点可分为m（m>0）个互不相交的有限集T1,T2，......,Tm,其中每一个集合本身又是一棵树，并且称为根的子树（SubTree）;
树节点的分类：
结点拥有的子树数称为结点的度（Degree），度为0的结点称为叶结点（Leaf）或终端结点；度不为0的结点称为非终端结点或分支结点。除根节点外，分支结点也成为内部节点。树的度是由树内各节点的度的最大值决定的。
二叉树的定义：
二叉树（Binary Tree）是n（n>=0）个结点的有限集合，该集合或者空集（称为空二叉树），或者由一个根节点和两颗互不相交的，分别称为根节点的左子树和右子树的二叉树组成。
// 二叉树的最大度为2；
特点：（1）每个结点最多有两棵子树；
（2）左子树和右子树是有顺序的；
（3）即使树中某结点只有一颗子树，也要区分左右；
二叉树的性质：
1.在二叉树的第i层上至多有2的i-1次幂个结点（i>=1）
例：第3层：2的3-1次幂，有4个结点；
2.深度为k的二叉树至多有2的k次幂 - 1个结点（k>=1）
例：上图为满二叉树，深度为4，至多有2的4次幂 - 1个结点，有15个结点；
3.对任何一颗二叉树，如果终端结点数为n0，度为2的结点数为n2则n0=n2+1;（终端结点指的就是叶子结点）；
例：上图中，终端结点数为8，度为2的结点数为7，所以n0=n2+1成立，即8=7+1；
例：上图中有15个结点，向下取整15的对数，所以结果为4；
（5）如果对于一棵有n个结点的完全二叉树的结点按层序编号：
如果i=1,结点无双亲；结果i>1,则双亲是[i/2]
如果2i > n,则结点i无孩子；否则其左孩子为2i；
如果2i + 1 > n，则结点i无右孩子；否则右孩子为2i + 1；
A. DS二叉树——二叉树之数组存储
题目描述
二叉树可以采用数组的方法进行存储，把数组中的数据依次自上而下,自左至右存储到二叉树结点中，一般二叉树与完全二叉树对比，比完全二叉树缺少的结点就在数组中用0来表示。，如下图所示
从上图可以看出，右边的是一颗普通的二叉树，当它与左边的完全二叉树对比，发现它比完全二叉树少了第5号结点，所以在数组中用0表示，同样它还少了完全二叉树中的第10、11号结点，所以在数组中也用0表示。
结点存储的数据均为非负整数
输入
第一行输入一个整数t，表示有t个二叉树
第二行起，每行输入一个数组，先输入数组长度，再输入数组内数据，每个数据之间用空格隔开，输入的数据都是非负整数
连续输入t行
输出
每行输出一个示例的先序遍历结果，每个结点之间用空格隔开
输入样例1 <-复制
3
3 1 2 3
5 1 2 3 0 4
13 1 2 3 4 0 5 6 7 8 0 0 9 10
输出样例1
1 2 3
1 2 4 3
1 2 4 7 8 3 5 9 10 6
提示
注意从数组位置和二叉树深度、结点位置进行关联，或者父子结点在数组中的位置存在某种管理，例如i, i+1, i/2, i+1/2........或者2i, 2i+1.......仔细观察哦
我的思路：
首先就是顺序输入，new很多的新数组出来，然后一个个存进去，过后按照先序遍历的方法，将其输出，然后就是看到有等于0的，就进行舍弃
#include
#include
using namespace std;
int t;
const int N = 100;
//先序遍历递归方法
void dfs(int i,int *a,int len)
{
if (i < len && a[i] != 0)//为零就不显示了
{
cout << a[i] << " ";
dfs(2 * i + 1, a, len);//左子树
dfs(2 * i + 2, a, len);//右子树
//这是完全二叉树的性质，就是左右子树为父节点*2+1或+2
}
}
int main()
{
cin >> t;//t个二叉树
while (t--)
{
int len;
cin >> len;//二叉树长度
int* a = new int[len];
for (int i = 0; i < len; i++)
{
cin >> a[i];//分别输入二叉树数值
}
//准备进行前序遍历，使用递归的方法
dfs(0, a, len);
cout << endl;
delete[]a;
}
return 0;
} B. DS二叉树——二叉树之父子结点
题目描述
给定一颗二叉树的逻辑结构如下图，（先序遍历的结果，空树用字符‘0’表示，例AB0C00D00）建立该二叉树的二叉链式存储结构。
编写程序输出该树的所有叶子结点和它们的父亲结点
输入
第一行输入一个整数t，表示有t个二叉树
第二行起，按照题目表示的输入方法，输入每个二叉树的先序遍历，连续输入t行
输出
第一行按先序遍历，输出第1个示例的叶子节点
第二行输出第1个示例中与叶子相对应的父亲节点
以此类推输出其它示例的结果
输入样例1 <-复制
3
AB0C00D00
AB00C00
ABCD0000EF000
输出样例1
C D
B A
B C
A A
D F
C E
大致思路：
先对于题目所给样例进行模拟发现
圈出来的部分是叶子节点，就是终端节点，而他们的父节点不管是否出现过，都需要再输出一次（图一圈错了，应该是圈c的，sorry）
#include
#include
#include
using namespace std;
class btnode//节点类
{
public:
char data;//里面存入的数据
btnode* lchild;//左指针
btnode* rchild;//右指针
btnode() :lchild(NULL), rchild(NULL) {}//初始设置为NULL
~btnode() {}//析构
};
class bitree//二叉树类
{
btnode* root;//定义根节点
int pos;//pos记录次数
string strtree;//整个字符串输入进来
char father[20];//子叶节点的父节点
int pf;
btnode* createbitree()//建树
{
btnode* T;//设置一个节点
char ch;
ch = strtree[pos++];//字符串输入进来
if (ch == '0')
T = NULL;//判断是否为空
else
{
T = new btnode();//建立新的节点
T->data = ch;//字符存入节点中
T->lchild = createbitree();//递归建树，先左后右
T->rchild = createbitree();
}
return T;//返回T
}
void show(btnode* t, char f)//叶子结点&父亲结点查找
{
if (t)
{
if (t->lchild == NULL && t->rchild == NULL)//为叶子结点
{
cout << t->data << " ";
father[pf++] = f;//存入父节点的数据
}
show(t->lchild, t->data);//t->lchild的父亲结点为t->data
show(t->rchild, t->data);
}
}
public:
bitree() {};
~bitree() {};
void createbitree(string treearray)
{
pos = 0;
strtree.assign(treearray);//
root = createbitree();
}
void show()
{
pos = 0; pf = 0;
show(root, root->data);//输出叶子结点
cout << endl;
int len = strlen(father);
for (int i = 0; i < len; i++)
cout << father[i] << " ";//输出父节点
cout << endl;
}
};
int main()
{
int t;
cin >> t;
while (t--)
{
string tree;
bitree T;
cin >> tree;
T.createbitree(tree);
T.show();
}
return 0;
} C. DS二叉树--左叶子数量
题目描述
计算一颗二叉树包含的叶子结点数量。
左叶子是指它的左右孩子为空，而且它是父亲的左孩子
提示：可以用三叉链表法，也可以用现有算法对两层结点进行判断
建树方法采用“先序遍历+空树用0表示”的方法（常规表示法）
输入
第一行输入一个整数t，表示有t个测试数据
第二行起输入二叉树先序遍历的结果，空树用字符‘0’表示，输入t行
输出
逐行输出每个二叉树的包含的左叶子数量
3
AB0C00D00
AB00C00
ABCD0000EF000
1
2
#include
using namespace std;
int LeafNum = 0;//左子叶数
typedef struct BiTNode
{
char data;
struct BiTNode* lchild, * rchild;
} BiTNode;
typedef struct BiTree
{
BiTNode* root;
} BiTree;
void CreateTree(BiTNode*& p)
{
char c;
cin >> c;
if (c != '0')
{
p = new BiTNode;
p->data = c;
CreateTree(p->lchild);
CreateTree(p->rchild);//常规建树
}
else
p = NULL;
}
void PreOrder(BiTNode* p)
{
if (p)
{
if (p->lchild)
{
if (!p->lchild->lchild && !p->lchild->rchild)
LeafNum++;
}
PreOrder(p->lchild);
PreOrder(p->rchild);
}
}
int main(void)
{
int t;
cin >> t;
while (t--)
{
BiTree myTree;
CreateTree(myTree.root);
PreOrder(myTree.root);
cout << LeafNum << endl;
LeafNum = 0;
}
return 0;
}
D. DS二叉树--叶子数量
题目描述
计算一颗二叉树包含的叶子结点数量。
提示：叶子是指它的左右孩子为空。
建树方法采用“先序遍历+空树用0表示”的方法，即给定一颗二叉树的先序遍历的结果为AB0C00D00，其中空节点用字符‘0’表示。则该树的逻辑结构如下图。
输入
第一行输入一个整数t，表示有t个测试数据
第二行起输入二叉树先序遍历的结果，空树用字符‘0’表示，输入t行
输出
逐行输出每个二叉树的包含的叶子数量
输入样例1 <-复制
3
AB0C00D00
AB00C00
ABC00D00E00
输出样例1
2
2
3
#include
using namespace std;
class BiNode{
char data;
BiNode *lChild;
BiNode *rChild;
public:
BiNode():lChild(NULL),rChild(NULL){}
BiNode(char e):data(e),lChild(NULL),rChild(NULL){}
~BiNode(){delete lChild;delete rChild;}
friend class BiTree;
};
class BiTree{
BiNode *root;
int leafNum;
void CreateTree(BiNode *&t);
void PreOrder(BiNode *t);
public:
BiTree():root(NULL),leafNum(0){};
void CreateTree();
void PreOrder();
};
void BiTree::CreateTree(BiNode *&t) {
char c;
cin>>c;
if(c!='0')
{
t = new BiNode(c);
CreateTree(t->lChild);
CreateTree(t->rChild);
}
else
t = NULL;
}
void BiTree::CreateTree() {
CreateTree(root);
}
void BiTree::PreOrder(BiNode *t) {
if(t)
{
if(!t->lChild && !t->rChild)
leafNum++;
PreOrder(t->lChild);
PreOrder(t->rChild);
}
}
void BiTree::PreOrder() {
PreOrder(root);
cout<>t;
while (t--)
{
BiTree myTree;
myTree.CreateTree();
myTree.PreOrder();
}
return 0;
}
E. DS二叉树—二叉树构建与遍历（不含框架）
题目描述
给定一颗二叉树的逻辑结构如下图，（先序遍历的结果，空树用字符‘#’表示，例AB#C##D##），建立该二叉树的二叉链式存储结构，并输出该二叉树的先序遍历、中序遍历和后序遍历结果。
输入
第一行输入一个整数t，表示有t个二叉树
第二行起输入每个二叉树的先序遍历结果，空树用字符‘#’表示，连续输入t行。
输出
输出每个二叉树的先序遍历、中序遍历和后序遍历结果。
输入样例1 <-复制
2
AB#C##D##
AB##C##
输出样例1
ABCD
BCAD
CBDA
ABC
BAC
BCA
F. DS二叉树--层次遍历
- 注意CreateTree传引用！！！又被卡在这个问题上了。。。
- 层次遍历的方法是利用队列，先放入根节点，之后每每弹出一个元素就放入它的左右孩子节点，如果左右孩子为NULL则不放入，直到队列为空，即BFS的思路。
输入
第一行输入一个整数t，表示有t个测试数据
第二行起输入二叉树先序遍历的结果，空树用字符‘0’表示，输入t行
输出
逐行输出每个二叉树的层次遍历结果
#include
#include
using namespace std;
class BiTNode
{
public:
char data;
BiTNode *lchild, *rchild;
BiTNode(){}
~BiTNode(){}
};
class BiTree
{
public:
BiTNode *root;
BiTree(){}
~BiTree(){}
void CreateTree();
void CreateTree(BiTNode *&p);
void LevelOrder();
void LevelOrder(BiTNode *p);
};
void BiTree::CreateTree()
{
CreateTree(root);
}
void BiTree::CreateTree(BiTNode *&p)
{
char ch;
cin>>ch;
if(ch!='0')
{
p = new BiTNode;
p->data = ch;
CreateTree(p->lchild);
CreateTree(p->rchild);
}
else
p = NULL;
}
void BiTree::LevelOrder()
{
LevelOrder(root);
}
void BiTree::LevelOrder(BiTNode *p)
{
queue tq;
tq.push(p);
while(!tq.empty())
{
p = tq.front();
tq.pop();
cout<data;
if(p->lchild)
tq.push(p->lchild);
if(p->rchild)
tq.push(p->rchild);
}
cout<>t;
while(t--)
{
BiTree myTree;
myTree.CreateTree();
myTree.LevelOrder();
}
}