二叉树及二叉搜索树

最新推荐文章于 2021-04-10 14:23:26 发布
最新推荐文章于 2021-04-10 14:23:26 发布
阅读量3.1k 收藏 1
点赞数
分类专栏： 数据结构与算法 文章标签： tree null delete insert 数据结构 存储

 

第十章  二叉树

学习目的

学习广义树的定义，熟悉树的有关术语

理解树是一种非线性的数据结构

理解很多有关树的操作都涉及到二叉树，所谓二叉树是指每个父结点最多包含两个子结点

掌握一棵n个结点的完全二叉树的高度是 int(log2n),这样的对是沿着从根开始的路径来寻找数据的

理解树的退化，面成为像链表一样的高效的存储结构

学习二叉树的实现，使用tnode对象来保存数据以及指向左、右子树的指针

理解6种树扫描的递归算法，最常用的3种算法是：中序，后序和前序遍历

学习使用队列逐层扫描树的算法

通过学习一系列实际应用，熟悉二叉树的相关算法

理解二叉搜索树的结构。理解二叉树按照结点的值，而不是结点的位置来保存数据。熟悉它的ADT

注意二叉搜索树是关联容器的特例

学习树的iterator类的实现

10.1树结构

根结构：在一棵树中，有一个唯一的起始点，称为根结点。每一个结点包含一个值和零个或多个指向

        后继的结点的指针。

边：从父结点指向子结点的连接称为边。

叶子结点：没有子结点的称为叶子结点。

层次：任何结点到它或其子结点只有唯一的一条路径。从根结点到任何结点的路径长度为每一个结点

定义了一种度量，称为层次。根结点的层次是0

树的高度:定义为树中所有结点层次的最大值.高度的概念也可以用路径来解释.树的高度是所有从根

结点到其他结点的路径中长度的最大值.

建立二叉树

二叉树由动态分配的结点对象构成，这些结点对象的指针指向自己的子结点。

树图

 

见代码chapter10.1

代码chapter10.2的树图

功能:建立如下二叉树,前序遍历,按层次遍历二叉树,拷贝二叉树,删除树

 

树图2

 

10.5 二叉搜索树

将二叉树设计成在能够存储大量数据的同时,又能为程序员提供方便高效的访问和更新元素的操作.最终得到的容器结构为二叉搜索树,......是所有关联容器的原型.

按元素值来存储的关联容器.

二叉树是由各个结点组成的数据结构,从根结点到其他结点之间只有唯一的路径.为了将二叉树设计成有效的存储容器,我们必须实现一种次序,把结点的值与它所处的路径联系起来.这种次序使得我们可以根据值来找到对应元素的位置.由于这个原因,这种存储容器称为二叉搜索树.

排序:对于每个结点,其左子树的所有结点的值都比它小,而其右子树中所有结点的值都比它大.

10.5.3二叉搜索树中的数据查找

   每个结点都有一个唯一的路径.这个路径既可以用来插入,也可以用来查找元素.比较当前结点与待查找的元素,如果相等,则找到元素;否则,如果待查找元素小于当前结点,则查找左子树;如果大于当前结点,则查找右子树.如果最后达到空树,则称没有找到该值.

见代码chapter10.5

chapter10.1

// Tnode.h

 

// 表示ercas二叉树的一个结点

template<class T>   class Tnode

{

public:

 T nodeValue;

 Tnode * left, *right; // 左右子结点指针

 // 默认的构造函数，数据初始化

 Tnode(){}

 // 初始化数据成员

 Tnode(const T & item, Tnode<T> * lptr = NULL, Tnode<T> * rptr = NULL)

  : nodeValue(item), left(lptr),right(rptr)

 {}

 

};

// main.cpp

 

#include <iostream>

#include "Tnode.h"

#include <string>

using namespace std;

template<class T>  void pre_order(Tnode<T> * node);

int main()

 {

     Tnode<int> * root, * p, * q, * r;

  p = new Tnode<int>(20);

     q = new Tnode<int>(40);

  r = new Tnode<int>(30,q );

  root = new Tnode<int>(10,p,r);

  pre_order( root );

  return 0;

 }

