数据结构与算法--二叉树（二）

最新推荐文章于 2023-05-04 01:29:17 发布

opera92

最新推荐文章于 2023-05-04 01:29:17 发布

阅读量460

点赞数

分类专栏：数据结构与算法文章标签：数据结构

本文链接：https://blog.csdn.net/opera95/article/details/51216991

版权

数据结构与算法专栏收录该内容

9 篇文章 1 订阅

订阅专栏

======================================================

二叉链表.c

//2
//第二种表示方法三叉链表
//三叉链表
typedef struct TriTNode
{
int data;
//左右孩子指针
struct TriTNode *lchild, *rchild;
struct TriTNode *parent;
}TriTNode, *TriTree;

//双亲链表
#define MAX_TREE_SIZE 100
typedef struct BPTNode
{
int data;
int parentPosition; //指向双亲的指针 //数组下标
char LRTag; //左右孩子标志域
}BPTNode;

typedef struct BPTree
{
BPTNode nodes[100]; //因为节点之间是分散的，需要把节点存储到数组中
int num_node; //节点数目
int root; //根结点的位置 //注意此域存储的是父亲节点在数组的下标
}BPTree;

//用这个数据结构能表达出一颗树。。。能，怎么表达？不能why

void main()
{
BPTree myTree; //

myTree.root = 0; //数组的0号位置是根结点
myTree.nodes[0].data = 'A';

//B
myTree.nodes[1].data = 'B';
myTree.nodes[1].parentPosition = 0;
myTree.nodes[1].LRTag = 1;

//C
myTree.nodes[2].data = 'C';
myTree.nodes[2].parentPosition = 0;
myTree.nodes[2].LRTag = 2;

system("pause");
}

void main11()
{
BiTNode nodeA, nodeB, nodeC, nodeD, nodeE;

nodeA.lchild = NULL;
nodeA.rchild = NULL;
nodeA.data = 0;
memset(&nodeA, 0, sizeof(BiTNode));
memset(&nodeB, 0, sizeof(BiTNode));
memset(&nodeC, 0, sizeof(BiTNode));
memset(&nodeD, 0, sizeof(BiTNode));
memset(&nodeE, 0, sizeof(BiTNode));

nodeA.data = 1;
nodeA.lchild = &nodeB;
nodeA.rchild = &nodeC;
nodeB.lchild = &nodeD;
nodeC.lchild = &nodeE;

printf("hello...\n");
system("pause");
return ;
}

============================================================

树的操作.c

#define _CRT_SECURE_NO_WARNINGS
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
//1
typedef struct BiTNode
{
int data;
struct BiTNode *lchild, *rchild;
}BiTNode;

typedef struct BiTNode * BiTree;

//先序遍历
void preOrder(BiTNode *T)
{
if (T == NULL)
{
return ;
}
printf("%d ", T->data); //

if (T->lchild != NULL)
{
preOrder(T->lchild);
}

if (T->rchild != NULL)
{
preOrder(T->rchild);
}
}
void InOrder(BiTNode *T)
{
if (T == NULL)
{
return ;
}

if (T->lchild != NULL)
{
InOrder(T->lchild);
}

printf("%d ", T->data); //

if (T->rchild != NULL)
{
InOrder(T->rchild);
}
}
void PostOrder(BiTNode *T)
{
if (T == NULL)
{
return ;
}
if (T->lchild != NULL)
{
PostOrder(T->lchild);
}

if (T->rchild != NULL)
{
PostOrder(T->rchild);
}
printf("%d ", T->data); //
}

/*
1
2 3
4 5
*/
//求树的叶子结点的个数
int sum = 0;
void coutLeafNum(BiTNode *T)
{
if (T == NULL)
{
return ;
}
if (T->lchild == NULL && T->rchild ==NULL)
{
sum ++;
}
coutLeafNum(T->lchild); //求左子树的叶子结点个数

coutLeafNum(T->rchild); //求右子树叶子结点个数
}

//1 递归函数遇上全局变量 ===>函数参数
//2 //遍历的本质强化
//访问树的路径是相同的,是不过是计算叶子结点的时机不同....
void coutLeafNum2(BiTNode *T, int *sum)
{
if (T == NULL)
{
return ;
}
if (T->lchild == NULL && T->rchild ==NULL)
{
//*sum++;
//*sum = *sum +1;
(*sum )++ ; //++后置 ++ 先*p 然后sum++
//1 p++

//1 是让实参++ 而不是让地址++
}

coutLeafNum2(T->lchild, sum); //求左子树的叶子结点个数

coutLeafNum2(T->rchild, sum); //求右子树叶子结点个数
}
void coutLeafNum3(BiTNode *T, int *sum)
{
if (T == NULL)
{
return ;
}

coutLeafNum3(T->lchild, sum); //求左子树的叶子结点个数
coutLeafNum3(T->rchild, sum); //求右子树叶子结点个数

if (T->lchild == NULL && T->rchild ==NULL)
{
(*sum )++ ; //计算叶子结点
}
}

