2021-07-22

数据结构（C&C++)

树（第一部分）

#include<stdio.h>
#include<stdlib.h>
#define MaxSize 25
typedef struct BiNode {
	int data;
	struct BiNode* lchild, * rchild;
}BiNode,*BiTree;
typedef struct {
	int data[MaxSize];
}SqTree;
int Common_Ancestor(SqTree T, int i, int j) {
	if (T.data[i] != '#' && T.data[j] != '#') {
		while (i != j) {
			if (i > j)
				i = i / 2;
			else
			{
				j = j / 2;
			}
		}
		return T.data[i];
	}
}
void visit(BiTree T) {
	if (T != NULL)
		printf("%d", T->data);
	else
		return;
}
void PreOrder(BiTree T) {
	visit(T);
	PreOrder(T->lchild);
	PreOrder(T->rchild);
}
void InOrder(BiTree T) {
	InOrder(T->lchild);
	visit(T);
	InOrder(T->rchild);
}
void PostOrder(BiTree T) {
	PostOrder(T->lchild);
	PostOrder(T->rchild);
	visit(T);
}
typedef struct {
	BiTree BStack[MaxSize];
	int top;
}BiTreeStack;
void IniBTStack(BiTreeStack& BiT) {
	BiT.top = -1;
}
bool TPush(BiTreeStack& BiT, BiNode* p) {
	if (BiT.top == MaxSize)
		return false;
	BiT.BStack[++BiT.top] = p;
	return true;
}
bool TPop(BiTreeStack& BiT, BiNode* &p) {
	if (BiT.top == -1)
		return false;
	p = BiT.BStack[BiT.top--];
	return true;
}
bool IsEmpty(BiTreeStack BiT) {
	if (BiT.top == -1)
		return true;
	else
		return false;
}
bool GetTop(BiTreeStack  BiT, BiNode* &p) {
	if (BiT.top == -1)
		return false;
	p = BiT.BStack[BiT.top];
	return true;
}
void InOrder2(BiTree T) {  //需要修改栈的结构，改为存放树的节点或者说指向树的节点的指针
	BiTreeStack BT;
	IniBTStack(BT);
	BiTree p = T;
	while (p || !IsEmpty(BT)) {
		if (p) {
			TPush(BT, p);
			p = p->lchild;
		}
		else
		{
			TPop(BT, p);
			visit(p);
			p = p->rchild;
		}
	}
}
void PreOrder2(BiTree T) {
	BiTreeStack BT;
	IniBTStack(BT);
	BiTree p = T;
	while (p || !IsEmpty(BT)) {
		if (p) {
			visit(p);
			TPush(BT, p);
			p = p->lchild;
		}
		else
		{
			TPop(BT, p);
			p = p->rchild;
		}
	}
}
void PostOrder2(BiTree T) {  //后序非常的特殊，要多练习并尝试理解
	BiTreeStack BT;
	IniBTStack(BT);
	BiTree p = T;
	BiNode* r = NULL;
	while (p || !IsEmpty(BT)) {
		if (p) {
			TPush(BT, p);
			p = p->lchild;
		}
		else
		{
			if (p->rchild && p->rchild != r) {
				p = p->rchild;
			}
			else
			{
				TPop(BT, p);
				visit(p);
				r = p;
				p - NULL; // 非常重要的一步，p=NULL是为什么？第一次访问时，如果他无右子树则应该直接打印，否则应该先去访问右子树，当再一次访问到他（二次访问时）再将其打印出来
			}				//p=NULL将直接跳过之前的if而来到这个循环，相当于“第二次访问”到有右子树的节点，将其弹出
		}
	}
}
int TreeDepth(BiTree T) {
	if (T == NULL)
		return 0;
	else
	{
		int l = TreeDepth(T->lchild);
		int r = TreeDepth(T->rchild);
		return l > r ? l + 1 : r + 1;
	}
}
void LevelOrder(BiTree T) {  //这里假设队列也类似栈做了专为树的结点做的处理
	BiTreeQueue BQ;
	IniBTQueue(BQ);
	BiTree p = T;
	BTEnQueue(BQ, p);
	while (!IsEmptyQ(BQ)) {
		BTDeQueue(BQ, p);
		visit(p);
		if(p->lchild!=NULL)
			BTEnQueue(BQ, p->lchild);
		if(p->rchild!=NULL)
			BTEnQueue(BQ, p->rchild);
	}
}
typedef struct ThreadNode {
	int data;
	struct ThreadNode* lchild, * rchild;
	int ltag, rtag;
}ThreadNode,*ThreadTree;
void InThread(ThreadTree& p, ThreadTree& pre)
{
	if (p != NULL) {
		InThread(p->lchild, pre);
		if (p->lchild == NULL) {
			p->lchild = pre;
			p->ltag = 1;
		}
		if (pre != NULL && pre->rchild == NULL) {
			pre->rchild = p;
			pre->rtag = 1;
		}
		pre = p;
		InThread(p->rchild, pre);
	}
}
void CreatInThread(ThreadTree T) {
	ThreadTree pre = NULL;
	if (T != NULL) {
		InThread(T, pre);
		pre->rchild = NULL;
		pre->rtag = 1;
	}
}
ThreadNode* FirstNode(ThreadNode* p) {
	while (p->ltag == 0)
		p = p->lchild;                   //返回的是某棵树中最左下的结点
	return p;
}
ThreadNode* NextNode(ThreadNode* p) {
	if (p->rtag == 0) return FirstNode(p->rchild);
	else
	{
		return p->rchild;
	}
}
ThreadNode* LastNode(ThreadNode* p) {
	while (p->rtag == 0)
		p = p->rchild;                 //返回的是某棵树中最右下的结点
	return p;
}
ThreadNode* PreNode(ThreadNode* p) {
	if (p->ltag == 0) return LastNode(p->lchild);
	else
	{
		return p->lchild;
	}
}
void InOrder3(ThreadNode *T) {
	for (ThreadNode* p = FirstNode(T); p != NULL; p = NextNode(p))
		visit(p);
}
void PreThread(ThreadTree &p,ThreadTree &pre) {
	if (p != NULL) {
		if (p->lchild == NULL) {
			p->lchild = pre;
			p->ltag = 1;
		}
		if (pre != NULL && pre->rchild == NULL) {
			pre->rchild = p;
			pre->rtag = 1;
		}
		pre = p;
		PreThread(p->lchild, pre);
		PreThread(p->rchild, pre);
	}
}

