二叉树总结

最新推荐文章于 2024-03-10 21:38:04 发布
最新推荐文章于 2024-03-10 21:38:04 发布
阅读量706 收藏 2
点赞数
分类专栏： 编程题
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/coolwriter/article/details/78995915
版权

1.二叉树创建

class Solution
{
public:
    TreeNode* reConstructBinaryTree(vector<int> pre,vector<int> vin)
    {
        if(pre.size()<=0||vin.size()<=0)
            return NULL;
        TreeNode *root=new TreeNode(pre[0]);
        //前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}
        for(int i=0;i<vin.size();i++)
        {
            if(pre[0]==vin[i])
            {

                root->left=reConstructBinaryTree(copy(pre,1,i),copy(vin,0,i-1));
                root->right=reConstructBinaryTree(copy(pre,i+1,pre.size()-1),copy(vin,i+1,vin.size()-1));                            
                break;
            }

        }
        return root;
    }
    vector<int> copy(vector<int> array,int begin,int end)
    {
        vector<int> temp;
        while(begin<=end)
        {
            temp.push_back(array[begin++]);
        }
        return temp;
    }
};
    int input;  
    scanf("%d",&input);         //按先序建立二叉树  
    if(input == 0)  
    {  
        root = NULL;   //置为NULL后结束  
        return root;     
    }  
    root = (TreeNode *)malloc(sizeof(TreeNode));  
    root ->val = input;  
    root->left = CreateTree(root->left);  
    root->right = CreateTree(root->right);  
    return root;  
}
2.二叉树递归遍历 

 void preorder(Node* root)//先序遍历打印树的各个节点  
    {  
        if (root)  
        {  
            cout<<root->val<<" ";  //访问当前节点的值
            preorder(root->left); //递归遍历左子树 
            preorder(root->right); //递归遍历右子树 
        }  
    }  
    void inorder(Node* root)//中序遍历打印树的各个节点  
    {  
        if (root)  
        {  
            preorder(root->left);  //递归遍历左子树 
            cout<<root->val<<" ";  //访问当前节点的值
            preorder(root->child);  //递归遍历右子树 
        }  
    }  
    void postorder(Node* root)//后序遍历打印树的各个节点  
    {  
        if (root)  
        {  
            preorder(root->left);  //递归遍历左子树 
            preorder(root->right);  //递归遍历右子树 
            cout<<root->val<<" ";  //访问当前节点的值
        }  
    }
3.二叉树非递归遍历 


//中序遍历  
void InOrderWithoutRecursion1(TreeNode* root)  
{  
    //空树  
    if (root == NULL)  
        return;  
    //树非空  
    TreeNode* p = root;  
    stack<TreeNode*> s;  
    while (!s.empty() || p)  
    {  
        //一直遍历到左子树最下边，边遍历边保存根节点到栈中  
        while (p)  
        {  
            s.push(p);  
            p = p->left;  
        }  
        //当p为空时，说明已经到达左子树最下边，这时需要出栈了  
        if (!s.empty())  
        {  
            p = s.top();  
            s.pop();  
            cout << setw(4) << p->val;  
            //进入右子树，开始新的一轮左子树遍历(这是递归的自我实现)  
            p = p->right;  
        }  
    }  
}  
三、 从上到下按层打印二叉树，同一层结点从左至右输出。每一层输出一行。 

/*
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) :
            val(x), left(NULL), right(NULL) {
    }
};
*/
class Solution {
public:
     vector<vector<int> > res;
        vector<vector<int> > Print(TreeNode* pRoot) 
        {
            if(!pRoot)
                return res;
        
    	 queue <TreeNode*> q;
    	 q.push(pRoot);
            
   		 vector<int> temp; 
    	 while (!q.empty()) 
         {
            int size=q.size();
           
            for (int i=0;i<size;i++) {      //一次处理一层的数据
                TreeNode *node=q.front();
                temp.push_back(node->val);
                q.pop();
                if (node->left) q.push(node->left);
                if (node->right) q.push(node->right);
            }
            res.push_back(temp);
            temp.clear();
        }
            return res;
   }
};
之字形打印二叉树 

