二叉树的基本操作

最新推荐文章于 2024-01-03 03:09:29 发布

QSiLl

最新推荐文章于 2024-01-03 03:09:29 发布

阅读量216

点赞数

分类专栏：力扣 #简单题库文章标签：算法数据结构

本文链接：https://blog.csdn.net/QSiLl/article/details/126032611

版权

力扣同时被 2 个专栏收录

5 篇文章 0 订阅

订阅专栏

#简单题库

5 篇文章 0 订阅

订阅专栏

1.二叉树的定义

二叉树（Binary Tree）是另一种树形结构，它的特点是每个结点至多只有两棵子树（即二叉树中不存在度大于2的结点），并且，二叉树的子树有左右之分，其次序不能任意颠倒。

满二叉树：一棵深度为k且有 $2^{k}-1$ 个结点的二叉树称为满二叉树。

完全二叉树：深度为k，有n个结点，并且每一个结点都与深度为k的满二叉树中编号从1-n的结点一一对应，称为完全二叉树。

2.二叉树的性质

性质1：二叉树的第i层至多有 $2^{i-1}$ 个结点（ $i\geq 1$ ）

性质2：深度为k的二叉树至多有 $2^{k}-1$ 个结点（ $k\geqslant1$ ）

性质3：对任何一棵二叉树T，如果其终端结点（叶子结点，即没有左右子树0）数为 $n_{0}$ ，度为2的结点数为 $n_{2}$ ，则 $n_{0}= n_{2}+1$

性质4：具有n个结点的完全二叉树的深度为 $\left \lfloor \log{_{2}}n \right \rfloor+1$

3.二叉树的构建

二叉树的二叉链表存储结构

 typedef struct BiTNode
 {
      int val;
      struct TreeNode *left;
      struct TreeNode *right;
  }BiTNode,*BiTree;

先序和中序

由二叉树的先序遍历和中序遍历结果，构建出此二叉树

例给定两个整数数组 preorder 和 inorder ，其中 preorder 是二叉树的先序遍历， inorder 是同一棵树的中序遍历，请构造二叉树并返回其根节点。

输入: preorder = [3,9,20,15,7], inorder = [9,3,15,20,7]
输出: [3,9,20,null,null,15,7]
leetcode题库105

struct TreeNode* buildTree(int* preorder, int preorderSize, int* inorder, int inorderSize)
{
    if(preorderSize == 0 || inorderSize == 0)
        return NULL;
    
    struct TreeNode* root = (struct TreeNode*)malloc(sizeof(struct TreeNode));
    int index;
    root -> val = preorder[0];
    for(index = 0;index < inorderSize;index++)//寻找根结点在中序遍历的位置inorder
        if(inorder[index] == preorder[0])
            break;
    root -> left = buildTree(preorder + 1,index,inorder,index);
    root -> right = buildTree(preorder + index + 1,preorderSize - index - 1,inorder + index + 1,preorderSize - index - 1);
    return root;
}

例先序ABEIDJ 中序EBIADJ 输出后续遍历结果为EIBDJA

c++版

c++中find（）函数和substr（）函数（截取字符串）的用法

int main()
{

	string s1 = "sldbxu";
	cout << s1.find('d') << endl;8//打印s1字符串中字符d的下标
	cout << s1.substr(2) << endl;//由下标2的字符开始，打印至\0
	cout<< s1.substr(2, 3) << endl;//由下标2的字符开始，打印3个
	return 0;
}


结果为
2
dbxu
dbx

完整代码

#include<iostream>
using namespace std;


void print(string s1,string s2)
{
	if (s1 == "\0" || s2 == "\0")
		return;
	//根结点
	int x = s2.find(s1[0]);
	//左子树
	print(s1.substr(1,x ),s2.substr(0,x));
	//右子树
	print(s1.substr(x + 1), s2.substr(x + 1));

	cout << s1[0];
}

int main()
{
	string s1, s2;
	cin >> s1 >> s2;
	print(s1, s2);
	return 0;
}

中序和后序

给定两个整数数组 inorder 和 postorder ，其中 inorder 是二叉树的中序遍历， postorder 是同一棵树的后序遍历，请你构造并返回这颗二叉树。

输入：inorder = [9,3,15,20,7], postorder = [9,15,7,20,3]
输出：[3,9,20,null,null,15,7]
leetcode题库106

struct TreeNode* buildTree(int* inorder, int inorderSize, int* postorder, int postorderSize)
{
    
    if(inorderSize == 0 || postorderSize == 0)
        return NULL;
    
    struct TreeNode* root = (struct TreeNode*)malloc(sizeof(struct TreeNode));
    int index;
    root -> val = postorder[postorderSize-1];
    for(index = 0;index < inorderSize;index++)//寻找根结点在中序遍历的位置inorder
        if(inorder[index] == postorder[postorderSize-1])
            break;
    root -> left = buildTree(inorder,index,postorder,index);
    root -> right = buildTree(inorder + index +1,inorderSize - index -1,postorder + index,postorderSize - index - 1);
    return root;

}

4.二叉树的遍历

按编号顺序依次输入root = [5,6,7,null,1,2]

先序输出：[5,6,1,7,2] 中序输出：[6,1,5,2,7] 后序输出：[1,6,2,7,5]

先序

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */
 
void preOrder(struct TreeNode* root, int* res, int* resSize){   //前序遍历函数
    if(root == NULL)                                            //树为空返回
        return ;
    res[*resSize] = root->val;                                  //遍历根结点
    (*resSize)++;
    preOrder(root->left, res, resSize);                         //前序遍历左子树
    preOrder(root->right, res, resSize);                        //前序遍历右子树
}

int* preorderTraversal(struct TreeNode* root, int* returnSize){
    int* res = (int*)malloc(sizeof(int) * 1000);                //存放遍历结果
    *returnSize = 0;
    preOrder(root, res, returnSize);
    return res;
}

中序

 void inorder(struct TreeNode* root, int* res, int* resSize){   //前序遍历函数
    if(root == NULL)                                            //树为空返回
        return ;
    
    inorder(root->left, res, resSize);                         //前序遍历左子树
     res[*resSize] = root->val;                                  //遍历根结点
    (*resSize)++;
    inorder(root->right, res, resSize);                        //前序遍历右子树
}

int* inorderTraversal(struct TreeNode* root, int* returnSize){
  int* res = (int*)malloc(sizeof(int) * 1000);                //存放遍历结果
    *returnSize = 0;
    inorder(root, res, returnSize);
    return res;
}

后序

 void postorder(struct TreeNode* root, int* res, int* resSize){   //前序遍历函数
    if(root == NULL)                                            //树为空返回
        return ;
   
    postorder(root->left, res, resSize);                         //前序遍历左子树
    postorder(root->right, res, resSize);                        //前序遍历右子树
    res[*resSize] = root->val;                                  //遍历根结点
    (*resSize)++;
}

int* postorderTraversal(struct TreeNode* root, int* returnSize){
 int* res = (int*)malloc(sizeof(int) * 1000);                //存放遍历结果
    *returnSize = 0;
    postorder(root, res, returnSize);
    return res;
}