void PostThread(ThreadTree& p, ThreadTree& pre) {
	if (p != NULL) {
		PostThread(p->lchild, pre);
		PostThread(p->rchild, pre);
		if (p->lchild == NULL) {
			p->lchild = pre;
			p->ltag = 1;
		}
		if (pre != NULL && pre->rchild == NULL) {
			pre->rchild = p;
			pre->rtag = 1;
		}
		pre = p;
	}
}
int BTDepth(BiTree T) {
	if (!T)
		return 0;
	int front = -1, rear = -1;
	int level = 0;
	int last = 0;   //某层的最右侧的结点
	BiTree Q[MaxSize];
	Q[++rear] = T;
	BiTree p;
	while (front < rear) {
		p = Q[++rear];
		if (p->lchild)
			Q[++rear] = p->lchild;
		if (p->rchild)
			Q[++rear] = p->rchild;
		if (front = last) {
			level++;
			last = rear;
		}

	}
	return level;
}

int Max = 0;
int count[MaxSize];
int BTWidth(BiTree T,int k) {   //k表示当前层数
	BiNode* p = T;
	if (p == NULL)
		return;
	else
		count[k]++;
	if (count[k] > Max)
		Max = count[k];
	BTWidth(p->lchild, k + 1);
	BTWidth(p->rchild, k + 1);
	return Max;
}
int BTWidth2(BiTree T) {
	if (!T)
		return 0;
	int front = -1, rear = -1;
	int last = 0;
	int max = 0, width = 0;   //max保存上一层的宽度，width保存本层的宽度，注意同时max也是最大宽度，只是看是否需要交换
	BiTree Q[MaxSize];
	Q[++rear] = T;
	BiTree p;
	while (front<rear)
	{
		p = Q[++front];
		width++;
		if (p->lchild) 
			Q[++rear] = p->lchild;
		
		if (p->rchild)
			Q[++rear] = p->rchild;

		if (front == last) {
			if (max < width)
				max = width;
			last = rear;
			width = 0;  //新的一层开始重新将宽度置零
		}
	}
	return max;
}
BiTree PreInCreat(int a[], int b[], int l1, int h1, int l2, int h2)//l1,h1,l2,h2是第一、第二个数组中的第一和最后一个结点的下标
{
	int l1 = 1, l2 = 1, h1 = n, h2 = n;    //n是数组的长度，在这里注意下标是从1开始的
	BiNode* root = (BiTree)malloc(sizeof(BiNode));
	root->data = a[l1];               //数组a中存的是先序序列，数组b中存的是中序序列
	int i;
	for (i = l2; b[i] != root->data; i++);   //根结点将树分成左右子树
	int llen = i - l2;
	int rlen = h2 - i;
	if (llen)
		root->lchild = PreInCreat(a, b, l1 + 1, l1 + llen, l2, l2 + llen - 1);
	else
		root->lchild = NULL;
	if (rlen)
		root->rchild = PreInCreat(a, b, h1 - rlen + 1, h1, h2 - rlen + 1, h2);
	else
		root->rchild = NULL;
	return root;
}
BiTree PostInCreat() {}    //后序中序怎么写
	
int DoubleNode(BiTree T) {
	if (T == NULL)
		return 0;
	else if (T->lchild != NULL && T->rchild != NULL)
	{
		return DoubleNode(T->lchild) + DoubleNode(T->rchild) + 1;
	}
	else
		return DoubleNode(T->lchild) + DoubleNode(T->rchild);
}
void SwapBT(BiTree T) {
	if (T) {
		SwapBT(T->lchild);
		SwapBT(T->rchild);
		BiNode* temp = T->lchild;
		T->lchild = T->rchild;
		T->rchild = temp;
	}
}
int i = 1;
int PreSearchK(BiTree T, int k) {
	int temp = 0;
	if (T == NULL)
		return 0;   //空结点返回特殊字符
	if (i == k)
		return T->data;
	i++;
	temp = PreSearchK(T->lchild, k);
	if (temp != 0)
		return temp;
	temp = PreSearchK(T->rchild, k);
	return temp;
}