/*
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) :
            val(x), left(NULL), right(NULL) {
    }
};
*/
class Solution {
public:
     vector<vector<int> > res;
        vector<vector<int> > Print(TreeNode* pRoot) 
        {
            if(!pRoot)
                return res;

         queue <TreeNode*> q;
         q.push(pRoot);
		bool flag = 1;
         vector<int> temp;
         while (!q.empty()) 
         {
            int size=q.size();
            for (int i=0;i<size;i++) 
            {      //一次处理一层的数据
                TreeNode *node=q.front();
                temp.push_back(node->val);
                q.pop();
                if (node->left) q.push(node->left);
                if (node->right) q.push(node->right);
                    
            }
              if(flag)
              {
                  res.push_back(temp);
              }
             else
             {
                 reverse(temp.begin(),temp.end());
                 res.push_back(temp);
             }
            flag =!flag; 
            temp.clear();
        }
            return res;
   }
};
二叉树深度 

/*
struct TreeNode {
	int val;
	struct TreeNode *left;
	struct TreeNode *right;
	TreeNode(int x) :
			val(x), left(NULL), right(NULL) {
	}
};*/
class Solution {
public:
   int TreeDepth(TreeNode* pRoot)
   {
        if(pRoot == NULL)
            return 0;
        queue<TreeNode*> queTree;
        queTree.push(pRoot);
        int depth = 0;
        while(!queTree.empty())
        {
            int size = queTree.size();
            depth++;
            while(size != 0)
            {
                TreeNode* temp = queTree.front();
                queTree.pop();
                if(temp->left)
                    queTree.push(temp->left);
                if(temp->right)
                    queTree.push(temp->right);
                size--;
            }
        }
        return depth;
    }
};
class Solution {
public:
    int TreeDepth(TreeNode* pRoot){
        if(!pRoot) return 0 ;
        return max(1+TreeDepth(pRoot->left), 1+TreeDepth(pRoot->right));
    }
};


否是平衡二叉树。 

class Solution {
public:
     int tree_deep(TreeNode* pRoot)
     {
         if(pRoot == NULL)
         {
             return 0;
         }
         int left = tree_deep(pRoot->left);
          int right = tree_deep(pRoot->right);
         return left > right?(left+1):(right+1);
     }
         
    
    bool IsBalanced_Solution(TreeNode* pRoot) {
	     if(pRoot == NULL)
         {
             return true;
         }
         int leftr = tree_deep(pRoot->left);
          int rightr = tree_deep(pRoot->right);
        int diff =abs(leftr - rightr);
        if(diff > 1)
        {
            return false;
        }
        else
        {
            return true;
        }
    }
};
输入两棵二叉树A，B，判断B是不是A的子结构 

/*
struct TreeNode {
	int val;
	struct TreeNode *left;
	struct TreeNode *right;
	TreeNode(int x) :
			val(x), left(NULL), right(NULL) {
	}
};*/
class Solution {
public:
    bool HasSubtree(TreeNode* pRoot1, TreeNode* pRoot2)
    {
        if (!pRoot2) return false;
        if (!pRoot1) return false;
        return (check(pRoot1,pRoot2) || HasSubtree(pRoot1->left,pRoot2) || HasSubtree(pRoot1->right,pRoot2));
    }
private:
    bool check(TreeNode* pRoot1, TreeNode* pRoot2)
    {
        if (!pRoot2) return true;
        if (!pRoot1) return false;
        if (pRoot1->val == pRoot2->val) return (check(pRoot1->left,pRoot2->left)&&check(pRoot1->right,pRoot2->right));
        return false;
    }
};

变换为源二叉树的镜像。 