template<class T>  void pre_order(Tnode<T> * node)

{

      if( node != NULL )

   {

    cout << node->nodeValue << endl;

    pre_order(node->left);

    pre_order(node->right);

   }

}

 

/chapter10.2

// Tnode.h

 

#ifndef  BINTREE_H

#define  BINTREE_H

// 表示ercas二叉树的一个结点

#include <iostream>

using std::cout;

using std::endl;

template<class T>   class Tnode

{

 

public:

 T nodeValue;

 Tnode * left, *right; // 左右子结点指针

 // 默认的构造函数，数据不有初始化

 Tnode(){}

 // 初始化数据成员

 Tnode(const T & item, Tnode<T> * lptr = NULL, Tnode<T> * rptr = NULL)

  : nodeValue(item), left(lptr),right(rptr)

 {}

 void setLeftNode(Tnode<T> * child_left)

 { left = child_left; }

 void setRightNode( Tnode<T> * child_right )

 { right = child_right; }

 ~Tnode()

 { cout << "delete node that's value is " << nodeValue << endl; }

 

};

 

template<class T>  class BinaryTree

{

public:

 BinaryTree() : root(NULL)

 { count_leaf = 0;idepth=0;}

 void build_tree();

 //前序遍历二叉树

    void pre_order();

 // 按层次遍历二叉树

 void level_order()

 { level_order(root); }

 // 叶子结点计数

 int getCountLeaf();

 // 计算树的深度

 int depth();

 // 得到根结点

 const Tnode<T> * getRoot()

 { return root; }

 // 设置根结点

 void setRoot( Tnode<T> * root_pa )

 {  root = root_pa; }

    Tnode<T> * copy_tree(const Tnode<T> * source);

 void delete_tree()

 { delete_tree(root); }

protected:

 Tnode<T> * root;

 int count_leaf;

 int idepth;

    void pre_order(Tnode<T> * node);

 void level_order(Tnode<T> * node);

 void getCountLeaf(Tnode<T> * node);

 int depth(Tnode<T> * node);

 void delete_tree(Tnode<T> * node);

};

 

#endif

 

// BinaryTree.cpp

 

 

#include "Tnode.h"

#include <deque>

using std::max;

 

 

template<class T> void BinaryTree<T>::build_tree()

{

 Tnode<char> * p,*pr,* lt, * rt, * oldp;

 lt = new Tnode<char>('G');

 p = new Tnode<char>('E',lt); // E子树

 lt = new Tnode<char>('D'); // E的兄弟结点

 p = new Tnode<char>('B',lt,p); // B 子树

    lt = new Tnode<char>('H');

 rt = new Tnode<char>('J');

 pr = new Tnode<char>('F',lt,rt); // F子树

    pr = new Tnode<char>('C',NULL,pr);// C子树

 p = new Tnode<char>('A',p, pr);

 root = p;

 

}

template<class T>  void BinaryTree<T>::pre_order()

{

      pre_order( root );

}

template<class T>  void BinaryTree<T>::pre_order(Tnode<T> * node)

{

      if( node != NULL )

   {

    cout << node->nodeValue << endl;

    pre_order(node->left);

    pre_order(node->right);

   }

}

template<class T>  void BinaryTree<T>::level_order(Tnode<T> * node)

{

 using std::deque;

 deque<Tnode<T> * >  dq;

 Tnode<T> * temp;

 dq.push_back( node );

 

 while ( !dq.empty() )

 {

  temp = dq.front();

  dq.pop_front();

  cout << temp->nodeValue;

  if (NULL != temp->left )

   dq.push_back(temp->left);

  if (NULL != temp->right )

   dq.push_back(temp->right);

 } 

}

template<class T>  int BinaryTree<T>::getCountLeaf()

{

    getCountLeaf( root );

 return count_leaf;

}

template<class T>  void BinaryTree<T>::getCountLeaf(Tnode<T> * node)

{  

      if( node != NULL )

   {

          if ( NULL == node->left && NULL == node->right )

       count_leaf++;

    getCountLeaf(node->left);

    getCountLeaf(node->right);

   }

}

template<class T>  int BinaryTree<T>::depth()

