二叉树杂记

最新推荐文章于 2023-09-28 17:24:17 发布
最新推荐文章于 2023-09-28 17:24:17 发布
阅读量376 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： 算法学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/wyyzsl212328/article/details/8463465

1、完全二叉树

若设二叉树的深度为h，除第 h 层外，其它各层 (1～h-1) 的结点数都达到最大个数，第 h 层所有的结点都连续集中在最左边，这就是完全二叉树。完全二叉树是由满二叉树而引出来的。对于深度为K的，有N个结点的二叉树，当且仅当其每一个结点都与深度为K的满二叉树中编号从1至n的结点一一对应时称之为完全二叉树。若一棵二叉树至多只有最下面的两层上的结点的度数可以小于2，并且最下层上的结点都集中在该层最左边的若干位置上，则此二叉树成为完全二叉树。

完全二叉树通常采用数组而不是链表存储

2、二叉查找树（二叉排序树 Binary Search Tree）

二叉排序树（Binary Sort Tree）又称二叉查找树。 它或者是一棵空树；或者是具有下列性质的二叉树：1）若左子树不空，则左子树上所有结点的值均小于它的根结点的值； （2）若右子树不空，则右子树上所有结点的值均大于它的根结点的值； （3）左、右子树也分别为二叉排序树；

二叉排序树是一种动态树表。其特点是：树的结构通常不是一次生成的，而是在查找过程中，当树中不存在关键字等于给定值的节点时再进行插入。新插入的结点一定是一个新添加的叶子节点，并且是查找不成功时查找路径上访问的最后一个结点的左孩子或右孩子结点。

在二叉排序树删去一个结点，分三种情况讨论：　

　若*p结点为叶子结点，即PL(左子树)和PR(右子树)均为空树。由于删去叶子结点不破坏整棵树的结构，则只需修改其双亲结点的指针即可。若*p结点只有左子树PL或右子树PR，此时只要令PL或PR直接成为其双亲结点*f的左子树（当*p是左子树）或右子树（当*p是右子树）即可，作此修改也不破坏二叉排序树的特性。若*p结点的左子树和右子树均不空。在删去*p之后，为保持其它元素之间的相对位置不变，可按中序遍历保持有序进行调整，可以有两种做法：其一是令*p的左子树的最右下节点代替*p，并删除*p的最又下节点；其二是令*p的直接前驱（或直接后继）替代*p，然后再从二叉排序树中删去它的直接前驱（或直接后继）。

#ifndef BinarySearchTree_H
#define BinarySearchTree_H

#include <stack>
using namespace std;


template<typename T>
class TreeNode
{
public:
  T value; // value contained in the node
  TreeNode<T> * parent; // Pointer to the parent
  TreeNode<T> * left; // Pointer to the left child
  TreeNode<T> * right; // Pointer to the right child

  TreeNode() // No-arg constructor
  {
    left = NULL;
    right = NULL;
    parent = NULL;
  }

  TreeNode(T value) // Constructor
  {
    this->value = value;
    left = NULL;
    right = NULL;
    parent = NULL;
  }
};


template < typename T >
class BinarySearchTree
{
public:
  int treeSize;
  BinarySearchTree();
  BinarySearchTree(T values[],int arraySize);
  int insert(T value);
  void inOrder();
  void inOrderNorRec();
  int deleteNode(T value);
  int successor(T value);
  int predecessor(T value);
  void maxValue();
  void minValue();
  int getSize(T value);
  void output();

private:
  TreeNode<T> * treeroot;
  void inOrder(TreeNode<T> *target);
  void inOrderNorRec(TreeNode<T> *target);
  TreeNode<T> * search(T searchvalue);
  int deleteNode(TreeNode<T> *delNode);
  TreeNode<T> * successor(TreeNode<T> *target);
  TreeNode<T> * predecessor(TreeNode<T> *target);
  TreeNode<T> * maxValue(TreeNode<T> *target);
  TreeNode<T> * minValue(TreeNode<T> *target);
  int getSize(TreeNode<T> *target);
  void output(TreeNode<T> *target,int totalSpaces);
};


