树是非线性的数据结构,有n个有限节点组成一个具有层次关系的集合,看起来像一个倒挂的树
根节点无前驱节点,其余节点被分成M个互不相交的集合T1,T2…Tm,每个集合又是一棵与树类似的子树,每棵子树的根节点只有一个前驱节点,可以有0个或多个后继节点。
树是递归定义的
节点的度:
一个节点含有的子树的个数称为该节点的度—>树的度为最大节点的度,
叶子节点也称为终端节点,度为0的节点,
深度:该节点到根
高度:该节点到叶子节点
一颗二叉树是节点的一个有限集合,该集合或为空或有一个根节点加上两颗左右子树组成
特点:1.每个节点最多有两颗子树,即二叉树不存在度大于2的节点
2.二叉树的子树有左右之分,其子树的次序不能颠倒,因此是有序树。
基本形态:
满二叉树:除了叶子节点外,所有节点均有左右子节点
完全二叉树:对整个二叉树的节点进行层序编号之后,所有序号都紧挨着
二叉树:任意形状,
1.若规定根节点的层数为1,一颗非空二叉树的第i层最多有2的i-1次方个节点。
2.只有根节点的二叉树的深度为1,则深度为k的二叉树的最大节点数为(2^k)-1
3.对任何一颗二叉树,如果叶子节点个数为n0,度为2的非叶子节点个数为n2,则有n0=n2+1
4.具有n个节点的完全二叉树的深度为log2(n+1)向上取整
5.具有n个节点的完全二叉树,按照从上到下从左到右的顺序,对所有的节点从0开始编号,则对于序号为i的节点有:
(1)若i>0;其双亲序号:(i-1)/2,i=0;i为根节点编号,无双亲节点。
(2)若2i+1
1.有多少层?10层,
10=log2(1000+1);第10层没放满
2.前9层能放多少节点?
2^9-1=511个节点,
第10层有1000-511=489个
489个节点是由第9层的节点244父节点产生,第9层有2^8个节点256个节点,256-245=11;
489+11=500个叶子节点,
计算 n0+n2+1=1000;n0+n0-1+1=1000;n0=500;
1.前序遍历:NLR,先根遍历–访问根节点–根的左子树–根的右子树
2.中序遍历:LNR中根遍历–根的左子树–根节点–根的右子树
3.后序遍历:LRN后根遍历–根的左子树–根的右子树–根节点
void preOrederTraversal(BtNode root){
if(root==null){
sout(root.val);
}
preOrederTraversal(root.left);
preOrederTraversal(root.right);
}
void preOrederTraversal(BtNode root){
if(root==null){
}
preOrederTraversal(root.left);
sout(root.val);
preOrederTraversal(root.right);
}
void preOrederTraversal(BtNode root){
if(root==null){
return;
}
preOrederTraversal(root.left);
preOrederTraversal(root.right);
sout(root.val);
}
遍历思路:递归遍历,每次不为空size++;
void getSize(BTNode root){
if(root==null)return;
size++;
getSize(root.left);
getSize(root.right);
}
子问题思路:左树节点+右树节点+1
void getSize(BTNode root){
if(root==null)return 0;
return getSize(root.left)+getSize(root.right)+1;
}
以遍历思路求叶子节点个数:
void getLeafSize(BTNode root){
if(root==null)return;
if(root.left==null&&root.right==null){
leafsize++;
}
getLeafSize(root.left);
getLeafSize(root.right);
}
子问题思路:
void getLeafSize(BTNode root){
if(root==null)return 0;
if(root.left==null&&root.right==null){
return 1;
}
return getLeafSize(root.left)+getLeafSize(root.right);
}
递归过程中 k要发生改变,当前树的左树和右数的第k层
int getKLevelSize(BTNode root,int k){
if( root==null){
return 0;
}
if(k==1){
return 1;
}
return getKLevelSize(root.left,k-1)+getKLevelSize(root.right,k-1);
}
求左树和右树的高度,比较之后,返回再+1
int getHight(BTNode root){
if(root==null)return 0;
letfHight = getHight(root.left);
rightHight = getHight(root.right);
if(leftHight>rightHight)return lefthHight+1;
else{
return rightHight +1;
}
}
public boolean isSubtree(TreeNode s,TreeNode t){
if(s==null || t==null){
return false;
}
if(isSameTree(s,t))return true;
if(isSubtree(s.left,t))return true;
if(isSubtree(s.right,t))return true;
return false;
}
public Boolean isSymmertric(TreeNode root){
if(root==null){
return true;
}
return isSymmetricChild(root.left,root.right);
}
public boolean isSymmertricChild(TreeNode left,TreeNode right){
if(left==null&&right!=null||left!=null&&left==null){
return false;
}
if(left==null&&right==null){
return true;
}
if(left.val!=right.val)return false;
return isSymmertricChild(left.left,right.right)&&
isSymmertricChild(left.right,right.left);
}
一个二叉树的每个节点的左右两颗子树的高度差不能超过1;
1.当前节点的左树和右树的差是否<=1;
2.看左树是否平衡,右树是否平衡,
public int hight(TreeNode root){
if(root==null)return 0;
int leftHight = hight(root.left);
int rightHight = hight(root.right);
if(Math.abs(leftHight-rightHigt)<=1){
return Math.max(leftHight,rightHight)+1;
}else{
retuen -1;
}
}
public boolean isBalanced(TreeNode root){
if(hight(root)>=0){
return true;
}
return false;
}
从前序遍历创建,递归栈为空时,返回null遍历停止;
public static int i=0;
public static BTNode creatTree(String str){
if(str==null || str.length()<=0)return null;
BTNode root = null;
if(s.charAt(i)!='#'){
root = new BTNode(str.charAt(i));
i++;
root.left = createTree(str);
root.right = createTree(str);
}else{
i++;
}
return root;
}
根节点本身是否为p,q当中的某个节点
根的左,根的右,
左右两边都不为空,root是公共祖先。左边不为空,右边为空,左边第一次找到的节点就是公共祖先。左边为空,右边不为空右边第一个节点为公共祖先
public static lowestCommonAncestor(TreeNode root,TreeNode P,TreeNode q){
if(root==null)return null;
if(root==p||root==q){
return root;
}
TreeNode left = lowestCommonAncestor(root.left, p, q);
TreeNode right = lowestCommonAncestor(root.right, p,q);
if(left!=null&&right!=null)return root;
if(left!=null)return left;
if(right!=null)return right;
return null;
}
左树的值是小于根的,右树的值大于根,所有节点满足此条件
转换为二叉搜索树;利用中序遍历解答
public TreeNode prev = null;
public void ConvertChild(TreeNode pcur){
if(pcur==null)return;
ConvertChild(pcur.left);
pcur.left = prev;
if(prev!=null){
prev.right = pcur;
}
prev=pcur;
ConvertChild(pcur.right);
}
public TreeNode Convert(TreeNode proottree){
if(proottree==null)return null;
ConvertChild(proottree);
TreeNode head = proottree;
while(head.left!=null){
head=head.left;
}
}
思路:用前序遍历找到根,用中序遍历确定左树和右树
class Solution {
private int preIndex=0;
public TreeNode buildTreeChild(int[] preorder,int[] inorder,int inbegin,int inend){
if(inbegin>inend)return null;
TreeNode root = new TreeNode(preorder[preIndex]);
int index = findValInorder(inorder,preorder[preIndex],inbegin,inend);
preIndex++;
root.left = buildTreeChild(preorder,inorder,inbegin,index-1);
root.right = buildTreeChild(preorder,inorder,index+1,inend);
return root;
}
public int findValInorder(int[] inorder,int key,int inbegin,int inend){
for(int i=inbegin;i<=inend;i++){
if(inorder[i]==key){
return i;
}
}
return -1;
}
public TreeNode buildTree(int[] preorder, int[] inorder) {
if(preorder ==null||inorder==null)return null;
if(preorder.length==0||inorder.length==0){
return null;
}
int preIndex = 0;
TreeNode root = buildTreeChild(preorder,inorder,0,inorder.length-1);
return root;
}
}
你需要采用前序遍历的方式,将一个二叉树转换成一个由括号和整数组成的字符串。
空节点则用一对空括号 “()” 表示。而且你需要省略所有不影响字符串与原始二叉树之间的一对一映射关系的空括号对。
需要注意的是:二叉树的遍历中间需要添加括号,递归的终止条件和递归的起始条件
class Solution {
public String tree2str(TreeNode root) {
StringBuilder sb = new StringBuilder();
tree2strChild(root,sb);
return sb.toString();
}
public void tree2strChild(TreeNode t,StringBuilder sb){
if(t==null)return;
sb.append(t.val);
if(t.left==null){
if(t.right==null){
return;
}else{
sb.append("()");
}
}else{
sb.append("(");
tree2strChild(t.left,sb);
sb.append(")");
}
if(t.right==null){
return;
}else{
sb.append("(");
tree2strChild(t.right,sb);
sb.append(")");
}
}
}