/*
struct TreeNode {
	int val;
	struct TreeNode *left;
	struct TreeNode *right;
	TreeNode(int x) :
			val(x), left(NULL), right(NULL) {
	}
};*/
class Solution {
public:
    void Mirror(TreeNode *pRoot) {
        if(pRoot == NULL)
        {
            return;
        }
        TreeNode *tem = NULL;
        tem = pRoot->left;
        pRoot->left = pRoot->right;
        pRoot->right = tem;
        Mirror(pRoot->left);
        Mirror(pRoot->right);

    }
};

二叉树中和为某一值的路径 
class Solution {
private:
    vector<vector<int> > result;
    void findnode(TreeNode *root, const int expectNumber,int sum,vector<int> &path)
    {
        if (root == NULL)
            
        {
            return;
        }
            
            path.push_back(root->val);
            sum += root->val;

            if (!root->left && !root->right && sum == expectNumber)
            {
                result.push_back(path);
            }
            else {
                findnode(root->left,expectNumber,sum,path);
                findnode(root->right,expectNumber,sum,path);
            }
            path.pop_back();
            sum -= root->val;
    }
public:
    vector<vector<int> > FindPath(TreeNode* root, int expectNumber)
    {
        vector<int> path;
        findnode(root,expectNumber,0,path);
        return result;
    }
};
判断该数组是不是某二叉搜索树的后序遍历的结果 

class Solution {
public:
    bool VerifySquenceOfBST(vector<int> sequence) {
        int sizeq = sequence.size();
		if(sizeq == 0)
        {
            return false;
        }
        else if(sizeq == 1)
        {
            return true;
        }
        return search_seq(sequence,0,sizeq-1);
    }
    bool search_seq(vector<int> s,int start,int end)
    {
        if(start > end)
        {
            return true;
        }
        int i = start;
        while(s[i] < s[end])
        {
            ++i;
        }
        for(int j=i;j<end;j++)
        {
            if(s[j] < s[end])
            {
                return false;
            }
        
    	}
        return search_seq(s,0,i-1) && search_seq(s,i+1,end-1);
}
};
二叉搜索树转换成一个排序的双向链表 

/*
非递归中序遍历，加个指针pre记录上一次出栈值
*/
class Solution {
public:
    TreeNode* Convert(TreeNode* pRootOfTree)
    {
        TreeNode *head = NULL, *pre = NULL;//head 输出，pre记录上一次出栈值
        stack<TreeNode*> s;
        while (pRootOfTree || !s.empty())
        {
            while (pRootOfTree)
            {
                s.push(pRootOfTree);
                pRootOfTree = pRootOfTree->left;
            }
            if (!s.empty())
            {
                pRootOfTree = s.top();
                s.pop();
                if (pre != NULL)
                {
                    pre->right = pRootOfTree;
                    pRootOfTree->left = pre;
                }
                else//pre为空，表示s第一次出栈，第一次出栈值为最左值，即输出值
                    {
                    head = pRootOfTree;
                }
                pre = pRootOfTree;
                pRootOfTree = pRootOfTree->right;
            }
        }
        return head;
    }
};

中序遍历顺序的下一个结点并且返回 

class Solution {
public:
    TreeLinkNode* GetNext(TreeLinkNode* pNode)
    {
        if(pNode==nullptr) return nullptr; //情况1.空树，返回空
        if(pNode->right!=nullptr)         //情况2.有右子树，则本节点的下一个节点即是其右子树的最左的子节点
        {
            TreeLinkNode*p=pNode->right;
            while(p->left!=nullptr) {p=p->left;}
            return p;
        }
        while(pNode->next!=nullptr) //情况3.1没有右子树，则本节点的下一个节点即是 满足：本节点的父节点（1）是他父节点（2）的左子节点 这一条件时，返回（2）
        {
           if(pNode->next->left==pNode) return pNode->next;
            pNode=pNode->next;
        }
        return nullptr; //情况3.2 已经找到根节点了，结束上面的循环，那么本节点的下一个节点就指向nullptr
    }
};

