中序遍历c语言

‘壹’ c语言中，到底先序遍历、中序遍历、后续遍历怎么看的...真的快疯掉了！求高人指点指点...泪目

先序遍历就是“根左右”，不管你现在在哪个节点，都是按这种规则。上面的题目：根是A，左是B，右是C，所以是A-》B，在当前根节点B，还是按上述规则，那么接下来到D，D之后没有子节点，返回B，遍历E-》X，X之后没有子节点，返回E，E的子节点都遍历完了，返回B，B的子节点都遍历完了，返回A，接下来遍历右子树，规则同上。
中序遍历就是“左根右”，对于A来说，先遍历B，对于B来说，先遍历D，对于D来说，已经没有左子树，所以遍历D，D没有右子树,返回B，遍历B，B有右子树E，对于E来说，先遍历X，完了返回E，E完了返回B，B完了返回A，遍历A，遍历右子树，规则同上。
后序遍历就是跟先序遍历相反的，先遍历右子树，再左子树，最后才是根。
好好思考一下。

‘贰’ C语言数据机构：由中序遍历和层次遍历能不能唯一确定一颗二叉树为什么说法不一致哪

由中序遍历和层次遍历能够唯一确定一颗二叉树。从下面的算法可知，每一步构造得到的二叉树结果是唯一的。
以下构造部分的答案来自网络知道：
假定树的层次遍历ABCDEFG
HIJ中序遍历DBGEHJACIF
两种遍历顺序要结合着分析，才能画出这颗树的图
比如，层次遍历，先访问到A节点，说明A是树的根节点
那么在中序遍历结果里看：
DBGEHJ在A前面，说明这些节点，都在A左子树上
CIF在A的后面，说这些节点，都在A的右子树上
那么，树可以先这样画：
__________A________
________/____\_____
_____DBGEHJ__CIF___
再看层次遍历，A后面是B，说明B是A左子树的根节点
从上图中的先序遍历顺序DBGEHJ中看到：
D在B的前面，说明D在B的左子树上
GEHJ在B的后面，说明它们在B的右子树上
那么，树又可以画成：
_________A________
_______/____\_____
_____B________CIF__
____/__\____________
___D__GEHJ_________
如此循环，直到将整个树都画完全
结果如下：
_____________A_______________
___________/____\_____________
________B_________C__________
______/___\_________\_________
_____D_____E_________F_______
__________/__\_________\______
_________G____H_________I____
_______________\______________
_________________J____________

‘叁’ c语言 关于二叉树的创建和遍历(中序遍历)

这个还是我学《数据结构》时做的有关二叉树的练习呢，本来是全的，包括树的初始化，建立，遍历（中序、前序、后序和层次），还有输出，复制，删除节点，求深度，树的删除等等，看你只问了有关创建和中序遍历的，所以选了一部分给你，供你参考吧！
#include <stdio.h>
#include <malloc.h>
#define MaxSize 10
#define Number 30
struct BiTNode{//定义数据结构
char data;
BiTNode *lchild,*rchild;
};
void InitBtree(BiTNode * &BT){//初始化二叉树
BT=NULL;
}
void CreateBiTree(BiTNode *&BT,char *str){//建立二叉树
BiTNode *s[MaxSize];//这里定义了一个数组用作堆栈方便检查输入和操作
int top=-1;
BT=NULL;
BiTNode *p=NULL;
int k, j=0;
char ch;
ch=str[j];
while(ch!='\0'){
switch(ch){
case '(':
top++;
s[top]=p;
k=1;
break;
case ')':
top--;
break;
case ',':
k=2;
break;
default:
p=(struct BiTNode *) malloc(sizeof(struct BiTNode));
p->data=ch;
p->lchild=p->rchild=NULL;
if(BT==NULL)
BT=p;
else{
if(k==1)
s[top]->lchild=p;
else
s[top]->rchild=p;
}
}
j++;
ch=str[j];
}
}
void inorder(BiTNode *BT){//中序遍历二叉树——递归形式
if(BT!=NULL){
inorder(BT->lchild );
printf("%c ",BT->data);
inorder(BT->rchild );
}
}

