算法必背（必备）锦囊-考研-学习-提升必背算法

这是自己备战考研中自己一点一点积攒起来的！也是为了方便自己背诵记忆！

前提：代码有很多错误，逻辑都是对的！

二叉树的链式存储结构：

typedef  struct  BiTNode{
Elemtype  data;
struct  BiTNode *lchild, *rchild;
}BiTNode,*BiTree；

二叉树的（后）遍历：

void Order(Bitree T)
{
	if(T!=NULL)
	{
		Order(T->lchild);
		Order(T->rchild);
		visit(T);
	}
}

二叉树的（中）遍历：

void middle(Bitree T)
{
	if(T!=NULL)
	{
		Order(T->lchild);
		visit(T);
		Order(T->rchild);
	}
}

二叉树的（前）遍历：

void prior(Bitree T)
{
	if(T!=NULL)
	{
		visit(T);
		Order(T->lchild);
		Order(T->rchild);
	}
}

中序遍历非递归算法：

void Inorder (BiTree T){
Initstack(s); Bitree p=T;
	  while (p||IsEmpty(s)){
		if(p){
			Push(S,p);
			p=p->lchild;}
		else{
			Pop(S,p);visit(p);
			p=p->rchild;
			}
		}
}

先序遍历的非递归算法：

void preInorder (BiTree T){
	InitStack(s);BiTree p=T; //初始化栈S，p是遍历指针
		while(p||!IsEmpty(s)){
			if(p){
				visit(p);Push(S,p);
				p=p->lchild;
			}
			else{
				Pop(S,p);
				p=p->rchild;
			}
		}
}

二叉树后序非递归遍历思想：

从根节点开始，将其入栈，然后沿其左子树一直往下搜索，直到搜索到没有左孩子的节点，然后遍历右子树，知道上述操作进行不下去，可以知道的是，如果某个节点想要出栈被访问，要么左子树为空，要么右子树刚被访问完。通常在算法设计中用来解决根到某节点的距离、求两个节点的公共祖先等。

二叉树的层次遍历：

代码：

void Levelorder (BiTree T){
	InitQueue(Q);
	BiTree T;
BiTreeNode *p；
	EnQueue(Q,T);//进队
	while(!IsEmpty(T)){
		Dequeue(Q,p);//出队
		visit(p);
		if(p->lchild!=Null)
			EnQueue(Q,p->lchild);
		if(p->rchild!= Null)
			Enqueue(q,p->rchild);
			}
}

二叉树的左右子树交换：

void Change(BiTree root)
{
	BiTree Queue[Max];
	BiTree *p,*q;
	if(root){
		EnQueue(Q,root);
		while(!IsEmpty(Q)){
			p=pop(Q);
			if(p->lchild) EnQueue(Q,p->lchild);
			if(p->rchild) EnQueue(Q,p->rchild);
			q=p->rchild;
			p->rchild=p->lchild;
			p->lchild=q;
		}
	}
}

给出二叉树自下而上，自右向左的非递归层次遍历算法。

void InvertLevel(BiTree T){
	Stack s,Queue q,
	if(T!=Null){
		InitStack(s);
		InitQueue(q);
		Enqueue(q,T);
		while(IsEmpty(q)==false){
			Dequeue(q);
			Push(s,q);
			if(T->lchild!=Null)
				Enqueue(q,T->lchild);
			if(T->rchild!=NUll)
				Enqueu(q,T->rchild);
		}
		while(Isempty(s)!=false){
			Pop(s,p);
			visit(p->data);
	}
  }
}

2014年统考真题-描述计算WPL的算法思想；写出相关结构体；写出计算WPL的代码。

算法思想：

采用先序遍历的思想，使用static变量用于输出最后计算的结果，每次遍历将节点的深度作为参数进行传递，每传递一次加一；对每一个节点进行访问，如果节点既没有左孩子也没有右孩子，则wpl加上当前节点的权值乘当前节点的深度；否则分别对左右子树进行调用函数，并将深度加一传入；最后返回计算结果。

结构体描述：

typedef struct BiTree{
		int weight;
		struct BiTree *lchild;*rchild;
}BiTree;

算法代码：

int WPL(BiTree , root){
	return wpl_preorder(BiTree,0);
}
int wpl_preorder(BiTree root,int deep){
	static int wpl=0;
	if(root->lchild==Null&&root->rchild==Null)
		return wpl+=root->weight*deep;
	if(root->lchild!=Null)
		return wpl_preorder(root->lchild,deep+1);
	if(root->rchild!=Null)
		return wpl_preorder(root->rchild,deep+1)
	return wpl;
}

——以上这是自己对树中比较重要的一部分总结，都是自己在学习之后使用在线编译器写出来的，可能存在很多的错误，运行时会报错。写博客主要是再次加深自己对算法逻辑的理解和记忆！ 并不是为了要实际的运行出来！不喜勿喷！蟹蟹！ 做个热爱技术的正直好青年！