2021-07-25

数据结构（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;
}

void DeleteXTree(BiTree &T) {
	if (T) {
		DeleteXTree(T->lchild);
		DeleteXTree(T->rchild);
		free(T);
	}
}
void Search(BiTree bt, int x) {
	BiTree Q[MaxSize];
	if (bt) {
		if (bt->data == x) {
			DeleteXTree(bt);
			exit(0);
		}
		InitQueue(Q);
		EnQueue(Q,bt);
		while (!IsEmpty(Q)) {
			DeQueue(Q, p);
			if (p->lchild)
				if (p->lchild->data == x) {
					DeleteXTree(p->lchild)
						p->lchild = NULL;
				}
				else
					EnQueue(Q, p->lchild);
			if (p->rchild)
				if (p->rchild->data == x) {
					DeleteXTree(p->rchild);
					p->rchild = NULL;
				}
				else
					EnQueue(Q,p->rchild);
				
		}
	}

}
typedef struct {
	BiTree T;
	int tag;             //tag=0表示左子树被访问，tag=1表示右子树被访问
}stack;   
void SearchAncestor(BiTree bt, int x) {
	stack s[MaxSize];
	int top = 0;
	while (bt != NULL || top > 0) {
		while (bt!=NULL&&bt->data!=x)
		{
			s[++top].T = bt;
			s[top].tag = 0;
			bt = bt->lchild;
		}
		if (bt->data == x) {
			printf("所查结点的祖先结点的值为：\n");
			for (i = 1; i < top; i++)
				printf("%d", s[i].T->data);
			exit(1);
		}
		while (top != 0 && s[top].tag == 1)
			top--;
		if (top != 0) {
			s[top].tag = 1;
			bt = s[top].T->rchild;
		}
	}

}
typedef struct W_BiTNode{
	int weight;
	struct W_BiTNode* lchild, * rchild;
}W_BiTNode,*W_BiTree;
int wpl_PreOrder(W_BiTree root,int deep) {
	static int wpl = 0;
	if (root->lchild == NULL && root->rchild == NULL)
		wpl += deep * root->weight;
	if (root->lchild != NULL)
		wpl_PreOrder(root->lchild, deep + 1);
	if (root->rchild != NULL)
		wpl_PreOrder(root->rchild, deep + 1);
	return wpl;
}
int WPL(W_BiTree root) {
	wpl_PreOrder(root, 0);
}

LinkedList head, pre = NULL;  //实现叶子结点串成链表，右孩子指针充当next链域
LinkedList InOrderLtoL(BiTree T) {
	InOrderLtoL(T->lchild);
	if (T->lchild == NULL && T->rchild == NULL) {
		if (pre == NULL) {             //第一个叶结点转化为首结点
			head = T;
			pre = T;
		}
		else {
			pre->rchild = T;            //后续的叶子结点用右指针串接起来
			pre = T;
		}
		InOrderLtoL(pre->rchild);
		pre->rchild = NULL;    //不要忘记最后一个叶子结点的右指针为NULL
	}
	return head;
}
ThreadNode* InPostPre(ThreadTree T,ThreadNode *p) {
	ThreadNode* q;
	if (p->rtag == 0)
		q = p->rchild;
	else if (p->ltag == 0)
		q = p->lchild;
	else if (p->lchild == NULL)
		q = NULL;   //p是中序序列的第一个结点，无前驱结点；或者说一直沿着向上找祖辈结点们的左孩子发现都是空的，那么在后续中就没有前驱
	else
	{
		while (p->ltag == 1 && p->lchild != NULL)
			p = p->lchild;
		if (p->ltag == 0)
			q = p->lchild;
		else
		{
			q = NULL;
		}
	}
	return q;
}
int Similar(BiTree T1, BiTree T2) {
	int leftS, rightS;
	if (T1 == NULL && T2 == NULL)
		return 1;
	else if (T1 == NULL || T2 == NULL)
		return 0;
	else
	{
		leftS = Similar(T1->lchild, T2->lchild);
		rightS = Similar(T1->rchild, T2->rchild);
		return leftS && rightS;
	}
}
//双亲表示法
typedef struct {
	int data;
	int parent;
}PTNode;
typedef struct {
	PTNode nodes[MaxSize];
	int n;              //结点数
}PTree;   
typedef struct CSNode {
	int data;
	struct CSNode *firstchild,*nextsibling
}CSNode,*CSTree;
int CSLeaves(CSTree CST) {
	if (CST == NULL)
		return 0;
	if (CST->firstchild == NULL)
		return 1 + CSLeaves(CST->nextsibling);
	else
	{
		return CSLeaves(CST->firstchild) + CSLeaves(CST->nextsibling);
	}
}
int CSHeight(CSTree cst) {
	int hc, hs;
	if (cst == NULL)
		return NULL;
	else {
		hc = CSHeight(cst->firstchild);    //第一子女树高
		hs = CSHeight(cst->nextsibling);   //兄弟树高
		if (hc + 1 > hs)                   //兄弟结点要比子女高一层，第一子女树的高度加1之后才和兄弟树高度相同
			return hc + 1;
		else
		{
			return hs;
		}
	}
}
BiNode* BST_Search(BiTree T, int k) {
	while (T != NULL && k != T->data) {
		if (k < T->data)
			T = T->lchild;
		else		
			T = T->rchild;
	}
	return T;
}

