二叉树相关方法代码实现

二叉树递归遍历，非递归遍历，线索二叉树的建立等算法

中序非递归

void InOrder(BiTree T){
	Stack S;
	BTNote p=T;
	Init(S);
	while(p&&!ISEmpty(S)){
		if(p)
		{
			Push(S,p);
			p=p->lchlid;
		}
		else
		{
			Pop(S,p);
			visit(p);
			p=p->rchild;
		} 
	}
}

先序非递归

void PreOrder(BiTree T){
	Stack S;
	BNode *p=T;
	Initi(S);
	while(p){
		if(p)
			visit(p);
			Push(S,p);
			p=p->lchild;
		else
			Pop(S,p);
			p=p->rchild;

	}
}

层次遍历

void LevelOrder(BiTree T){
    BNode *p;
    p=T;
    Queue Q;
    EnQueue(Q,p);
    while(!IsEmpty(Q)){
        DeQueue(Q,p);
        visit(p);
        if(p->lrchild!=NULL)
            EnQueue(Q,p->lchild);
        if(p->rchild!=NULL)
            EnQueue(Q,p->rchild);
    }
}

二叉树线索化

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 CreateInThread(ThreadTree &T){
	ThreadTree pre=NULL;
	if（T!=NULL){
		InThread(T,pre);
		pre->rchild=NULL;//从InThread函数出来后 pre=p;
		pre->rtag=1;
	}
}

ThreadNode *Eirstnode(ThreadNode *P){
	while(p->ltag==0) p=p->lchild;
	returu p;
  
}

ThreadNode *Nextnode(ThreadNode *p){
	if(p->rtag==0）return Firstnode(p->rchild);
	else return p->rchild;
}
void Inorder(ThreadNode *T){
	for(ThreadNode *p=Firstnode(T);p!=NULL; p=Nextnode(p))
		visit(p);
}

排序二叉树非递归查找

BNode *Search(BiTree T,ElemType key){
	while(T&&key!=T->data){
		if(p->data<T->data)
			T=T->lchild;
		else
			T=T->rchild;
	}
    return T;
}

排序二叉树的插入

int BST_Insert(BiTree &T,ElemType key){
    if(T==NULL)
        T=(BNode*)malloc(sizeof(BNode));
    	T->data=key;
    	T->lchild=NULL;
    	T->rchild=NULL;
    	return 1;
    else if(T-<data==key)
        return 0;
    else if(key<T->data)
        return BST_Insert(T->lchild,key);
    else
        return BST_Insert(T->rchild,key);
}
//建立二叉排序树
void Crea_BST(BiTree &T,ElemType str[],int n){
    int i=0;
    T=NULL;
    while(i<n){
        BST_Insert(T,str[i]);
        i++; 
    }
}
‍```

# BFS广度优先搜索
```c
void BFSTraverse(Graph G){
    for(i=0;i<G.vexnum;++i){
        visited[i]=false;
    }
    for(i=0;i<G.vexnum;++i){
        if(!visit[i])
            BFS(G,i);
    }
}



void BFS(Grapg G,int v){
    visit(v);
    visited[v]=true;
    EnQueue(Q,v);
    while(!IsEmpty(Q)){
        DeQueue(Q,v);
        for(w=Neighbor(G,v);w>=0;w=NextNeighbor(G,v,w)){
            if(!visites[w])
                visit(w);
            	visited[w]=true;
            	EnQueue(Q,w);
        }
    }
}

BFS算法求单源最短路径

void BFS_MIN_Distance(Graph G,int u){
    for(i=0;i<G.vexnum;++i){
        du[i]=max;
    }
    du[u]=0;
    visited[u]=true;
    EnQueue(Q,u);
    while(!IsEmpty(Q)){
        DeQueue(Q,u);
        for(w=FirstNeighbor(G,u);w>=0;w=NextNeighbor(G,u,v)){
            if(!visited[w]){
                visited[w]=true;
                d[w]=d[u]+1;
                EnQueue(G,w);
            }
        }
    }
}

DFS深度优先搜索

void DFSTraverse(Graph G){
    for(i=0;i<vexnum;++i){
        visited[i]=false;
    }
    for(i=0;i<vexnum;++i){
        if(!visited[i])
            DFS(G,i);
    }
}
void DFS(Graph G,,int v){
    visited[v]=true;
    visit(v);
    for(w=FirstNeighbor(G,v);w>=0;NextNeighbor(G,v,w)){
        if(!visit[w])
            DFS(G,w);
    }
}