{

 int d = depth(root);

 return d;

}

template<class T>  int BinaryTree<T>::depth(Tnode<T> * node)

{

 if ( NULL == node )

  return -1;

  return 1 + max(depth(node->left),depth(node->right));

}

template<class T> Tnode<T> *  BinaryTree<T>::copy_tree(const Tnode<T> * source)

{

        if ( NULL == source )

    return  NULL;

  

  Tnode<T> * p = new Tnode<T>( source->nodeValue );

  Tnode<T> * pl, * pr;

  pl = copy_tree(source->left );

  p->setLeftNode( pl );

  pr = copy_tree(source->right);

  p->setRightNode( pr );

  return p;

}

 

template<class T> void BinaryTree<T>::delete_tree(Tnode<T> * node)

{

 

 // 采用后序遍历,保证先删除子结点，再删除父结点

 if ( NULL != node )

 {

         delete_tree(node->left);

   delete_tree(node->right);

   delete node;

 }

 

}

 

// main.cpp

#include <iostream>

 

#include "Tnode.h"

#include "BinaryTree.cpp"

#include <string>

using namespace std;

 

int main()

 {

     BinaryTree<char> bintree;

  bintree.build_tree();

  int count = bintree.getCountLeaf();

  cout << "leaf count = " << count << endl;

  int d = bintree.depth();

  cout << "depth of tree = " << d << endl;

  BinaryTree<char> tree_backup;

  Tnode<char> * p = tree_backup.copy_tree( bintree.getRoot() );

  tree_backup.setRoot( p );

  tree_backup.level_order();

  tree_backup.pre_order();

  cout << "the address of bintree root = " << bintree.getRoot() << endl;

  cout << " the address of tree_backup = " << tree_backup.getRoot() << endl;

  bintree.delete_tree();

  return 0;

 }

/

chapter10.5二叉搜索树 插入加查找

 

#ifndef  BINTREE_H

#define  BINTREE_H

// 表示ercas二叉树的一个结点

#include <iostream>

using std::cout;

using std::endl;

template<class T>   class Tnode

{

 

public:

 T nodeValue;

 Tnode * left, *right; // 左右子结点指针

 // 默认的构造函数，数据不有初始化

 Tnode(){}

 // 初始化数据成员

 Tnode(const T & item, Tnode<T> * lptr = NULL, Tnode<T> * rptr = NULL)

  : nodeValue(item), left(lptr),right(rptr)

 {}

 void setLeftNode(Tnode<T> * child_left)

 { left = child_left; }

 void setRightNode( Tnode<T> * child_right )

 { right = child_right; }

 ~Tnode()

 { cout << "delete node that's value is " << nodeValue << endl; }

 

};

 

template<class T>  class BinaryTree

{

public:

 BinaryTree() : root(NULL)

 { count_leaf = 0;idepth=0;}

 void build_tree();

 //前序遍历二叉树

    void pre_order();

 // 按层次遍历二叉树

 void level_order()

 { level_order(root); }

 // 叶子结点计数

 int getCountLeaf();

 // 计算树的深度

 int depth();

 // 得到根结点

 const Tnode<T> * getRoot()

 { return root; }

 // 设置根结点

 void setRoot( Tnode<T> * root_pa )

 {  root = root_pa; }

    Tnode<T> * copy_tree(const Tnode<T> * source);

 void delete_tree()

 { delete_tree(root); }

 void insert(const T & t)

 {    insert( t, root, NULL, 1); 

 }

 bool find(const T & t)

 {  return find(t,root); }

protected:

 Tnode<T> * root;

 int count_leaf;

 int idepth;

    void pre_order(Tnode<T> * node);

 void level_order(Tnode<T> * node);

 void getCountLeaf(Tnode<T> * node);

 int depth(Tnode<T> * node);

 void delete_tree(Tnode<T> * node);

 void insert(const T & t, Tnode<T> * current, Tnode<T> * parent, int flag);

 bool find(const T & t, Tnode<T> * current);

 

};

 

#endif

 

// BinaryTree.cpp

 

#include "Tnode.h"

#include <deque>

using std::max;

 

 

template<class T> void BinaryTree<T>::build_tree()

