数据结构的C实现_二叉树的非递归遍历和层序遍历

原创 2012年03月22日 18:46:36
//编译环境G++
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
using namespace std;

//////////////TreeNode///////////////////////////////////////////
typedef struct _TreeNode
{
    char key;
    struct _TreeNode *Lc;
    struct _TreeNode *Rc;
}TreeNode;
////////////////////////////////////////////////////////////////

////////stack//////////////////////////////////////////////////
//Record作为栈结点的一个域,存储树结点的访问信息
typedef struct _StackRecord
{
    bool leftvisit;
    bool rightvisit;
    bool currentvisit;
    TreeNode *treenode;
}StackRecord;

//初始化Record
void InitStackRecord(StackRecord &s_record)
{
    s_record.leftvisit=false;
    s_record.rightvisit=false;
    s_record.currentvisit=false;
    s_record.treenode=NULL;
}

//栈结点
typedef struct _StackNode
{
    StackRecord record;
    struct _StackNode *next;
}StackNode;

//栈
typedef struct _Stack
{
    StackNode *top;
}Stack;

void InitStack(Stack &s)
{
    s.top=NULL;
}

bool isemptyS(Stack &s)
{
    if(s.top==NULL)
    return 1;
    return 0;
}

void Push(Stack &s,StackRecord e)
{
    StackNode *node=(StackNode*)malloc(sizeof(StackNode));
    node->record=e;
    node->next=NULL;
    node->next=s.top;
    s.top=node;
}

bool Pop(Stack &s,StackRecord &e)
{
    if(isemptyS(s)) return false;
    else
    {
        StackNode *node=s.top;
        e=node->record;
        s.top=node->next;
        free(node);
        return true;
    }
}

void DestroyStack(Stack &s)
{
    StackRecord temp;InitStackRecord(temp);
    while(Pop(s,temp)){}
}
///////////////////////////////////////////////////////////////////////////

////Queue//////////////////////////////////////////////////////////////////
//队列结点
typedef struct _QNode
{
    TreeNode *treenode;
    struct _QNode *next;
}QNode;

//队列
typedef struct _Queue
{
    QNode *front;
    QNode *rear;
}Queue;

void InitQueue(Queue &Q)
{
    Q.front=NULL;
    Q.rear=NULL;
}

bool isemptyQ(Queue &Q)
{
    if(Q.front==NULL)
    return 1;
    return 0;
}
void EnQueue(Queue &Q,TreeNode *_treenode)
{
    //printf("EnQueue: %c\n",_treenode->key);
    QNode *s=(QNode*)malloc(sizeof(QNode));
    s->treenode=_treenode;
    s->next=NULL;
    if(isemptyQ(Q))
    {
        Q.front=s;
        Q.rear=s;
        return;
    }
    else
    {
        Q.rear->next=s;
        Q.rear=s;
    }
}

bool DeQueue(Queue &Q,TreeNode *&treenode)
{
    if(isemptyQ(Q))
    return false;
    else
    {
        QNode *node=Q.front;
        treenode=node->treenode;
        Q.front=node->next;
        if(Q.front==NULL)
        {
            Q.rear=NULL;
        }
        free(node);
    }
    return true;
}