给定一颗二叉搜索树，请找出其中的第k大的结点。例如， 5 / \ 3 7 /\ /\ 2 4 6 8 中，按结点数值大小顺序第三个结点的值为4。 

/*
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) :
            val(x), left(NULL), right(NULL) {
    }
};
*/
class Solution {
public:
   int count = 0;
    TreeNode *res = NULL;
         void inOrder(TreeNode * root,int k)  
        {  
            if (root == NULL)  
            {  
                return;  
            }  
            inOrder(root->left,k);  
            count++;
             if(count == k)
             {
                 res = root;
             }
            inOrder(root->right,k);  
        }  
    TreeNode* KthNode(TreeNode* pRoot, int k)
    {
        if(!pRoot)
            return pRoot;
        inOrder(pRoot,k);
      
        return res;
    }
};

求二叉树中节点的个数   

size_t size(Node* root)//求树中的节点个数
    {
        size_t count = 0;
        if (NULL == root)
        {
            count = 0;
        }
        else
        {
            //当前节点 = 左子树节点 + 右子树节点 + 1
            count = size(root->left) + size(root->right)+ 1;
        }
        return count;
    }
求二叉树中叶子节点的个数   
size_t getleafsize(Node* root)//求叶节点的个数
    {
        if (NULL == root)//空树
        {
            return 0;
        }
        if (NULL == root->left && NULL == root->right)//左叶节点右节点均为空，即
        {
            return 1;
        }
        else//左子树的叶节点+右子树的叶节点
        {
            return getleafsize(root->left)+getleafsize(root->right);
        }
    }
求二叉树第K层的节点个数（假设根节点为第1层）   

size_t getklevelsize(Node* root,size_t k)//树中第k层的节点个数
    {
        assert(k>0);

        size_t count = 0;
        if (NULL == root)
        {
            return 0;
        }
        if (k == 1)
        {
            count++;
        }
        else
        {
            count =  getklevelsize(root->left,k-1)
                + getklevelsize(root->right,k-1);
        }
        return count;
    }
判断一个节点是否在二叉树中   

bool _Find(Node* root,const T& data)    //查找指定数据的节点
    {
        if (NULL == root)
        {
            return false;
        }
        else if (root->val== data)
        {
            return true;
        }
        else
        {
            bool isIn = false;
            if (root->left && !isIn)
                isIn = _Find(root->left,data);
            if (root->right && !isIn)
                isIn = _Find(root->right,data);
            return isIn;
        }
    }

求二叉树中最远的两个节点的距离   

int _RemoteDistance1(Node* root,int& distance)
    {
        if (NULL == root)
        {
            return 0;
        }
        int tmp = _Depth(root->_left)+_Depth(root->_right);//递归去求每棵子树的最远距离

        if (distance < tmp)//用全局变量保存每棵子树的最远距离，并不断更新
        {
            distance = tmp;
        }
        return distance;
    }
求二叉查找树的公共祖先 



/*1 如果两个节点都比当前节点小, 那公共祖先必然是当前节点的左子树上, 所以递归左子树;
2 如果两个节点都比当前节点大, 那么同上, 递归右子树;
3 如果两个节点有一个为当前节点, 则当前节点为公共节点; 如果两个节点分别比当前节点小和大, 那么当前节点必为公共节点.*/
class Solution {  
public:  
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {  
        if(root == NULL || p == NULL || q == NULL)  
            return root;  
        if(p->val > root->val && q->val > root->val)  
            return lowestCommonAncestor(root->right, p, q);  
        else if(p->val < root->val && q->val < root->val)  
            return lowestCommonAncestor(root->left, p, q);  
        else  
            return root;  
    }  
};