{

 Tnode<char> * p,*pr,* lt, * rt, * oldp;

 lt = new Tnode<char>('G');

 p = new Tnode<char>('E',lt); // E子树

 lt = new Tnode<char>('D'); // E的兄弟结点

 p = new Tnode<char>('B',lt,p); // B 子树

    lt = new Tnode<char>('H');

 rt = new Tnode<char>('J');

 pr = new Tnode<char>('F',lt,rt); // F子树

    pr = new Tnode<char>('C',NULL,pr);// C子树

 p = new Tnode<char>('A',p, pr);

 root = p;

 

}

template<class T>  void BinaryTree<T>::pre_order()

{

      pre_order( root );

}

template<class T>  void BinaryTree<T>::pre_order(Tnode<T> * node)

{

      if( node != NULL )

   {

    cout << node->nodeValue << endl;

    pre_order(node->left);

    pre_order(node->right);

   }

}

template<class T>  void BinaryTree<T>::level_order(Tnode<T> * node)

{

 using std::deque;

 deque<Tnode<T> * >  dq;

 Tnode<T> * temp;

 dq.push_back( node );

 

 while ( !dq.empty() )

 {

  temp = dq.front();

  dq.pop_front();

  cout << temp->nodeValue;

  if (NULL != temp->left )

   dq.push_back(temp->left);

  if (NULL != temp->right )

   dq.push_back(temp->right);

 } 

}

template<class T>  int BinaryTree<T>::getCountLeaf()

{

    getCountLeaf( root );

 return count_leaf;

}

template<class T>  void BinaryTree<T>::getCountLeaf(Tnode<T> * node)

{  

      if( node != NULL )

   {

          if ( NULL == node->left && NULL == node->right )

       count_leaf++;

    getCountLeaf(node->left);

    getCountLeaf(node->right);

   }

}

template<class T>  int BinaryTree<T>::depth()

{

 int d = depth(root);

 return d;

}

template<class T>  int BinaryTree<T>::depth(Tnode<T> * node)

{

 if ( NULL == node )

  return -1;

  return 1 + max(depth(node->left),depth(node->right));

}

template<class T> Tnode<T> *  BinaryTree<T>::copy_tree(const Tnode<T> * source)

{

        if ( NULL == source )

    return  NULL;

  

  Tnode<T> * p = new Tnode<T>( source->nodeValue );

  Tnode<T> * pl, * pr;

  pl = copy_tree(source->left );

  p->setLeftNode( pl );

  pr = copy_tree(source->right);

  p->setRightNode( pr );

  return p;

}

 

template<class T> void BinaryTree<T>::delete_tree(Tnode<T> * node)

{

 

 // 采用后序遍历,保证先删除子结点，再删除父结点

 if ( NULL != node )

 {

         delete_tree(node->left);

   delete_tree(node->right);

   delete node;

 }

 

}

template<class T>  

void BinaryTree<T>::insert(const T & t, Tnode<T> * current, Tnode<T> * parent, int flag)

{

     if ( NULL == t )

       return ;

  if ( NULL == root )

  {

    root = new Tnode<T>(t);

    return ;

  }

  if ( NULL == current )

  {

          Tnode<T> * p = new Tnode<T>(t);

    flag?( parent->left = p):(parent->right = p);

    return;

  }

  if( t<current->nodeValue)

   insert(t, current->left,current,1);

  else if (t>current->nodeValue)

   insert(t, current->right,current,0);

}

template<class T>  bool BinaryTree<T>::find(const T & t, Tnode<T> * current)

{

 if (NULL == current)

  return false;

 if (t == current->nodeValue)

  return true;

 else if (t < current->nodeValue)

       return find(t,current->left);

            else

             return find(t,current->right);

}

//main.cpp

 

#include <iostream>

#include "Tnode.h"

#include "BinaryTree.cpp"

#include <string>

using namespace std;

 

