【一周编程学习】--4.二叉树的学习笔记--LeetCode第98题、102题、107题

最新推荐文章于 2021-02-24 10:47:22 发布

roy_blue

最新推荐文章于 2021-02-24 10:47:22 发布

阅读量1k

点赞数

分类专栏： # 数据结构与算法笔记 # Leetcode刷题文章标签：【一周编程学习】

本文链接：https://blog.csdn.net/wxq_1993/article/details/85935008

版权

数据结构与算法笔记同时被 2 个专栏收录

14 篇文章 0 订阅

订阅专栏

Leetcode刷题

14 篇文章 0 订阅

订阅专栏

1.二叉树的相关知识点

二叉树具有五种基本形态：

空二叉树。
只有一个根结点。
根结点只有左子树。
根结点只有右子树。
根结点既有左子树又有右子树

以二叉链表作为二叉树存储结构：data是数据域，lchild指向左孩子的指针域，rchild指向右孩子的指针域

typedef struct BinTreeNode
{
    char data;
    struct BinTreeNode * leftP,* rightP;
    BinTreeNode() {leftP=NULL,rightP=NULL}
}BinTreeNode,*BinTreeList;

利用完全二叉树实现大根堆的时间复杂度是O(logN )

例题：哈夫曼树

哈夫曼二叉树是一颗带权重的二叉树，权重是由队列中每个字符出现的次数所决定的。并且哈夫曼二叉树始终保证权重越大的字符出现在越高的地方。

字符串”alibaba”的二进制哈夫曼编码有（）位。

　　A、11　　　B、12　　　C、13　　　D、14

根据字符出现频率构建的带权重二叉树确定每个字符编码的。首先我们统计“alibaba”各个字符出现频率：a-3，b-2，l-1，i-1。由出现的频率我们有以下哈夫曼二叉树，对出现的频率升序排序：

“alibaba”整个字符串的编码为0 100 101 11 0 11 0。也就是说该字符串二进制哈夫曼编码位数为13位。

2.二叉树的遍历

前序遍历:先访问根节点，前序遍历左子树，在前序遍历右子树

中序遍历：中序遍历根节点的左子树，然后访问根节点，最后中序遍历右子树。如果某结点没有左孩子，则打印该节点。

后序遍历：从左到右先叶子后结点的方式遍历访问左右子树，最后访问根节点。

已知前序遍历序列和中序遍历序列，可以唯一确定一棵二叉树。

已知中序遍历序列和后序遍历序列，可以唯一确定一棵二叉树

实现代码递归版本和非递归版本： C++


typedef struct BiTNode
{
	char data;
	BiTNode *lchild;
	BiTNode *rchild;
}BiTNode,*BiTree;
//前序遍历（递归）
void preOrder(BiTree T)
{
	if(T){
	cout<<T->data<<" ";
	preOrder(T->lchild);
	preOrder(T->rchild);
	}
}
//前序遍历（非递归）
void preOrder1(BiTree T)
{
	stack<BiTree> s;
	BiTree p=T;
	while(p!=NULL||!s.empty())
	{
		while(p!=NULL)
		{
			cout<<p->data<<" ";
			s.push(p);
			p=p->lchild;
		}
		while(!s.empty())
		{
			p=s.top();
			s.pop();
			p=p->rchild;
		}	
	}
}
//前序创建二叉树
BiTree preCreateBTree()
{
	BiTree T=NULL;
	char ch;
	cin>>ch;
	if(ch!='#')
	{
		T=new BiTNode;
		T->data=ch;
		T->lchild=preCreateBTree();
		T->rchild=preCreateBTree();
	}
	return T;
}
//中序遍历（递归）
void inOrder(BiTree T)
{
	if(T){
	inOrder(T->lchild);
	cout<<T->data<<" ";
	inOrder(T->rchild);
	}
}
//中序遍历（非递归）
void inOrder1(BiTree T)
{
	stack<BiTree> s;
	BiTree p=T;
	while(p!=NULL||!s.empty())
	{
		while(p!=NULL){
		s.push(p);
		p=p->lchild;
		}
		while(!s.empty())
		{
			p=s.top();
			cout<<p->data<<" ";
			s.pop();
			p=p->rchild;
		}
	}

}
//中序创建二叉树
BiTree inCreatBTree()
{


}

