二叉树递归和非递归遍历算法代码

#include<iostream>
#include<stack>
typedef struct node
{
int data;
struct node*leftptr;
struct node*rightptr;
}treenode;


void initdata(treenode *head)
{
head->data = 30;
head->leftptr = (treenode*)malloc(sizeof(treenode));
memset(head->leftptr, 0, sizeof(treenode));
head->leftptr->data = 20;


head->rightptr = (treenode*)malloc(sizeof(treenode));
memset(head->rightptr, 0, sizeof(treenode));
head->rightptr->data = 23;


head->leftptr->leftptr = (treenode*)malloc(sizeof(treenode));
memset(head->leftptr->leftptr, 0, sizeof(treenode));
head->leftptr->leftptr->data = 16;


head->leftptr->rightptr = (treenode*)malloc(sizeof(treenode));
memset(head->leftptr->rightptr, 0, sizeof(treenode));
head->leftptr->rightptr->data = 17;


head->rightptr->leftptr = (treenode*)malloc(sizeof(treenode));
memset(head->rightptr->leftptr, 0, sizeof(treenode));
head->rightptr->leftptr->data = 29;
head->rightptr->rightptr = (treenode*)malloc(sizeof(treenode));
memset(head->rightptr->rightptr, 0, sizeof(treenode));
head->rightptr->rightptr->data = 33;


}


void reserverfirst(treenode*head)
{
if (head == NULL)
{
return;
}
std::cout << head->data << std::endl;
if (head->leftptr!=NULL)
reserverfirst(head->leftptr);
if (head->rightptr!=NULL)
reserverfirst(head->rightptr);
}
std::stack<treenode*>ptrtree;
void reserveusestack(treenode*head)
{
if (head == NULL)
{
return;
}
if (head->rightptr != NULL)
{
ptrtree.push(head->rightptr);
}
}


#if 0
void preOrder2(treenode* pRoot)
{
std::stack<treenode*> s;
treenode *p = pRoot;


if (pRoot == NULL)
return;
while (p != NULL || !s.empty())
{
while (p != NULL)
{
std::cout << p->data << " ";
s.push(p);
p = p->leftptr;
}
if (!s.empty())
{
p = s.top();
s.pop();
p = p->rightptr;
}
}
}


#endif




int main()
{
treenode*head = (treenode*)malloc(sizeof(treenode));
memset(head, 0, sizeof(treenode));
initdata(head);
//reserverfirst(head);
preOrder2(head);
return 0;
}