//求树的高度
int Depth(BiTNode *T)
{
int depthval = 0;
int depthLeft = 0, depthRight = 0;

if (T == NULL)
{
return 0;
}

depthLeft = Depth(T->lchild); //求左子树的高度
depthRight = Depth(T->rchild); //求右子树的高度

//1 + 谁大要谁
depthval = 1 + ( (depthLeft>depthRight) ? depthLeft :depthRight );
return depthval;
}

//copy二叉树
BiTNode* CopyTree(BiTNode *T)
{
BiTNode *newlptr = NULL;
BiTNode *newRptr = NULL;
BiTNode *newNode = NULL;

if (T == NULL)
{
return NULL;
}

newlptr = CopyTree(T->lchild);
newRptr = CopyTree(T->rchild);

//new结点
newNode = (BiTNode *)malloc(sizeof(BiTNode)) ; //
if (newNode == NULL)
{
return NULL;
}

newNode->data = T->data; //从旧树中copy数据
newNode->lchild = newlptr; //新的左子树
newNode->rchild = newRptr; //新的右子树
return newNode;
}
void main()
{
BiTNode nodeA, nodeB, nodeC, nodeD, nodeE;

nodeA.lchild = NULL;
nodeA.rchild = NULL;
nodeA.data = 0;
memset(&nodeA, 0, sizeof(BiTNode));
memset(&nodeB, 0, sizeof(BiTNode));
memset(&nodeC, 0, sizeof(BiTNode));
memset(&nodeD, 0, sizeof(BiTNode));
memset(&nodeE, 0, sizeof(BiTNode));

nodeA.data = 1;
nodeB.data = 2;
nodeC.data = 3;
nodeD.data = 4;
nodeE.data = 5;

nodeA.lchild = &nodeB;
nodeA.rchild = &nodeC;
nodeB.lchild = &nodeD;
nodeC.lchild = &nodeE;

//拷贝二叉树
{
BiTNode *newTree = NULL;
newTree = CopyTree(&nodeA);
printf("\n中序遍历新树:");
InOrder(newTree);
}

{
//求树的高度
int depth = Depth(&nodeA);
printf("depth:%d \n", depth);
}

//计算树的叶子结点
{
int mysum = 0;
coutLeafNum(&nodeA);
printf("sum:%d \n", sum);

coutLeafNum2(&nodeA, &mysum);
printf("mysum:%d \n", mysum);

mysum = 0;
coutLeafNum3(&nodeA, &mysum);
printf("mysum:%d \n", mysum);

}

//printf("\n先序遍历树: ");
//preOrder(&nodeA);

printf("\n中序遍历树: ");
InOrder(&nodeA);

//printf("\n后序遍历树: ");
//PostOrder(&nodeA);

system("pause");
}

=========================================================

中序递归.c

#include <iostream>
using namespace std;

#include "stack"

//1
typedef struct BiTNode
{
int data;
struct BiTNode *lchild, *rchild;
}BiTNode;

typedef struct BiTNode * BiTree;

//递归中序遍历
void InOrder(BiTNode *T)
{
if (T == NULL)
{
return ;
}

if (T->lchild != NULL)
{
InOrder(T->lchild);
}

printf("%d ", T->data); //

if (T->rchild != NULL)
{
InOrder(T->rchild);
}
}
BiTNode * GoFarLeft(BiTNode *T, stack<BiTNode *> &s)
{
if (T ==NULL)
{
return NULL;
}
while (T->lchild != NULL) //一直往左走 ,找到中序遍历的起点
{
s.push(T);
T = T->lchild; //让指针下移
}
return T; //
}
void MyInOrder(BiTNode *T)
{
stack<BiTNode *> s; //
BiTNode *t = GoFarLeft(T, s); //一直往左走找到中序遍历的起点

while (t != NULL)
{
printf("%d ", t->data);

//若结点有右子树,重复步骤1
if (t->rchild != NULL)
{
t = GoFarLeft(t->rchild, s);
}
//若结点没有右子树看栈是否为空
else if ( !s.empty() )
{
t = s.top(); //把栈顶弹出
s.pop();
}
else
{
t = NULL;
}
}
}

void main()
{
BiTNode nodeA, nodeB, nodeC, nodeD, nodeE;
nodeA.lchild = NULL;
nodeA.rchild = NULL;
nodeA.data = 0;
memset(&nodeA, 0, sizeof(BiTNode));
memset(&nodeB, 0, sizeof(BiTNode));
memset(&nodeC, 0, sizeof(BiTNode));
memset(&nodeD, 0, sizeof(BiTNode));
memset(&nodeE, 0, sizeof(BiTNode));

nodeA.data = 1;
nodeB.data = 2;
nodeC.data = 3;
nodeD.data = 4;
nodeE.data = 5;

nodeA.lchild = &nodeB;
nodeA.rchild = &nodeC;
nodeB.lchild = &nodeD;
nodeC.lchild = &nodeE;

printf("\n中序遍历递归算法");
InOrder(&nodeA);

printf("\n中序遍历非递归算法");
MyInOrder(&nodeA);

cout<<"hello..."<<endl;
system("pause");
return ;
}