//后序遍历（递归）
void postOrder(BiTree T)
{
	if(T){
	postOrder(T->lchild);
	postOrder(T->rchild);
	cout<<T->data<<" ";
	}
}
//后序遍历（非递归）
void postOrder1(BiTree T)
{
	BiTree p=T;
	stack<BiTree> s1;
	stack<BiTree> s2;
	while(p!=NULL||!s1.empty())
	{
		while(p)
		{
			s2.push(p);
			s1.push(p);
			p=p->rchild;
		}
		if(!s1.empty())
		{
			p=s1.top();
			s1.pop();
			p=p->lchild;
		}
		while(!s2.empty())
		{
			p=s2.top();
			s2.pop();
			cout<<p->data<<" ";
		}
	}
}

参考：

1.https://jingyan.baidu.com/article/5553fa82ba04be65a3393462.html

2.二叉树的遍历：https://blog.csdn.net/z_ryan/article/details/80854233

3.层次遍历：https://blog.csdn.net/hansionz/article/details/81947834

3.LeetCode第98题、102题、107题

第98题搜索二叉树

给定一个二叉树，判断其是否是一个有效的二叉搜索树。假设一个二叉搜索树具有如下特征：

节点的左子树只包含小于当前节点的数。
节点的右子树只包含大于当前节点的数。
所有左子树和右子树自身必须也是二叉搜索树。

一颗二叉搜索树，如果按照中根遍历来的话（即先左子树，然后根结点，再右子树的顺序）那么一颗二叉搜索树遍历出来就是一个单调递增的数组 。

使用C++实现：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    void inOrder(vector<int> &res,TreeNode* root)
    {
        if(root)
        {
            inOrder(res,root->left);
            res.push_back(root->val);
            inOrder(res,root->right);
        }
    }
    
    vector<int> res;
    
    bool isValidBST(TreeNode* root) {
        if(root==NULL)
            return true;
        inOrder(res,root);
        for(int i=0;i<res.size()-1;i++)
            if(res[i]>=res[i+1])
                return false;
        return true;
    } 
};

第102题给定一个二叉树，返回其按层次遍历的节点值。（即逐层地，从左到右访问所有节点）。

二叉树的层次遍历是按照从上到下、从左到右的顺序依次打印出来的，正好符合队列结构的顺序-->先进先去。定义一个队列，里面存储二叉树的指针，使用这个指针依次访问二叉树的左孩子和右孩子。

使用C++和Python实现:

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        int count=0;        
        TreeNode* temp;
        vector<int> a; //存储每一层结点的值
        vector<vector<int>> res;
        queue<TreeNode*> q;
		
        if(!root) 
			return res;
			
        q.push(root);
        while(q.size())
		{    //第一个循环给count赋值
            count=q.size();
            a.clear();
            while(count--){ //第二个循环开始往二位数组输入
                temp=q.front();
                if(temp->left) q.push(temp->left);
                if(temp->right) q.push(temp->right);
                q.pop();
                a.push_back(temp->val);
            }
            res.push_back(a);
        }
        return res;
    }
};

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    def preorder(self, root, level, res):
        if root:
            if len(res) < level + 1: res.append([])
            res[level].append(root.val)
            self.preorder(root.left, level + 1, res)
            self.preorder(root.right, level + 1, res)
    def levelOrderBottom(self, root):
        """
        :type root: TreeNode
        :rtype: List[List[int]]
        """
        res = []
        self.preorder(root, 0, res)
        res.reverse()
        print res
        return res

第107题二叉树的倒序层次遍历

c++在102题的res结果加上reverse(res.begin(),res.end());

reverse函数的作用是使vector反转。

这次使用Python实现;

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    def preorder(self, root, level, res):
        if root:
            if len(res) < level + 1: res.append([])
            res[level].append(root.val)
            self.preorder(root.left, level + 1, res)
            self.preorder(root.right, level + 1, res)
    def levelOrderBottom(self, root):
        """
        :type root: TreeNode
        :rtype: List[List[int]]
        """
        res = []
        self.preorder(root, 0, res)
        res.reverse()
        #print res
        return res

参考：

1.https://www.cnblogs.com/loadofleaf/p/5502285.html

2.https://www.cnblogs.com/loadofleaf/p/5502324.html

roy_blue

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
2
评论
【一周编程学习】--4.二叉树的学习笔记--LeetCode第98题、102题、107题

1.二叉树的相关知识点二叉树具有五种基本形态：空二叉树。只有一个根结点。根结点只有左子树。根结点只有右子树。根结点既有左子树又有右子树以二叉链表作为二叉树存储结构：data是数据域，lchild指向左孩子的指针域，rchild指向右孩子的指针域 typedef struct BinTreeNode{ char data; str...
复制链接

扫一扫