void main(){
BiTNode *BT;
printf("以广义表形式表示输入的二叉数 （如A(B(C,D),E(,F))的形式）\n\n");
char string[Number]="A(B(,C),D(E(F),G(,H)))";
//如果想要自己输入，可以将下边的注释去掉，然后自己按照广义表形式输入，
//（如上例的形式）此处为了方便查看，用了默认的数值
//这里之所以用此种形式（广义表形式输入）是为了保证输入的数组成的二叉树完全符合你所定义的树的形状
/*char string[Number],ch;
int i=0;
ch=getchar();
while(ch!='\n' && i<Number){
string[i]=ch;
i++;
ch=getchar();
}
string[i]='\0';
*/

InitBtree(BT);//初始化二叉树
CreateBiTree(BT,string);//创建二叉树
printf("\n中序遍历二叉树顺序为： ");
inorder(BT);//中序遍历二叉树
printf("\n");
}
程序不复杂，所以只是加了必要和最简单的注释，相信你看看应该完全可以理解的，祝你进步！

‘肆’ C语言中，前序遍历，中序遍历各什么意思

前序遍历：先访问根节点，然后访问左子树，再访问右子树。
中序遍历：先访问左子树，然后访问根节点，再访问右子树。

‘伍’ C语言利用栈 进行中序遍历

typedefcharTElemType;
typedefintStatus;
typedefcharSElemType;
typedefstructBiTNode{
TElemTypedata;
structBiTNode*lchild,*rchild;
		}BiTNode,*BiTree;
typedefstruct
{
	SElemType*base;
	SElemType*top;
	intstacksize;
	}SqStack;
StatusInOrderTraverse(BiTreeT)

{
SqStackS;
BiTNode*p;
	InitStack(&S);
	p=T;
	while(p||!EmptyStack(S))
	{
		if(p)
		{
			push(&S,*p);p=p->lchild;
		}
		else
		{
		pop(&S,p);
		if(!p->data)returnERROR;
		
		printf("%d",p->data);
		p=p->rchild;	
		}
	}
	returnOK;
}

‘陆’ 中序遍历二叉树（C语言）

#include<stdio.h>

inttree[1000];
intm;

voidmidorder(inti){
if(i>=m||tree[i]==0)return;

midorder(i*2+1);
printf("%d",tree[i]);
midorder(i*2+2);
}

