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位。
“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
- 参考: