二叉树遍历 - 数据结构

二叉树遍历 - 数据结构

1. 二叉树遍历

1.1 遍历算法：

1．先序遍历的递归算法定义：

　　若二叉树非空，则依次执行如下操作：

　　(1) 访问根结点；

　　(2) 遍历左子树；

　　(3) 遍历右子树。

2．中序遍历的递归算法定义：

　　若二叉树非空，则依次执行如下操作：

　　(1)遍历左子树；

　　(2)访问根结点；

　　(3)遍历右子树。

3．后序遍历得递归算法定义：

　　若二叉树非空，则依次执行如下操作：

　　(1)遍历左子树；

　　(2)遍历右子树；

　　(3)访问根结点。

4．层次遍历：层序遍历（level traversal）二叉树的操作定义为：

若二叉树为空，则退出，否则，

按照树的结构，从根开始自上而下，自左而右访问每一个结点，从而实现对每一个结点的遍历

例子：表达式a + b × (c- d)- e/ f



先序遍历：- + a * b - c d / e f

中序遍历：a + b * c - d- e / f

后续遍历：a b c d - × + e f /-

1.2遍历算法实现：

基本操作实现 stdafx.h：

[cpp] view plain copy

print?

// stdafx.h : include file for standard system include files,

// or project specific include files that are used frequently, but

// are changed infrequently

//

#pragma once

#include <stdio.h>

#include "stdlib.h"

#include <iostream>

using namespace std;

//宏定义

#define TRUE 1

#define FALSE 0

#define OK 1

#define ERROR 0

#define INFEASIBLE -1

#define OVERFLOW -2

#define STACKEMPTY -3

#define QUEUEEMPTY -3

#define MAX 10 // MAXIMUM STACK CONTENT

#define MAX_QUEUE 10 // MAXIMUM QUEUE CONTENT

typedef int Status;

typedef char ElemType;

//而二叉树

typedef struct BitNode{

ElemType data;

Status visited;

struct BitNode *lchild, *rchild; //左右孩子指针

}BitNode, *BiTree;

typedef BiTree StackElemType;

typedef BiTree QueueElemType;

class stack

{

private:

StackElemType arr[MAX];

int top;

public:

stack()

{

inItStack();

}

/************************************************************************/

/* 初始化栈 */

/************************************************************************/

void inItStack()

{

top=-1;

}

/************************************************************************/

/* 入栈 */

/************************************************************************/

void push(StackElemType a)

{

top++;

if(top < MAX) {

arr[top] = a;

} else {

cout<<"STACK FULL!!"<<top;

}

}

/************************************************************************/

/* 出栈 */

/************************************************************************/

StackElemType pop()

{

if(isEmpty()) {

cout<<"STACK IS EMPTY ";

return NULL;

} else {

StackElemType data=arr[top];

arr[top] = NULL;

top--;

return data;

}

}

/************************************************************************/

/* 出栈 */

/************************************************************************/

StackElemType getTop()

{

if(isEmpty()) {

cout<<"STACK IS EMPTY ";

return NULL;

} else {

return arr[top];

}

}

/************************************************************************/

/* 是否为空 */

/************************************************************************/

bool isEmpty()

{

if(top == -1) return true;

else return false;

}

};

class queue {

private:

QueueElemType elem[MAX_QUEUE] ; ///假设当数组只剩下一个单元时认为队满

int front; //队头指针

int rear; //队尾指针

public:

/************************************************************************/

/*

初始化

直接使用结构体指针变量，必须先分配内存地址，即地址的指针

*/

/************************************************************************/

void InitQueue()

{

front = rear = -1;

}

/************************************************************************/

/* 入队

*/

/************************************************************************/

void EnQueue(QueueElemType e)

{

if((rear+1)% MAX_QUEUE == front) exit(OVERFLOW);

rear = (rear + 1)% MAX_QUEUE;

elem[rear] = e;

}

/************************************************************************/

/* 出队

*/

/************************************************************************/

QueueElemType DeQueue()

{

if (QueueEmpty()) exit(QUEUEEMPTY);

front = (front+1) % MAX_QUEUE;

return elem[front];

}

/************************************************************************/

/* 获取队头元素内容

*/

/************************************************************************/

QueueElemType GetFront()

{

if ( QueueEmpty() ) exit(QUEUEEMPTY);

return elem[ (front+1) % MAX_QUEUE ];

}

/************************************************************************/

/* 判断队列Q是否为空

*/

/************************************************************************/

int QueueEmpty()

{

if( front==rear) return TRUE;

else return FALSE;

}

};

二叉树遍历


[cpp] view plain copy

print?

/ Test.cpp : Defines the entry point for the console application.

//

#include "stdafx.h"

/************************************************************************/

/* 算法：

*/

/************************************************************************/

Status CreateBiTree(BiTree &T);

Status PreOrderTraverse(BiTree &T) ;

Status visit(BiTree &T);

/************************************************************************/

/* 先序生成二叉树:

由于使用递归，要想退出函数，输入#的个数跟树的深度有关系

*/

/************************************************************************/

Status CreateBiTree(BiTree &T) {

char data ;

//scanf("%d", &data);

cin>> data;

if ( '#' == data ) T = NULL; //空格没法读入，所以使用#

else{

T = (BiTree) malloc(sizeof(BitNode));

if (!T) exit(OVERFLOW);

T->data = data;

CreateBiTree(T->lchild);

CreateBiTree(T->rchild);

}

return OK;

}

/************************************************************************/

/* 先序递归遍历二叉树:

*/

/************************************************************************/

Status PreOrderTraverse(BiTree &T) {

if(T) {

if(visit(T) )

if(PreOrderTraverse(T->lchild) )

if(PreOrderTraverse(T->lchild) ) return OK;

return ERROR;

}

return OK;

}

/************************************************************************/

/* 先序序循环遍历二叉树:

*/

/************************************************************************/

Status PreOrderTraverse_for(BiTree &T) {

BiTree root;

stack s;

s.inItStack();

root = T;

while(root || !s.isEmpty()) {

if(root) {

visit(root);

s.push(root);

root = root->lchild;

} else {

root = s.getTop();

s.pop();

root = root->rchild;

}

}

return OK;

}

/************************************************************************/

/* 层序遍历二叉树:

*/

/************************************************************************/

void LevelOrderTraverse(BiTree T)

{

BiTree root,TNode;

queue q;

root = T;

if(!root) exit(ERROR);

q.EnQueue(root);

while (!q.QueueEmpty())

{

TNode = q.DeQueue();

visit(TNode);

if (TNode->lchild) q.EnQueue(TNode->lchild);

if (TNode->rchild) q.EnQueue(TNode->rchild);

}

}

Status visit(BiTree &T){

if(T->visited != TRUE) {

T->visited = TRUE;

cout<<T->data;

return TRUE;

}

return FALSE;

}

void main(){

int pos =1 ;

BiTree T;

cout<<"- + a * b - c d / e f\n";

CreateBiTree( T);

//PreOrderTraverse(T);

//PreOrderTraverse_for(T);

LevelOrderTraverse(T);

}