voidsolve(){
inth=1;
while((1<<h)<=m)++h;
printf("%d",h);

midorder(0);
printf("
");
}

intmain(){
inti,n,t;

scanf("%d",&n);

for(i=0;i<n;++i){
m=0;
while(scanf("%d",&t)>0&&t>=0){
tree[m++]=t;
}
solve(0);
}
}

‘柒’ C语言 关于二叉树的中序遍历问题 急急急！！今晚就要交

#include <stdio.h>
#include <malloc.h>

typedef struct node
{
int data;
struct node *lchl,*rchl;
} NODE;

NODE *create(NODE *t) //函数带有返回值 以影响调用者
{
int a;
scanf("%d",&a);
if(a)
{
t=(NODE*)malloc(sizeof(NODE));
t->data=a ;
t->lchl = create(t->lchl);
t->rchl = create(t->rchl);
return t ; // 此处返回刚才申请单元的指针 t
}
else
return NULL; // 无子树返回 NULL
}

void print(NODE *T) //中序遍历
{
if(T)
{
print(T->lchl);
printf("%4d",T->data);
print(T->rchl);
}
}

void main()
{
NODE *root;
root = create(root) ; // 接收返回值
print(root);
printf("\n") ;
}

‘捌’ 二叉树的建立、中序遍历（用C语言实现）

#include "iostream.h"
//#include "exception.h"
//树节点类
int count=0,mode=0,data=0;

class BinaryTreeNode
{
friend class BinaryTree;
public :
BinaryTreeNode()
{
LeftChild = RightChild = 0;
}
BinaryTreeNode(const int& e)
{
data = e;
LeftChild = RightChild = 0;
}
BinaryTreeNode(const int& e, BinaryTreeNode *l,BinaryTreeNode *r)
{
data = e;
LeftChild = l;
RightChild = r;
}
private :
int data;
BinaryTreeNode *LeftChild, //左子树
*RightChild; // 右子树
} ;
class BinaryTree
{
friend class BinaryTreeNode;
public :
BinaryTree( )
{
root = 0;
}
~ BinaryTree( ) { }
bool IsEmpty( ) const
{
return ((root) ? false : true);
}
bool Root(int& x) const
{// 取根节点的d a t a域，放入x
// 如果没有根节点，则返回f a l s e
if (root)
{
x = root->data;
return true;
}
else return false; // 没有根节点
}
void MakeTree(const int& element)
{
root = new BinaryTreeNode (element);
}
void MakeTree(const int& element,BinaryTree& left,BinaryTree& right)
{// 将left, right和element 合并成一棵新树
// left, right和this必须是不同的树
// 创建新树
root = new BinaryTreeNode (element, left.root, right.root);
// 阻止访问l e f t和r i g h t
left.root = right.root = 0;
}
void Inorder(void (*Visit) (BinaryTreeNode *u))
{
InOrder ( Visit,root ) ;
}
void Delete( )
{
PostOrder (Free,root);
root = 0;
}

private :
BinaryTreeNode *root; // 根节点指针
static void Free(BinaryTreeNode *t)
{
delete t;
}
void InOrder(void(*Visit) (BinaryTreeNode *u),BinaryTreeNode *t)
{// 中序遍历
if (t)
{
InOrder(Visit, t->LeftChild);
Visit( t ) ;
InOrder( Visit, t->RightChild);
}
}

‘玖’ c语言中序遍历怎么做

求采纳

‘拾’ C语言二叉树中序遍历问题

#include<stdio.h>
#include<stdlib.h>

typedef struct BitNode{
char data;
struct BitNode *lchild,*rchild;
}BitNode,*BiTree;

typedef struct{
BiTree base;
BiTree top;
int stacksize;
}SqStack;

int InitStack(SqStack &S){
S.base=(BitNode *)malloc(100*sizeof(BitNode));
if(!S.base) exit (-2);
S.top = S.base;
S.stacksize=100;
return 1;
}

int StackEmpty(SqStack S){
if(S.top==S.base) return 1;
else return 0;
}

int Push(SqStack &S,BiTree e){
if(S.top-S.base>=S.stacksize){
S.base=(BitNode *)realloc(S.base,(S.stacksize+10)*sizeof(BitNode));
if(!S.base) exit(-2);
S.top=S.base+S.stacksize;
S.stacksize+=10;
}
// *S.top++=*e;
*(++S.top)=*e;
return 1;
}

int Pop(SqStack &S,BiTree &e){
if(S.top==S.base) return -1;
//*e=*--S.top;
e=S.top--;
return 1;
}

int GetTop(SqStack S,BiTree &e){
if(S.top==S.base) return -1;
// *e=*(S.top-1);
e=S.top;
return 1;
}

int CreateBiTree(BiTree &T){
char ch;
scanf("%c",&ch);
if(ch=='#') T=NULL;
else {
if(!(T=(BitNode *)malloc(sizeof(BitNode)))) exit(-2);
T->data=ch;
CreateBiTree(T->lchild);
CreateBiTree(T->rchild);
}
return 1;
}

int InOrderTraverse(BiTree T){
BiTree p;
SqStack S;
InitStack(S);
p=T;
while(p!=NULL||!StackEmpty(S)){
if(p!=NULL) {
Push(S,p);

p=p->lchild;
}
else{
Pop(S,p);

printf("%c",p->data);
p=p->rchild;
}
}
return 1;
}

int main()
{
BiTree T;
CreateBiTree(T);

InOrderTraverse(T);

getchar();
getchar();
return 1;
}
ps:中序遍历算法没问题，问题出在栈的使用上，你判断栈为空的条件是s.top==s.base,所以第一个空间不能使用，当作判断条件。还有就是你放进栈的是树的节点，那么pop出来就只要改变一下指针就好了
随便说一下，为什么要把树的节点放进栈中，可以把指向树的节点的指针放进栈中啊。