template < typename T >
BinarySearchTree<T>::BinarySearchTree()
{
  treeroot = NULL;
  treeSize = 0;
}


template < typename T >
BinarySearchTree<T>::BinarySearchTree(T values[],int arraySize)
{
  treeroot = NULL;
  treeSize = 0;
  for(int i=0 ; i<arraySize ; i++){
    this->insert(values[i]);
  }
}


template <typename T>
int BinarySearchTree<T>::insert(T value)
{
  if (treeroot == NULL){
    treeroot = new TreeNode<T>(value); 
  } 
  else
  {
    TreeNode<T> *former = NULL;
    TreeNode<T> *current = treeroot;
    while (current != NULL){
      if (value < current->value){
        former = current;
        current = current->left;
      }
      else if (value > current->value){
        former = current;
        current = current->right;
      }
      else{
        cout << "Node with value "<< value <<" has existed." <<endl;
        return 1;
      }
    }

    if (value < former->value){
      TreeNode<T> *newNode=new TreeNode<T>(value);
      former->left = newNode;
      newNode->parent = former;
    }
    else if(value > former->value){
      TreeNode<T> *newNode=new TreeNode<T>(value);
      former->right = newNode;
      newNode->parent = former;
    }
  }

  treeSize++;
  return 0;
}


template <typename T>
TreeNode<T> * BinarySearchTree<T>::search(T searchvalue)
{
  TreeNode<T> *current = treeroot;
  int find =0;
  while (current != NULL && find == 0){
    if (current->value == searchvalue){
      find = 1;
    }
    else if(current->value > searchvalue){
      current = current->left;
    }else{
      current = current->right;
    }
  }

  if (find == 1){
    return current;
  }else{
    return NULL;
  }
}


template <typename T>
int BinarySearchTree<T>::deleteNode(T value){
  TreeNode<T> *delNode = this->search(value);
  if ( delNode == NULL){
    cout << "not find " << endl;
    return 1;
  }
  this->deleteNode(delNode);
  cout << "Node "<< value <<" has been deleted."<< endl;
  return 0;
}


template <typename T>
int BinarySearchTree<T>::deleteNode(TreeNode<T> *delNode){
  TreeNode<T> *deleteTarget;
  if (delNode->left == NULL && delNode->right == NULL){
    deleteTarget = delNode;
  }else if(delNode->left !=NULL){
    deleteTarget = this->predecessor(delNode);
  }else if(delNode->right !=NULL){
    deleteTarget = this->successor(delNode);
  }

  TreeNode<T> *deleteTargetChild = NULL;
  if (deleteTarget->left != NULL){
    deleteTargetChild = deleteTarget->left;
  }else if (deleteTarget->right != NULL){
    deleteTargetChild = deleteTarget->right;
  }

  if (deleteTargetChild != NULL){
    deleteTargetChild->parent = deleteTarget->parent;
  }

  if (deleteTarget->parent == NULL){
    treeroot = deleteTargetChild;
    deleteTargetChild->parent = NULL;
  }else if ( deleteTarget->parent->left == deleteTarget){
    deleteTarget->parent->left = deleteTargetChild;
  }else{
    deleteTarget->parent->right = deleteTargetChild;
  }

  if (deleteTarget != delNode){
    delNode->value = deleteTarget->value;
  }

  treeSize--;
  return 0;
}


template <typename T>
int BinarySearchTree<T>::successor(T value)
{
  TreeNode<T> *position = this->search(value);
  if ( position == NULL){
    cout << "not find " << endl;
    return 1;
  }
  TreeNode<T> *successorNode = this->successor(position);
  if ( successorNode != NULL)
    cout << value << " \'s successor is:" << successorNode->value << endl;
  else
    cout << value << " has no successor" << endl;
  return 0;
}


template <typename T>
TreeNode<T> * BinarySearchTree<T>::successor(TreeNode<T> *target)
{
  if ( target->right != NULL){
    return minValue(target->right);
  }
  TreeNode<T> * parentNode =target->parent;
  while ( parentNode != NULL && parentNode->right == target){
    target = parentNode;
    parentNode = parentNode->parent;
  }
  return parentNode;
}