void DestroyQueue(Queue &Q)
{
    TreeNode *temp;
    while(DeQueue(Q,temp)){}
}
/////////////////////////////////////////////////////////////////////////
//非递归先序遍历
void NRPreOrderTravserse(TreeNode *T)
{
    Stack stack;
    InitStack(stack);
    if(T!=NULL)
    {
        StackRecord record;
        InitStackRecord(record);
        record.treenode=T;
        Push(stack,record);
        while(!isemptyS(stack))
        {
            Pop(stack,record);
            //check current
            if(!record.currentvisit)
            {
                printf("%c ",record.treenode->key);
                record.currentvisit=true;
                Push(stack,record);
                continue;
            }

            //check left
            if(!record.leftvisit)
            {
                record.leftvisit=true;
                Push(stack,record);
                if(record.treenode->Lc!=NULL)
                {
                StackRecord leftrecord;
                InitStackRecord(leftrecord);
                leftrecord.treenode=record.treenode->Lc;
                Push(stack,leftrecord);
                }
                continue;
            }
            //check right
            if(!record.rightvisit)
            {
                record.rightvisit=true;
                Push(stack,record);
                if(record.treenode->Rc!=NULL)
                {
                StackRecord rightrecord;
                InitStackRecord(rightrecord);
                rightrecord.treenode=record.treenode->Rc;
                Push(stack,rightrecord);
                }
                continue;
            }
        }
    }
    DestroyStack(stack);
}

//非递归中序遍历
void NRInOrderTravserse(TreeNode *T)
{
    Stack stack;
    InitStack(stack);
    if(T!=NULL)
    {
        StackRecord record;
        InitStackRecord(record);
        record.treenode=T;
        Push(stack,record);
        while(!isemptyS(stack))
        {
            Pop(stack,record);
            //check left
            if(!record.leftvisit)
            {
                record.leftvisit=true;
                Push(stack,record);
                if(record.treenode->Lc!=NULL)
                {
                StackRecord leftrecord;
                InitStackRecord(leftrecord);
                leftrecord.treenode=record.treenode->Lc;
                Push(stack,leftrecord);
                }
                continue;
            }
            //check current
            if(!record.currentvisit)
            {
                printf("%c ",record.treenode->key);
                record.currentvisit=true;
                Push(stack,record);
                continue;
            }
            //check right
            if(!record.rightvisit)
            {
                record.rightvisit=true;
                Push(stack,record);
                if(record.treenode->Rc!=NULL)
                {
                StackRecord rightrecord;
                InitStackRecord(rightrecord);
                rightrecord.treenode=record.treenode->Rc;
                Push(stack,rightrecord);
                }
                continue;
            }
        }
    }
    DestroyStack(stack);
}

//非递归后序遍历
void NRPostOrderTravserse(TreeNode *T)
{
    Stack stack;
    InitStack(stack);
    if(T!=NULL)
    {
        StackRecord record;
        InitStackRecord(record);
        record.treenode=T;
        Push(stack,record);
        while(!isemptyS(stack))
        {
            Pop(stack,record);
            //check left
            if(!record.leftvisit)
            {
                record.leftvisit=true;
                Push(stack,record);
                if(record.treenode->Lc!=NULL)
                {
                StackRecord leftrecord;
                InitStackRecord(leftrecord);
                leftrecord.treenode=record.treenode->Lc;
                Push(stack,leftrecord);
                }
                continue;
            }

            //check right
            if(!record.rightvisit)
            {
                record.rightvisit=true;
                Push(stack,record);
                if(record.treenode->Rc!=NULL)
                {
                StackRecord rightrecord;
                InitStackRecord(rightrecord);
                rightrecord.treenode=record.treenode->Rc;
                Push(stack,rightrecord);
                }
                continue;
            }

            //check current
            if(!record.currentvisit)
            {
                printf("%c ",record.treenode->key);
                record.currentvisit=true;
                Push(stack,record);
                continue;
            }
        }
    }
    DestroyStack(stack);
}

//层序遍历,利用队列
void LevelTravserse(TreeNode *T)
{
    Queue Q;
    InitQueue(Q);
    //EnQueue(Q,T);
    if(T!=NULL)
    {
        EnQueue(Q,T);
        while(!isemptyQ(Q))
        {
            TreeNode *currentTreeNode;
            DeQueue(Q,currentTreeNode);

            if(currentTreeNode->Lc!=NULL)
            {
                EnQueue(Q,currentTreeNode->Lc);
            }
            if(currentTreeNode->Rc!=NULL)
            {
                EnQueue(Q,currentTreeNode->Rc);
            }
            printf("%c ",currentTreeNode->key);
        }
    }
    DestroyQueue(Q);
}

