关于非递归前序遍历二叉树的一个问题

发现一个很有意思的问题，但是也是一个很让我苦恼的问题。

我上网查了很多资料，发现这个问题的算法一般用的是顺序栈。而我喜欢用链式栈，而链式栈的pop函数为

void pop(sqs *s,BiTreeNode *e)
{
    if(s->top == s->Base) return;
    *e = *--s->top;

}

对应的算法代码为

pop（&s，p）；
p = p->rightChild;

我用链式栈原本一直做不出这个问题，然后代码也不知道什么问题，断点调试也不行，就很烦~~

直到我观察到别人的算法的pop是返回地址的。我才发现一点问题。于是我把pop函数改成

BiTreeNode* pop(sqs *s)
{
    if(s->top == s->Base) return NULL;
    return --s->top;

}

对应的算法代码为

p = pop(&s);//pop(&s,p);
p = p->rightChild;

然后就可以了！

我尝试把pop函数改成这样，但是还是不太行

​
void pop(sqs *s,BiTreeNode *e)
{
    if(s->top == s->Base) return;
    e = --s->top;

}

​

 

 

 

我想了半天觉得这应该是指针的问题，但是现在还没想出具体是什么问题。

但是觉得很有趣，有趣但苦恼啊！

整个算法的代码为

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

typedef char DataType;
#define maxsize 100
#define increase 10


typedef struct Node
{
DataType data;/*数据域*/
struct Node *leftChild;/*左子树指针*/
struct Node *rightChild;/*右子树指针*/
}BiTreeNode;/*结点的结构体定义*/
typedef struct sqs{
    BiTreeNode *Base;
    BiTreeNode *top;
    int size;
}sqs;
/*初始化创建二叉树的头结点*/
void Initiate(BiTreeNode **root)
{
*root = (BiTreeNode *)malloc(sizeof(BiTreeNode));
(*root)->leftChild = NULL;
(*root)->rightChild = NULL;
}

void Destroy(BiTreeNode **root)
{
if((*root) != NULL && (*root)->leftChild != NULL)
Destroy(&(*root)->leftChild);

if((*root) != NULL && (*root)->rightChild != NULL)
Destroy(&(*root)->rightChild);

free(*root);
}

/*若当前结点curr非空，在curr的左子树插入元素值为x的新结点*/
/*原curr所指结点的左子树成为新插入结点的左子树*/
/*若插入成功返回新插入结点的指针，否则返回空指针*/
BiTreeNode *InsertLeftNode(BiTreeNode *curr, DataType x)
{
BiTreeNode *s, *t;
if(curr == NULL) return NULL;

t = curr->leftChild;/*保存原curr所指结点的左子树指针*/
s = (BiTreeNode *)malloc(sizeof(BiTreeNode));
s->data = x;
s->leftChild = t;/*新插入结点的左子树为原curr的左子树*/
s->rightChild = NULL;

curr->leftChild = s;/*新结点成为curr的左子树*/
return curr->leftChild;/*返回新插入结点的指针*/
}

/*若当前结点curr非空，在curr的右子树插入元素值为x的新结点*/
/*原curr所指结点的右子树成为新插入结点的右子树*/
/*若插入成功返回新插入结点的指针，否则返回空指针*/
BiTreeNode *InsertRightNode(BiTreeNode *curr, DataType x)
{
BiTreeNode *s, *t;

if(curr == NULL) return NULL;

t = curr->rightChild;/*保存原curr所指结点的右子树指针*/
s = (BiTreeNode *)malloc(sizeof(BiTreeNode));
s->data = x;
s->rightChild = t;/*新插入结点的右子树为原curr的右子树*/
s->leftChild = NULL;

curr->rightChild = s;/*新结点成为curr的右子树*/
return curr->rightChild;/*返回新插入结点的指针*/
}
void PreOrder(BiTreeNode *t, void visit(DataType item))
//使用visit(item)函数前序遍历二叉树t
{
if(t != NULL)
{//此小段有一处错误
visit(t->data);

PreOrder(t-> leftChild, visit);
PreOrder(t-> rightChild, visit);
}
}
void InOrder(BiTreeNode *t, void visit(DataType item))
//使用visit(item)函数中序遍历二叉树t
{
if(t != NULL)
{//此小段有一处错误
InOrder(t->leftChild, visit);
visit(t->data);
InOrder(t->rightChild, visit);

}
}
void PostOrder(BiTreeNode *t, void visit(DataType item))
//使用visit(item)函数后序遍历二叉树t
{
if(t != NULL)
{//此小段有一处错误
PostOrder(t->leftChild, visit);
PostOrder(t->rightChild, visit);
visit(t->data);
}
}
void Visit(DataType item)
{
printf("%c ", item);
}
BiTreeNode *Search(BiTreeNode *root, DataType x)//需找元素x是否在二叉树中
{
BiTreeNode *find=NULL;
if(root!=NULL)
{
if(root->data==x)
find=root;
else
{
find=Search(root->leftChild,x);
if(find==NULL)
find=Search(root->rightChild,x);
}
}
return find;
}


void initsqs(sqs *s)
{
    s->Base = (BiTreeNode *)malloc(maxsize*sizeof(BiTreeNode));
    if(!s->Base) return;
    s->top = s->Base;
    s->size = maxsize;
}
int push(sqs *s,BiTreeNode e)
{
    if(s->top-s->Base>=s->size)
        s->Base = (BiTreeNode *)realloc(s->Base,(s->size + increase)*sizeof(BiTreeNode));
    *s->top =e;
    s->top++;
    return 1;
}
BiTreeNode* pop(sqs *s)
{
    if(s->top == s->Base) return NULL;
    return --s->top;

}
void gettop(sqs s,BiTreeNode *e)
{
    if(s.top == s.Base)
        return;
    *e = *(s.top - 1);
}
int empty(sqs s)
{
    if(s.top == s.Base)
        return 0;
    else
        return 1;
}
void preorder(BiTreeNode *t)
{
    sqs s;initsqs(&s);
    BiTreeNode *p = t,*p1 = NULL;
    while(p||empty(s))
    {
        if(p)
        {
            printf("%c\t",p->data);

            push(&s,*p);
            p = p->leftChild;
        }
        else
        {
            p = pop(&s);//pop(&s,p);
            p = p->rightChild;

        }
    }
}



int main()
{
BiTreeNode *root, *p, *pp,*find;
char x='E';

Initiate(&root);
p = InsertLeftNode(root, 'A');
p = InsertLeftNode(p, 'B');
p = InsertLeftNode(p, 'D');
p = InsertRightNode(p, 'G');
p = InsertRightNode(root->leftChild, 'C');
pp = p;
InsertLeftNode(p, 'E');
InsertRightNode(pp, 'F');

printf("前序遍历：");
PreOrder(root->leftChild, Visit);
printf("\n中序遍历：");
InOrder(root->leftChild, Visit);
printf("\n后序遍历：");
PostOrder(root->leftChild, Visit);
printf("\n");
preorder(root->leftChild);
find=Search(root,x);
if(find!=NULL)
printf("\n数据元素%c在二叉树中 \n",x);
else
printf("\n数据元素%c不在二叉树中 \n",x);

Destroy(&root);
return 0;

}

有兴趣的可以研究研究！一起学习！