template <typename T>
int BinarySearchTree<T>::predecessor(T value)
{
  TreeNode<T> *position = this->search(value);
  if ( position == NULL){
    cout << "not find " << endl;
    return 1;
  }
  TreeNode<T> *predecessorNode = this->predecessor(position);
  if ( predecessorNode != NULL)
    cout << value << " \'s predecessor is:" << predecessorNode->value << endl;
  else
    cout << value << " has no predecessor" << endl;
  return 0;
}


template <typename T>
TreeNode<T> * BinarySearchTree<T>::predecessor(TreeNode<T> *target)
{
  if ( target->left != NULL){
    return maxValue(target->left);
  }
  TreeNode<T> * parentNode =target->parent;
  while ( parentNode != NULL && parentNode->left == target){
    target = parentNode;
    parentNode = parentNode->parent;
  }
  return parentNode;
}


template <typename T>
void BinarySearchTree<T>::maxValue()
{
  TreeNode<T> * max = this->maxValue(treeroot);
  cout << "Max Value is :" << max->value << endl;
}


template <typename T>
TreeNode<T> * BinarySearchTree<T>::maxValue(TreeNode<T> *target)
{
  while (target -> right != NULL){
    target = target -> right;
  }
  return target;
}


template <typename T>
void BinarySearchTree<T>::minValue()
{
  TreeNode<T> * min = this->minValue(treeroot);
  cout << "Min Value is :" << min->value << endl;
}


template <typename T>
TreeNode<T> * BinarySearchTree<T>::minValue(TreeNode<T> *target)
{
  while (target -> left != NULL){
    target = target -> left;
  }
  return target;
}


template <typename T>
int BinarySearchTree<T>::getSize(T value)
{
  TreeNode<T> *target = this->search(value);
  return getSize(target);
}


template <typename T>
int BinarySearchTree<T>::getSize(TreeNode<T> *target)
{
  if (target == NULL){
    return 0;
  }

  if (target->left == NULL && target->left == NULL){
    return 1;
  }else {
    return this->getSize(target->left) + 1 + this->getSize(target->right);
  }
}


template <typename T>
void BinarySearchTree<T>::inOrder()
{
  inOrder(treeroot);
}


template <typename T>
void BinarySearchTree<T>::inOrder(TreeNode<T> *target)
{
  if (target == NULL)
    return ;
  inOrder(target->left);
  cout << target->value << " ";
  inOrder(target->right);
}


template <typename T>
void BinarySearchTree<T>::inOrderNorRec()
{
  inOrderNorRec(treeroot);
}


template <typename T>
void BinarySearchTree<T>::inOrderNorRec(TreeNode<T> *target)
{
  stack < TreeNode<T> *> s;
  while ((target != NULL) || !s.empty())
  {
      if (target != NULL)
      {
          s.push(target);
          target = target->left;
      }
      else
      {
          target = s.top();
          cout << target->value << " ";
          s.pop();
          target = target->right;
      }
  }
}


template <typename T>
void BinarySearchTree<T>::output()
{
    output(treeroot,0);
}


template <typename T>
void BinarySearchTree<T>::output(TreeNode<T> *target,int totalSpaces)
{
    if(target != NULL)
    {
        output(target->right,totalSpaces+4);
        for(int i=0;i<totalSpaces;i++){
          cout<<' ';
        }
        
        if (target->parent != NULL){
          cout << target->value << "[" << target->parent->value << "]" << endl;
        }
        else{
          cout << target->value << "[ROOT]" << endl;
        }
        
        output(target->left,totalSpaces+4);
    }
};

#endif

自己实现的简单二叉查找树的建立和输出