int main()
{
    TreeNode *tree,*p;
    p=(TreeNode*)malloc(sizeof(TreeNode));
    p->key='A';p->Lc=NULL;p->Rc=NULL;
    tree=p;

    p=(TreeNode*)malloc(sizeof(TreeNode));
	p->key='B';
	tree->Lc=p;

	p=(TreeNode*)malloc(sizeof(TreeNode));
	p->key='C';
	p->Lc=NULL;
	p->Rc=NULL;
	tree->Lc->Lc=p;

	p=(TreeNode*)malloc(sizeof(TreeNode));
	p->key='D';
	p->Lc=NULL;
	p->Rc=NULL;
	tree->Lc->Rc=p;

	p=(TreeNode*)malloc(sizeof(TreeNode));
	p->key='E';
	p->Lc=NULL;
	tree->Rc=p;

	p=(TreeNode*)malloc(sizeof(TreeNode));
	p->key='F';
	p->Lc=NULL;
	p->Rc=NULL;
	tree->Rc->Rc=p;

	NRPreOrderTravserse(tree);printf("\n");
	NRInOrderTravserse(tree);printf("\n");
	NRPostOrderTravserse(tree);printf("\n");
	LevelTravserse(tree);

  return 0;
}


图像检索相关论文

图像检索相关论文
  • YiLiang_
  • YiLiang_
  • 2017年03月07日 09:59
  • 2710

Image Retrieval

Papers Learning High-level Image Representation for Image Retrieval via Multi-Task DNN using Click...
  • hpb21
  • hpb21
  • 2016年12月05日 00:25
  • 2974

详解BN(Batch Normalization)算法

详解Batch Normalization 原文地址:http://blog.csdn.net/hjimce/article/details/50866313 作者:hjimce 一、背景意义 本...
  • lx10271129
  • lx10271129
  • 2018年01月05日 19:42
  • 43

论文解读 Saliency Weighted Convolutional Features for Instance Search

论文解读 Saliency Weighted Convolutional Features for Instance Search 显著性检测应用于实例检索,对INSTRE数据集有明显的提升...
  • lx10271129
  • lx10271129
  • 2018年01月03日 22:02
  • 35

Bags of Local Convolutional Features for Scalable Instance Search 论文解读

利用BOW的思路来聚合CNN特征,形成最终的image 描述,用于实例检索任务
  • lx10271129
  • lx10271129
  • 2018年01月03日 17:34
  • 36

图像检索相关论文

图像检索相关论文
  • YiLiang_
  • YiLiang_
  • 2017年03月07日 09:59
  • 2710

CVPR 2016

ORAL SESSION Image Captioning and Question Answering Monday, June 27th, 9:00AM - 10:05AM. T...
  • ahong286286
  • ahong286286
  • 2016年11月02日 23:44
  • 1492

CVPR2014年录用论文

Preliminary List of Accepted Papers Authors, please contact the Web Chairs with any needed upda...
  • u010545732
  • u010545732
  • 2014年03月07日 16:37
  • 7305

【数据结构与算法】二叉树的层序遍历

转载请注明出处: http://blog.csdn.net/ns_code/article/details/13169703     前面有篇博客详细分析了二叉树三种遍历(前序、中序...
  • zhangxiao93
  • zhangxiao93
  • 2016年03月12日 11:08
  • 3824

层序遍历二叉树(不借助vector或deque,用C语言实现)

前面几篇文章中,我们对二叉树的层序遍历和层序打印都是借助vector或deque来实现的,本文只通过C语言来实现,代码如下:#include using namespace std; #define...
  • cyuyanenen
  • cyuyanenen
  • 2016年06月02日 19:36
  • 1672
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:数据结构的C实现_二叉树的非递归遍历和层序遍历
举报原因:
原因补充:

(最多只允许输入30个字)