BiNode* BST_Search2(BiTree T, int k) {
	if (T == NULL)
		return NULL;
	if (T->data == k)
		return T;
	if (T->data < k)
		return BST_Search2(T->lchild, k);
	else
		return BST_Search2(T->rchild, k);
}
int BST_Insert(BiTree& T, int x) {
	if (T == NULL) {
		BiNode* T = (BiTree)malloc(sizeof(BiNode));
		T->data = x;
		T->lchild = T->rchild = NULL;
		return 1;
	}
	else if (x == T->data)   //不要漏掉结点可能重复的情况
		return 0;
	else if (x < T->data)
		return BST_Insert(T->lchild, x);
	else
		return BST_Insert(T->rchild, x);
}
void CreatBST(BiTree& T, int a[], int n) {
	T = NULL;
	while (i<n)
	{
		BST_Insert(T, a[i]);
		i++;
	}
}

int predit = -32767;    //中序遍历二叉树看是否是升序，predit用来保存前驱作为比较，前驱应当比当前节点小
int JudgeBST(BiTree T) {
	int b1, b2;
	if (T == NULL)
		return 1;
	else
	{
		b1 = JudgeBST(T->lchild);
		if (b1 == 0 || predit >= T->data)
			return 0;
		predit = T->data;
		b2 = JudgeBST(T->rchild);
		return b2;
	}
}
void OutPutK(BiTree T, int k) {
	if (T == NULL)
		return;
	if (T->rchild)
		OutPutK(T->rchild, k);
	if (T->data >= k)
		printf("%d/n", T->data);
	if (T->lchild)
		OutPutK(T->lchild, k);
}
int MinK(BiTree T) {
	while (T->lchild != NULL)
		T = T->lchild;
	return T->data;
}
int MaxK(BiTree T) {
	while (T->rchild != NULL)
		T = T->rchild;
	return T->data;
}
int K_Level(BiTree T, BiNode* p) {
	int n = 0;
	BiTree S = T;
	if (S) {
		n++;
		while (p->data != S->data) {

			if (p->data < S->data)
				S = S->lchild;
			else
				
				S = S->rchild;
			n++;
		}
		
	}
	return n;
}
void JudgeAVL(BiTree T, int& balance, int& h) {
	int bl = 0, br = 0, hl = 0, hr = 0;
	if (T == NULL) {
		h = 0;
		balance = 1;
	}
	else if (T->lchild == NULL && T->rchild == NULL) {
		h = 1;
		balance = 1;
	}
	else
	{
		JudgeAVL(T->lchild, bl,hl);
		JudgeAVL(T->rchild, br, hr);
		h = (hl > hr ? hl : hr) + 1;
		if (abs(hl - hr) < 2)
			balance = bl && br;
		else
			balance = 0;
	}
}
typedef struct RandBiTNode {
	int data;
	struct RandBiTNode* lchild, * rchild;
	int count;
}RandBiTNode,*RandBiTree;
RandBiTNode* Search_NoK_Min(RandBiTree T, int k) {
	if (k<1 || k>T->count)
		return NULL;
	if (T->lchild == NULL) {
		if (k == 1)
			return T;
		else
		{
			return Search_NoK_Min(T->rchild, k - 1);
		}
	}
	else
	{
		if (T->lchild->count == k - 1)
			return T;
		if (T->lchild->count > k - 1)
			return Search_NoK_Min(T->lchild, k);
		if (T->lchild->count < k - 1)
			return Search_NoK_Min(T->rchild, k - (T->lchild->count + 1));
	}
}

树中涉及了大量的递归以及对应的非递归算法的实现，结点的下标是重点，存储结构对效率有影响