typedef struct BR
{
	int data;
	struct BR *lchild;
	struct BR *rchild;

}Node;
Node *InsertBST(Node **tree,int key)//传递二维指针
{
	if(*tree==NULL)
	{
	  (*tree)=new Node;
	  (*tree)->lchild=(*tree)->rchild=NULL;
	  (*tree)->data=key;
	 
	}
	else
	{
		if ((*tree)->data>key)
		{
			InsertBST(&(*tree)->lchild,key);
		}
		else if ((*tree)->data<key)
		{
			InsertBST(&(*tree)->rchild,key);
		}
	}

		
	 return *tree;
}
void CreateBiTree(Node **tree,int d[],int n)
{
	for (int i=0;i<n;i++)
	{
		InsertBST(tree,d[i]);
	}
}
//二叉树的输出，按照从小到大的顺序，此时是中序遍历输出
void PrintBitree(Node *tree)
{
	if (tree!=NULL)
	{
		PrintBitree(tree->lchild);
		cout<<tree->data<<endl;
		PrintBitree(tree->rchild);
	}
	else 
		return;
}
int _tmain(int argc, _TCHAR* argv[])
{
	string str="ABCDAK";
	int Array[8]={3,7,5,9,4,12,86,15};
	string help_str=str;
 	Node *tree=NULL;
	CreateBiTree(&tree,Array,8);
	PrintBitree(tree);
	int ch=getchar();
	return 0;
}



 