求二叉树的公共祖先 

 /*直到递归到某节点满足一定的条件, 返回该节点; 否则继续递归, 若到叶子节点, 返回空. 那么最终返回的必然为两个被求节点的公共祖先. 
具体思路:
1 如果当前节点为空, 返回空;
2 如果当前节点为两个节点中的一个, 或者当前节点恰好是两个节点的父亲节点, 那么返回该节点;
3 递归遍历当前节点左子树;
4 递归遍历当前节点右子树;
5 如果3 和 4 返回的都不是空, 那么当前节点必为公共祖先, 返回当前节点;
6 如果5不满足, 但3返回的不为空, 则返回3返回的节点指针;
7 如果5不满足, 但4返回的不为空, 则返回4返回的节点指针*/
class Solution {  
public:  
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {  
        if(root == NULL)  
            return NULL;  
        if(root == p || root == q || (root->left == p && root->right == q) || (root->left == q && root->right == p))  
            return root;  
        TreeNode* leftReturn = lowestCommonAncestor(root->left, p, q);  
        TreeNode* rightReturn = lowestCommonAncestor(root->right, p, q);  
        if(leftReturn != NULL && rightReturn != NULL)  
            return root;  
        if(leftReturn != NULL)  
            return leftReturn;  
        if(rightReturn != NULL)  
            return rightReturn;  
    }  
};