====================================================

树的线索化.c

#define _CRT_SECURE_NO_WARNINGS
#include "string.h"
#include "stdio.h"
#include "stdlib.h"

/* Link==0表示指向左右孩子指针, */
/* Thread==1表示指向前驱或后继的线索 */
#define Thread 1
#define Link 0

typedef struct BiThrNode /* 二叉线索存储结点结构 */
{
char data; /* 结点数据 */
struct BiThrNode *lchild, *rchild; /* 左右孩子指针 */
int LTag;
int RTag; /* 左右标志 */
} BiThrNode, *BiThrTree;

char Nil='#'; /* 字符型以空格符为空 */

/* 按前序输入二叉线索树中结点的值,构造二叉线索树T */
BiThrNode* CreateBiThrTree()
{
BiThrNode *tmp = NULL;
char ch;
scanf("%c",&ch);

if (ch == '#')
{
return NULL;
}
else
{
tmp = (BiThrNode *)malloc(sizeof(BiThrNode));
if (tmp == NULL)
{
return NULL;
}
memset(tmp, 0, sizeof(BiThrNode));
tmp->data = ch;

tmp->lchild = CreateBiThrTree(); /* 递归构造左子树 */
tmp->rchild = CreateBiThrTree();
}
return tmp;
}

BiThrNode *pre; /* 全局变量,始终指向刚刚访问过的结点 */
/* 中序遍历进行中序线索化 */
void InThreading(BiThrNode *p)
{
if(p)
{
InThreading(p->lchild); // 递归左子树线索化
if(p->lchild == NULL) // 没有左孩子
{
p->LTag = Thread; p->lchild = pre; //前驱线索左孩子指针指向前驱
}
if(pre->rchild == NULL) // 前驱没有右孩子
{
pre->RTag = Thread; pre->rchild = p; // 后继线索前驱右孩子指针指向后继(当前结点p)
}
pre = p; // 保持pre指向p的前驱
InThreading(p->rchild); // 递归右子树线索化
}
}

/* 中序遍历二叉树T,并将其中序线索化,Thrt指向头结点 */
BiThrNode* InOrderThreading(BiThrTree T)
{
BiThrNode *Thrt = NULL;

Thrt = (BiThrNode *)malloc(sizeof(BiThrNode)); //建头结点
if (Thrt == NULL)
{
return NULL;
}
memset(Thrt, 0, sizeof(BiThrNode));

Thrt->LTag = Link; //左孩子为孩子指针
Thrt->RTag = Thread; //右孩子为线索化的指针
Thrt->rchild = Thrt; // 右指针回指 */ //步骤2和4
if(T == NULL) // 若二叉树空,则左指针回指
{
Thrt->lchild = Thrt; //步骤1和3
}
else
{
Thrt->lchild = T; //步骤1
pre = Thrt ;
InThreading(T); // 中序遍历进行中序线索化
pre->rchild = Thrt; //步骤4
pre->RTag = Thread; // 最后一个结点线索化
Thrt->rchild = pre; //步骤2
}
return Thrt;
}

/* 中序遍历二叉线索树T(头结点)的非递归算法 */
int InOrderTraverse_Thr(BiThrNode* T)
{
BiThrNode* p;
p = T->lchild; /* p指向根结点 */
while (p != T)
{
/* 空树或遍历结束时,p==T */
while (p->LTag == Link)
p = p->lchild;
printf("%c ", p->data);

//如果中序遍历的最后一个结点的右孩子 == T 说明到最后一个结点 ,遍历结束..
while (p->RTag==Thread && p->rchild!=T)
{
p = p->rchild;
printf("%c ", p->data);
}
p = p->rchild;
}
return 0;
}

/* 中序遍历二叉线索树T(头结点)的非递归算法 */
int InOrderTraverse_Thr2(BiThrNode* T)
{
BiThrNode* p;
p = T->rchild; /* p指向根结点 */
while (p != T)
{
/* 空树或遍历结束时,p==T */
while (p->RTag == Link)
p = p->rchild;
printf("%c ", p->data);

//如果中序遍历的最后一个结点的右孩子 == T 说明到最后一个结点 ,遍历结束..
while (p->LTag==Thread && p->lchild!=T)
{
p = p->lchild;
printf("%c ", p->data);
}
p = p->lchild;
}
return 0;
}

int main()
{
BiThrTree T, H;
printf("请按前序输入二叉树(如:'ABDH##I##EJ###CF##G##')\n");
T = CreateBiThrTree(); // 按前序产生二叉树
H = InOrderThreading(T); // 中序遍历,并中序线索化二叉树
printf("中序遍历(输出)二叉线索树:\n");
InOrderTraverse_Thr(H); // 中序遍历(输出)二叉线索树

printf("\n逆序访问:");
InOrderTraverse_Thr2(H);

printf("\n");

system("pause");
return 0;
}