【Kotlin开发者社区文章集锦】66篇精选技术精华文章
AI天才研究院
03-09 9124
【数据结构与算法图文动画详解】终于可以彻底弄懂：红黑树、B-树、B+树、B*树、满二叉树、完全二叉树、平衡二叉树、二叉搜索树【计算机基础】OS 进程间通信（IPC）机制介绍软件架构哲学：和...
Java“树结构TreeNode”用法详解，二叉树用法实现代码！！！
最新发布
wwwwwmmn的博客
03-10 6987
本篇文章详细整理了TreeNode的用法，二叉树四种遍历的详细实现代码，构造二叉树，查找父节点等……
重建二叉树
qq_34823218的博客
11-09 163
题目描述 输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。 思路 前序遍历：根节点-左子树-右子树 中序遍历：左子树-根节点-右子树 后序遍历：左子树-右子树-根节点 1.前序遍历的第一个值为根节点的...
如何创建一个简单的二叉树（TreeNode）？
热门推荐
weixin_39309402的博客
10-17 1万+
我们都知道，数据结构最典型的就是数组和链表，在《算法图解》一书中，详细介绍了数组和链表的优缺点： 数组查询快（下标），但删除或者插入就比较慢（遍历） 链表与之相反，删除和插入元素很快，但查找很慢 所以二叉树就应运而生了，它结合二者的优点，取二家之长，但是在实际编程中，大多时候，根本用不到二叉树（实际编程中，我从来没用过二叉树，但是面试可能会问啊，所以趁有空学习总结下），网上找了一下二叉树的应用场...
【数据结构】二叉树
m0_50987960的博客
11-26 4193
树和二叉树的重要概念以及方法的实现
java treenode_Java Tree结构数据中查找匹配节点方式
weixin_31690531的博客
02-21 1334
我就废话不多说了，大家还是直接看代码吧~private boolean contains(List children, String value) {for (TreeVo child : children) {if (child.getName().equals(value) || (child.getChildren().size() > 0 && contains(ch...
二叉树的深度和分支节点数
EasyLife
09-12 4993
点击(此处)折叠或打开/* *二叉树采用二叉链表结构表示。设计并实现如下算法： *求一棵二叉树的深度和双分支结点的个数。 */#include stdio.h>#include stdlib.h>#define ERROR 0#define OK 1#define OVERFLOW 0#define STACK_INIT_SIZE 100#define STACKINCREMENT 100type
排序算法杂记
爱橙子的OK绷的专栏
04-03 1267
1、精简排序，即一对数字不进行两次和两次以上的比较，以下是“精简排序”的是正确答案: A B A、插入排序 B、归并排序 C、选择排序 D、堆排序插入排序：前面是有序的，后面的每一个元素与前面有序的元素比较，比较过的就是有序的了，不会再比较一次，例如：3 2 1 5 第一趟：【2,3,1,5】，2和3比较，3后移；第二趟：【1,2,3,5】，1和2,1和3比较，而2,
小米武研 web 后端开发面试杂记
hldh214的博客
03-31 3068
引子 2018/03/20 多云 我参加了小米武汉研发中心的面试, 岗位是 web 后端开发 当中还有一个小插曲, 在当天的上午接到人事电话, 约好当天下午 3 点现场面试 电话结束前说好了以电邮的形式告知详细信息, 然后一直到当天下午 2 点都没收到电邮 可能是被拒了我也没在意, 直到当天下午 3 点一刻的时候, 人事打来电话询问到哪了 我回复没有收到电邮, 没有准备动身… 最后...
杂记：Visual Tracking + Object Proposals + Features + Coding
YU_Xianguo的博客
04-09 4406
这篇文章主要是做一个笔记式的讲解最近关注的一些东西，包括基于核相关滤波器的目标跟踪算法、EdgeBoxes目标假设算法、Color Names特征描述方法，最后再讲讲我对如何进行高效率编程的理解
java node类_【LeetCode】TreeNode类实现解析（java实现）
weixin_28848317的博客
02-12 1599
在LeetCode中，TreeNode是经常用到的一个结构体，表示数据结构树(Tree)中的一个节点。其官方定义如下：public class TreeNode {int val;TreeNode left;TreeNode right;TreeNode(int x) { val = x; }}123456在Tree的题目中，常会给出一些测试用例，用一些特定的格式来表示一棵树，如[3,9,20,n...
剑指offerDayN树篇
carpdiem_fan的博客
06-23 267
根据前序中序递归重建二叉树 层序遍历+按照节点位置输出层序遍历树递归专栏：1树的镜像 2树的高度 3是否为平衡二叉树 三种树层序遍历的方式
数据结构（十三）——树
weixin_34132768的博客
02-04 634
数据结构（十三）——树 一、树的简介 1、树的简介 树是一种非线性的数据结构，是由n（n >=0）个结点组成的有限集合。如果n==0，树为空树。如果n>0，树有一个特定的结点，根结点根结点只有直接后继，没有直接前驱。除根结点以外的其他结点划分为m（m>=0）个互不相交的有限集合，T0，T1，T2，...，Tm-1，每个结合是一棵树，称为根结点的子树。树的示例如下： 2、树的度 树...
数据结构笔记——树
qq_63982145的博客
05-01 656
一、树的基本操作 二、树的存储结构 1.双亲表示法： 示例： 存储表示为： #define maxnode //树的结点最大个数 template <Class T> { T data;//数据域 int parent;//指针域 }; NodeType t[maxnode]; 优缺点：该存储方式对于查找双亲和根结点十分方便，但若查找某结点的孩子结点，需要查询整个数组。 2.孩子表示法： （1）多重链表表示法： 方案一：每个结点指针域的...
树结构封装（递归、排序）
weixin_43861630的博客
09-28 316
树结构封装、排序、递归
树形结构工具类
ITERCHARLIE的博客
07-13 375
import com.hyl.common.validator.AssertUtils; import java.util.ArrayList; import java.util.LinkedHashMap; import java.util.List; import java.util.Map; /** * 树形结构工具类，如：菜单、部门等 * * @author zzj * @since 1.0.0 */ public class TreeUtils { /** * .
数据结构-树-平衡二叉树
微光的博客
03-22 278
1. 介绍 AVL树又称为高度平衡的二叉搜索树。它能保持二叉树的高度平衡，尽量降低二叉树的高度，减少树的平均搜索长度。 VL树性质： 左子树和右子树的高度之差的绝对值不超过1 树中的每个左子树和右子树都是AVL树 AVL树效率： 一棵AVL树有N个节点，其高度可以保持在lgN，插入/删除/查找的时间复杂度也是lgN。 2. 实现 2.1 类定义 public cl...
二叉树定义与遍历
IRON_MAN_LEVEL1的博客
06-11 216
C++ 基础遍历
C语言二叉树性质详解
C语言公共基础部分之二叉树性质 根据给定的文件信息，我们可以总结出以下知识点： 1. 二叉树的定义：二叉树是树形结构的一个重要类型，由n个结点的有限集组成，或者是空集，或者由一个根结点及两棵互不相交的、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值