链表队列与二叉树基本操作

原创 2007年09月25日 00:00:00

/*********************************
 * file : m.cpp
 * 功能: 1,建链表队列
         2,定义二叉树
   3,对二叉树进行中序,后序遍历
   4,对二叉树进行层次遍历
   5,计算二叉树的叶子数目
   6,计算二叉树的深度
   7,实现复制二叉树
   8,删除二叉树
 * 创建日期:2007-9-24
*********************************/

#include <iostream>
using namespace std;

template <typename T>
class qnode
{
public:
 qnode()
 {
  next = 0;
 }
 qnode(const T &v):value(v)
 {
  next = 0;
 }

public:
 T value;
 qnode<T> *next;
};

template <typename T>
class Quen
{
public:
 qnode<T> *front;
 qnode<T> *rear;

public:
 Quen():front(0),rear(0)
 {}
 Quen(const T &v)
 {
  qnode<T> *p = new qnode<T>(v);
  front = p;
  rear = p;
 }

 void push(const T &v)
 {
  qnode<T> *p = new qnode<T>(v);
  rear->next = p;
  rear = p;
 }
 
 void pop()
 {
  if(empty() == false)
  {
   qnode<T> *p = front;
   front = front->next;
   delete p;
  }
  else
   cout << "Queen empty!" << endl;
 }

 bool empty()
 {
  return !((front != 0) && (rear != 0));
 }

 T getfront()
 {
  return front->value;
 }
};

// 以上为链表队列的实现
// 以下为二叉树的遍历操作

template <typename T>
class tnode
{
public:
 tnode():left(0), right(0)
 {}
 tnode(const T &v, tnode<T> *lef =  0, tnode<T> *rig = 0):value(v),left(lef),right(rig)
 {}

public:
 T value;
 tnode<T> *left;
 tnode<T> *right;
};

//中序遍历
template <typename T>
void InOrder(tnode<T> *root)
{
 if( root != 0)
 {
  InOrder(root->left);
  cout << root->value << ' ';
  InOrder(root->right);
 }
}

// 后序遍历
template <typename T>
void PostOrder(tnode<T> *root)
{
 if( root != 0)
 {
  PostOrder(root->left);
  PostOrder(root->right);
  cout << root->value << ' ';
 }
}

// 借助链表队列实现迭代层次遍历
template <typename T>
void level(tnode<T> *root)
{
 Quen<tnode<T> *> *q = new Quen<tnode<T> *>(root);
 tnode<T> *p;

// q->push(root);
 while(q->empty() == false)
 {
  p = q->getfront();
  cout << p->value << ' ';
  if( p->left != 0 )
   q->push(p->left);
  if( p->right != 0 )
   q->push(p->right);
  q->pop();
 }
}

// 计算叶子数目
template <typename T>
void countleaf(tnode<T> *root, int &count)
{
 if( root != 0 )
 {
  if( (root->left == 0) && (root->right == 0))
   count++;

  countleaf(root->left, count);
  countleaf(root->right, count);
 }
}

// 计算树高度
template <typename T>
int depth(tnode<T> *root)
{
 int ldepth, rdepth, ndepth;
 if( root->left == 0 )
  ldepth = -1;
 else
  ldepth = depth(root->left);

 if( root->right == 0 )
  rdepth = -1;
 else
  rdepth = depth(root->right);

 ndepth = 1 + ((ldepth > rdepth) ? ldepth : rdepth);

 return ndepth;
}

// 复制二叉树
template <typename T>
tnode<T> *copytree( tnode<T> *root )
{
 tnode<T> *lp, *rp, *np;
 if( root == 0 )
  return 0;
 lp = copytree( root->left );
 rp = copytree( root->right );
 np = new tnode<T>(root->value, lp, rp);

 return np;
}

// 删除二叉树
template <typename T>
void deltree(tnode<T> *root)
{
 if( root != 0 )
 {
  deltree(root->left);
  deltree(root->right);
  delete root;
 }
}

int main()
{
 tnode<int> *p, *root;
 
 root = new tnode<int>(1);
 root = new tnode<int>(11, 0, root);
 p = new tnode<int>(4);
 root->left = p;
 p = new tnode<int>(2);
 p = new tnode<int>(6, 0, p);
 root = new tnode<int>(5, p, root);

 InOrder(root);
 cout << endl;

 PostOrder(root);
 cout << endl;

 level(root);
 cout << endl;

 int count = 0;
 countleaf(root, count);
 cout << "count = " << count << endl;

 cout << "depth = " << depth(root) << endl;

 level(copytree(root));
 cout << endl;
 
 //deltree(root);
// level(root);
 cout << endl;

 return 0;

 

输出:

6 2 5 4 11 1
2 6 4 1 11 5
5 6 11 2 4 1
count = 3
depth = 2
5 6 11 2 4 1

版权声明:本文为博主原创文章,未经博主允许不得转载。

相关文章推荐

使用C++链表来实现二叉树的存储和基本操作

1、创建Node.h 定义链表的节点 #ifndef NODE_H #define NODE_H class Node{ public: Node(); Node* searchNo...

数据结构--二叉树(链表)基本操作

#include "StdAfx.h" #include #include typedef struct tree{ int key; str...

二叉树的构造(二叉链表)、遍历以及基本操作

二叉树的构造(二叉链表)、遍历以及基本操作 #include #include #include using namespace std; typedef char Elemtyp...

c语言实现二叉树的基本操作--二叉链表存储

利用二叉链表存储,并且利用递归的方法实现二叉树的遍历(前序遍历、中序遍历和后续遍历)操作。 c语言具体实现代码如下: #include #include #include typedef int...

二叉树遍历非递归算法所用到的栈以及层次遍历所用到的队列的基本操作算法的实现

栈的基本操作算法的实现 基本数据结构 typedef struct BiNode {  char data;  struct BiNode *lchild,*rchild; ...

数据结构之链表队列基本操作

#include #include #include #include using namespace std; #define TRUE 1 #define FALSE 0 #define OK 1...

二叉树的基本操作

二叉树的基本操作

内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

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