int main()

 {

  BinaryTree<int> binSearchTree;

  binSearchTree.insert(30);

  binSearchTree.insert(25);

  binSearchTree.insert(35);

  binSearchTree.insert(10);

  binSearchTree.insert(32);

  binSearchTree.insert(37);

  binSearchTree.insert(15);

  binSearchTree.level_order();

  bool b = binSearchTree.find( 10 );

  b?( cout << "exist/n" ):(cout << "does't exist/n");

  b = binSearchTree.find( 8 );

  b?( cout << "exist/n" ):(cout << "does't exist/n");

  return 0;

 }

 

 

 

 

 

 

 

 


 

 

 

 

 

 

dreamcs
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二叉树与二叉查找树
Carl_helloworld
11-27 561
二叉树与二叉查找树。
二叉树--二叉搜索树
Hy_2267的博客
04-11 677
编号2的二叉树中，叶子节点全都在最底层，除了叶子节点之外，每个节点都有左右两个子节点，这种二叉树就叫做满二叉树。 叶子节点都在最底下两层，最后一层的叶子节点都靠左排列，并且除了最后一层，其他层的节点个数都要达到最大，这种二叉树叫做完全二叉树。 如何表示（或者存储）一棵二叉树？ 链式存储法：一种是基于指针或者引用的二叉链式存储法 基于数组的顺序存储法：一种是基于数组的顺序存储法 把根节点存储在下标i = 1的位置，那左子节点存储在下标2 * i = 2的位置，右子节点存储在2 * i + 1..
二叉树总结
weixin_39759634的博客
01-22 249
按照labuladong做了二叉树的题，在此稍微总结一下 1.二叉树的定义： python class TreeNode: def __init__(self, val=0, left=None, right=None): self.val = val self.left = left self.right = right c++ struct TreeNode { int val; TreeNode
二叉树 与 二叉搜索树
iteye_17833的博客
05-26 123
                                            二叉树 与 二叉搜索树   指针与引用： int count = 18； int* ptr =  &amp;count; int count = 18; int&amp; pcount = count;   创建二叉树与创建二叉搜索树        前者：只是为了熟悉课本知识     ...
数据结构----二叉树与二叉搜索树
Stephen GS的博客
08-27 1097
数据结构----二叉树与二叉搜索树
二叉搜索树
YANG
10-26 796
二叉搜索树的操作：插入，删除，查找，遍历 二叉搜索树也称有序搜索树，它具有如下的性质： 1.每个结点都有一个作为搜索依据的关键码(key)，每个结点的关键码都不一样 2.左子树上所有结点的关键码都小于当前根节点的关键码 3.右子树上所有结点的关键码都大于当前根节点的关键吗 4.左右子树都是二叉搜索树 二叉树的操作：插入，删除，查找，遍历 一、插入---Insert 当进行插入后，不能破坏二叉搜索树的结构，因此
二叉树的二叉搜索表示.rar_二叉搜索树_二叉树的二叉搜索
09-22
二叉搜索树（Binary Search Tree，BST）是一种特殊类型的二叉树，它的每个节点都具有以下特性： 1. **左子树性质**：左子树上所有节点的值都小于当前节点的值。 2. **右子树性质**：右子树上所有节点的值都大于当前...
二叉树与二叉搜索树的理解
Starry Sea
04-10 1116
树(tree)是一种抽象数据类型(ADT)，用来模拟具有树状结构性质。 它是由n (n≥0) 个有限节点通过连接它们的边组成具有层次关系的集合。 把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。 树由多种，一个节点有两个以上子节点的树，称为多路树，而每个节点最多只能由两个子节点的树，称为二叉树。 ...
算法面试通关40讲完整课件 18-20 树、二叉树、二叉搜索树
07-06
在算法面试中，树、二叉树以及二叉搜索树是非常关键的数据结构，它们在解决各种问题时展现出高效和灵活性。下面将详细讲解这些概念及其重要性质。 **1. 树 (Tree)** 树是一种非线性的数据结构，由一个或多个节点...
C语言判定一棵二叉树是否为二叉搜索树的方法分析
12-31
本文实例讲述了C语言判定一棵二叉树是否为二叉搜索树的方法。分享给大家供大家参考，具体如下： 问题 给定一棵二叉树，判定该二叉树是否是二叉搜索树（Binary Search Tree）？ 解法1:暴力搜索 首先说明一下二叉树和...
是否二叉搜索树
u013243314的专栏
06-25 5980
习题4.3 是否二叉搜索树   (25分) 本题要求实现函数，判断给定二叉树是否二叉搜索树。 函数接口定义： bool IsBST ( BinTree T ); 其中BinTree结构定义如下： typedef struct TNode *Position; typedef Position BinTree; struct TNode{ ElementType
（数据结构）二叉搜索树和二叉树有什么区别？
CaoMei_HuaCha的博客
10-31 4615
二叉树每个节点最多有两个节点。 二叉搜索树支持对数时间的搜索，支持对数时间级别的插入和删除。 补充问题：最小堆的堆属性是什么？ 每个节点都小于或等于其两个子节点。...
二叉树和二叉搜索树之间的区别
CHCH998的博客
06-28 2371
任何人都可以用一个例子解释二叉树和二叉搜索树之间的区别吗？
二叉树和二叉查找树--基本方法
流萤梦的博客
07-26 2万+
二叉树每个节点的子节点不允许超过两个。通过将子节点的个数限定为2，可以写出高效的程序在树中插入、查找和删除数据。 二叉查找树是一种特殊的二叉树，相对较小的值保存在左节点中，较大的值保存在右节点中。 那么，如何实现二叉查找树呢？ 1、定义Node对象 Node 对象既保存数据，也保存和其他节点的链接（left 和right），show() 方法用来显示保存在节点中的数据。 functio...
二叉排序树（二叉查找树、二叉搜索树）
热门推荐
rodman177的博客
05-03 10万+
什么是二叉查找树： 根节点的值大于其左子树中任意一个节点的值，小于其右节点中任意一节点的值，这一规则适用于二叉查找树中的每一个节点。 本文章重点来讨论一下关于二叉查找树删除节点的问题。 有一下二叉查找树，如图： 在删除节点的时候我们只需考虑一下三种情况： （1）要删除的节点是叶子结点，如图： （2）要删除的节点有左节点但是没有右节点，或者有右节点但是没有左节点，如图： （3）要删除的节点既有...
二叉树的用途之一二叉搜索树
more_HH
07-21 2万+
    在学习数据结构的时候，也曾经学习过二叉树，以及前序排列、中序排列、后序排列等等，但是一直无缘使用它！二叉树可以干什么？    排序有快速排序，归并排序，查找有二分法，甚至直接遍历查找，二叉树的使用很少。    实际场景使用上，用的最多的是二叉平衡树，有种特殊的二叉平衡树就是红黑树，Java集合中的TreeSet和TreeMap,C++STL中的set,map以及LInux虚拟内存的管理，都...
二叉搜索树(BST)与平衡二叉树(AVL树)专题
DaveBobo的博客
08-26 5886
1 二叉搜索树（BST）一颗二叉搜索树 （BST）是以一颗二叉树来组织的，可以使用一个链表数据结构来表示，其中，每个结点就是一个对象，包含数据内容key以及left、right和p分别指向结点的左孩子、右孩子和双亲。如果某个孩子结点和父节点不存在，则相应属性的值为空（NIL）。 二叉搜索树中的关键字key的存储方式总是满足二叉搜索树的性质： 设x是二叉搜索树中的一个结点。如果y是x左子树中的一个
数据结构-二叉树和二叉查找树
tuke_tuke的博客
12-20 6803
先按树-二叉树-二叉查找树的顺序解释会比较清楚。 一，树 树（Tree）是n（n≥0）个结点的有限集。在任意一棵非空树中： （1）有且仅有一个特定的被称为根（Root）的结点； （2）当n>1时，其余结点可分为m（m>0）个互不相交的有限集T1，T2，…，Tm，其中每一个集合本身又是一棵树，并且称为根的子树（SubTree）。 结点的度（Degree）：结点拥有的子树数称为结点的度（De
平衡二叉树是二叉搜索树吗
最新发布
06-13
平衡二叉树是一种特殊的二叉搜索树（Binary Search Tree, BST），它满足两个额外的条件：对于任意节点，其左子树中所有节点的值都小于该节点的值，右子树中所有节点的值都大于该节点的值，同时树的高度被尽可能地...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值