coolwriter
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
重建二叉树
qq_34823218的博客
11-09 112
题目描述 输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。 思路 前序遍历：根节点-左子树-右子树 中序遍历：左子树-根节点-右子树 后序遍历：左子树-右子树-根节点 1.前序遍历的第一个值为根节点的...
手动构建二叉树
weixin_45794299的博客
09-21 239
一、题目 手动构建二叉树 二、思路 1、先new TreeNode[size]数组 2、对数组中的每个val进行赋值，left和right进行置为nullptr 3、从0遍历到size/2-1；根据左孩子和父节点的关系，右孩子和父节点的关系进行链接 三、代码 #include <iostream> #include <string.h> #include <string> #include <vector> #include <map> #incl
Java实现二叉树及其常规操作
qq_58284486的博客
03-19 3150
😊使用Java实现一个二叉树。 二叉树是一个递归的数据结构，每个节点最多有两个子节点，且有左右之分，分别称为该节点的左右孩子。二叉树是树形结构的一个重要类型，许多实际问题抽象出来的数据结构往往是二叉树形式，因此二叉树显得特别重要，但它的存储结构和算法都较为简单。 二叉树结构以及代码实现很容易，但一定要注意理解递归思想，只要可以很好地理解递归思想，解决二叉树相关问题难度就降低很多了，大家可以参考我博客的内容自己手敲一边代码实现二叉树，收获一定会很大，一起加油😊😊😊 目录 模拟实现二叉树 ​.
Java“树结构TreeNode”用法详解，二叉树用法实现代码！！！
最新发布
wwwwwmmn的博客
03-10 3069
本篇文章详细整理了TreeNode的用法，二叉树四种遍历的详细实现代码，构造二叉树，查找父节点等……
如何创建一个简单的二叉树（TreeNode）？
weixin_39309402的博客
10-17 9383
我们都知道，数据结构最典型的就是数组和链表，在《算法图解》一书中，详细介绍了数组和链表的优缺点： 数组查询快（下标），但删除或者插入就比较慢（遍历） 链表与之相反，删除和插入元素很快，但查找很慢 所以二叉树就应运而生了，它结合二者的优点，取二家之长，但是在实际编程中，大多时候，根本用不到二叉树（实际编程中，我从来没用过二叉树，但是面试可能会问啊，所以趁有空学习总结下），网上找了一下二叉树的应用场...
部分二叉树总结
02-14
自己根据资料对二叉搜索树，B树,红黑树等的基本梳理和总结，一张脑图就能理解，费了一些功夫弄出来的，手里没多少分的就不要下了
二叉树面试题 树和二叉树总结.doc
02-24
"二叉树面试题 树和二叉树总结" 本资源摘要信息涵盖了树和二叉树的面试题总结，包括选择题和解释。涵盖的知识点包括树和二叉树的定义、性质、操作和应用等。 一、树和二叉树的定义 树是一种数据结构，由一个根...
四种根据给定遍历序列构造二叉树总结（JAVA递归和非递归版）
12-21
构造二叉树根据前序与中序遍历序列构造二叉树根据先序遍历构造二叉搜索树根据中序与后序遍历序列构造二叉树根据前序与后序遍历序列构造二叉树 二叉树的遍历顺序及方法可参考之前写过的二叉树的遍历（JAVA递归和非...
二叉树大总结1_二叉树的各种题(遍历、查找)
12-09
二叉树大总结1_二叉树的各种题(遍历、查找等)，是网上一个不错的学习例子。
树与二叉树算法总结
07-14
树与二叉树算法总结 树与二叉树是计算机科学中非常重要的一部分，掌握树与二叉树的算法对于数据结构和算法设计非常重要。本文将对树与二叉树的基本概念、性质、运算和应用进行总结。 一、树的基本概念 树是一种非...
二叉树遍历问题，总结递归和迭代解法
11-29
} }总结二叉树的遍历是数据结构中的基础操作，理解递归和迭代解法对于解决更复杂的二叉树问题至关重要。递归方法简洁明了，易于理解，但可能会导致较大的函数调用开销。而迭代方法通常效率更高，但实现起来可能更...
二叉树的应用
05-21
总结来说，二叉树的应用实验涵盖了二叉树的基本操作，包括构造、遍历和属性查询。这些基本操作是理解和使用二叉树的关键，它们在数据结构和算法中扮演着重要角色，如搜索、排序、表达式求解等。通过这样的实践，我们...
【数据结构】二叉树
m0_50987960的博客
11-26 3912
树和二叉树的重要概念以及方法的实现
java treenode_Java Tree结构数据中查找匹配节点方式
weixin_31690531的博客
02-21 1176
我就废话不多说了，大家还是直接看代码吧~private boolean contains(List children, String value) {for (TreeVo child : children) {if (child.getName().equals(value) || (child.getChildren().size() > 0 && contains(ch...
【数据结构与算法】初识二叉树(中)
冲击大厂之路!!!
09-29 1048
二叉树中篇，详解二叉树的三种遍历方式，以及二叉树的模拟实现！
java node类_【LeetCode】TreeNode类实现解析（java实现）
weixin_28848317的博客
02-12 1471
在LeetCode中，TreeNode是经常用到的一个结构体，表示数据结构树(Tree)中的一个节点。其官方定义如下：public class TreeNode {int val;TreeNode left;TreeNode right;TreeNode(int x) { val = x; }}123456在Tree的题目中，常会给出一些测试用例，用一些特定的格式来表示一棵树，如[3,9,20,n...
二叉树的遍历方法总结
05-26
二叉树的遍历方法主要有三种：前序遍历、中序遍历和后序遍历。其中，前序遍历是指先访问根节点，然后访问左子树，最后访问右子树；中序遍历是指先访问左子树，然后访问根节点，最后访问右子树；后序遍历是指先访问左子树，然后访问右子树，最后访问根节点。 以下是三种遍历方法的递归实现： 前序遍历（根->左->右）： ``` void preorderTraversal(TreeNode* root) { if (root == NULL) { return; } cout << root->val << " "; preorderTraversal(root->left); preorderTraversal(root->right); } ``` 中序遍历（左->根->右）： ``` void inorderTraversal(TreeNode* root) { if (root == NULL) { return; } inorderTraversal(root->left); cout << root->val << " "; inorderTraversal(root->right); } ``` 后序遍历（左->右->根）： ``` void postorderTraversal(TreeNode* root) { if (root == NULL) { return; } postorderTraversal(root->left); postorderTraversal(root->right); cout << root->val << " "; } ``` 以上实现方式都是使用递归实现的，也可以使用迭代的方式来实现遍历。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值