数据结构--二叉树详解（知识点+习题）

最新推荐文章于 2024-08-25 21:49:30 发布
最新推荐文章于 2024-08-25 21:49:30 发布
阅读量638 收藏 11
点赞数 11
文章标签： 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2302_81705247/article/details/140649770
版权

一，概念

1，结点的度：一个结点含有子树的个数称为该结点的度

2， 树的度：一棵树中，所有结点度的最大值称为树的度；

3，叶子结点或终端结点：度为0的结点称为叶结点； 

4，双亲结点或父结点：若一个结点含有子结点，则这个结点称为其子结点的父结点,

5，孩子结点或子结点：一个结点含有的子树的根结点称为该结点的子结点；

6，根结点：一棵树中，没有双亲结点的结点；

7，树的高度或深度：树中结点的最大层次；

二，二叉树的分类

1，满二叉树

每层的结点数都达到最大值，则这棵二叉树就是满二叉树。满二叉树是一种特殊的完全二叉树

2，完全二叉树

从上到下，从左到右一次排列

三，二叉树的基本性

1，若规定根节点的层数为1，则一颗非空二叉树的第i层上最多有2^i-1个节点

2， 如规定根结点的二叉树的深度为为1，则深度为k的二叉树的最大节点数是2^-1

3，对任意一颗二叉树，如果其叶节点的个数为n0，度为2的非叶节点个数为n2，则有n0=n2+1

4,具有n个节点的完全二叉树的深度为log2（n+1）上取整

5，对于具有n个节点的完全二叉树，如果按照从上至下从左至右所有节点从0开始编号，如果父节点的下标为i，则孩子节点为2i+1，2i+2。但是如果2i+1>=n,左无左孩子，若2i+2>=n，否则没有右孩子

6，知道孩子的下标，父节点的下标为（i-1）/2,如果i=0，则无则无双亲节点 

7, 二叉树存储分为顺序存储，和链式储存，链式储存是通过一个一个节点的引用起来的。

以链式储存为例：

例如：

public class BinaryTree {
    public TreeNode root;
    static class TreeNode{
        public char val;
        public TreeNode left;
        public TreeNode right;

        public TreeNode(char val) {
            this.val = val;
        }
    }

四，二叉树的遍历

分类：

二叉树的遍历分为大体四种：前序遍历，中序遍历，后序遍历，层序遍历。前三种遍历的方式又可以写为递归的形式和非递归的形式

前序遍历：

二叉树中的每一棵树都要符合先遍历根，然后遍历左树，最后是右树（根左右）

递归：

如果根为空，直接return。先打印根，然后打印左树，最后是右树

public void preOrder(TreeNode root){
    if (root==null){
        return;
    }
    System.out.print(root.val+" ");
    preOrder(root.left);
    preOrder(root.right);
}

非递归：

法一：
借助栈。先将根放到栈中，然后弹出，记录下来（赋值给cur），并打印。然后先将cur的右根放到栈中，再放cur的左根。在再弹出栈顶元素也就是左根，重复上述步骤（记录下来，并打印，将其右左树再放到栈中）

注意：

1，一定是先放右树，再放左树

2，将左右树放到栈中时要分别判断左右树是否为空，如果为空则不进栈

public void preOrder2(TreeNode root){
    Stack<TreeNode> stack=new Stack<>();
    stack.push(root);
    TreeNode cur=stack.pop();
    stack.push(cur.right);
    stack.push(cur.left);
    System.out.print(cur.val+" ");
    while (!stack.isEmpty()){
        cur=stack.pop();
        if (cur.right!=null){
            stack.push(cur.right);
        }
        if (cur.left!=null) {
            stack.push(cur.left);
        }
        System.out.print(cur.val+" ");
    }
}


法二：
借助栈。将root赋值给cur，进入两次循环，内循环是找到cur最左边的树并把过程中经过的每一个节点放到栈中，直到找到null。因为这里是前序遍历，所以每找到一个节点就要打印出来。当找到null时，走出循环。这时弹出栈顶元素，cur等于栈顶元素的右树（通过前面步骤，已知栈顶元素的左树为空）。然后cur开始外循环。由于内循环的条件是cur!=null，所以当右树为空时，不进入内循环，直接再次弹出栈顶元素。如果不为空是，则进入内循环，寻找它的左树……

public void preOrder3(TreeNode root){
    Stack<TreeNode> stack=new Stack<>();
    TreeNode cur=root;
    while (cur!=null||!stack.isEmpty()){
        while (cur!=null){
            stack.push(cur);
            System.out.print(cur.val+" ");
            cur=cur.left;
        }
        TreeNode old=stack.pop();
        cur=old.right;
    }
    System.out.println();
}

中序遍历：

二叉树中的每一棵树都要符合先遍历左树，然后遍历根，最后是右树（左根右）

递归：

public void midOrder(TreeNode root){
    if (root==null){
        return;
    }
    midOrder(root.left);
    System.out.print(root.val+" ");
    midOrder(root.right);
}

非递归：

与前序遍历非递归的法二原理相似，只是根打印的位置不相同，所以在走内循环时不打印节点，走完后，在打印，这样保证先打印的是左树。

public void midOrder2(TreeNode root){
    Stack<TreeNode>stack=new Stack<>();
    TreeNode cur=root;
    while (cur!=null||!stack.isEmpty()){
        while (cur!=null){
            stack.push(cur);
            cur=cur.left;
        }
        TreeNode old=stack.pop();
        System.out.print(old.val+" ");
        cur=old.right;
    }
    System.out.println();
}

后序遍历：

二叉树中的每一棵树都要符合先遍历左树，然后遍历右树，最后是根（左右根）

递归：

public void postOrder(TreeNode root){
    if (root==null){
        return;
    }
    postOrder(root.left);
    postOrder(root.right);
    System.out.print(root.val+" ");
}

非递归：

与中序遍历非递归思路相似，只是根打印的位置不相同，所以在走内循环，及走完内循环后均不打印，完成内循环后，直接判断栈顶元素右树是否为空，如果为空，就可以弹出栈顶元素，并且打印。但是如果不为空，就要先走右树（因为后序遍历的顺序是左右根，已知没有左树，所以要先打印右树）。

注意：要把每次遍历完的节点储存一下。因为每次内循环走完左树为空时，到判断栈顶元素A右树时（在右树不为空的情况下），这时会开始遍历右树，当遍历完右树后，又会回到这个起点（判断该栈顶元素A是否有右树），这时就会进入死循环，所以这里的判断条件进行丰富，即栈顶元素既有右树且之前没有遍历过【注意栈顶元素A,只是举了一个例子，方便理解！】

public void postOrder2(TreeNode root){
    Stack<TreeNode>stack=new Stack<>();
    TreeNode cur=root;
    TreeNode prev=null;
    while (cur!=null||!stack.isEmpty()){
        while (cur!=null){
            stack.push(cur);
            cur=cur.left;
        }
        TreeNode old=stack.peek();
        if (old.right==null||prev==old.right){
            stack.pop();
            System.out.print(old.val+" ");
            prev=old;
        }else {
            cur=old.right;

        }
    }
    System.out.println();
}

层序遍历：

一层一层的进行遍历

这里我们用到了队列，先把根放进去，弹出时，记录下来（赋值到ret中）并打印，然后根据ret，将ret的左树和右树也放到队列里面，重复上述步骤（弹出，记录下来，并打印，将其左右树再放到队列中），循环上述步骤，直到队列为空，则遍历完成。需要注意的是：将左右树放到队列中时要分别判断左右树是否为空，如果为空则不进队列，只有不为空时，才能放入。

法一：

public void levelOrder(TreeNode root){
    Queue<TreeNode> queue=new LinkedList<>();
    if (root==null){
        return;
    }
    queue.offer(root);
    while (!queue.isEmpty()){
        TreeNode ret=queue.peek();
        if (ret.left!=null){
            queue.offer(ret.left);
        }
        if (ret.right!=null){
            queue.offer(ret.right);
        }
        System.out.print(queue.poll().val+" ");
    }
    System.out.println();
}

法二：

这种方法是将每一层的节点放到一个链表中，然后将每一层的的链表放到一个“大的链表”中。先将根放到队列中，计算这一层的大小size，则决定着这一层的的链表的大小。然后循环size次，从而将这一层的每个元素均放到该层链表中。然后将这一层的每个元素的左右树再放到队列中，重复上述步骤，直到链表为空。

public List<List<Character>> levelOrder2(TreeNode root){
    List<List<Character>> ret=new LinkedList<>();
    if (root==null){
        return ret;
    }
    Queue<TreeNode> queue=new LinkedList<>();
    queue.offer(root);
    while (!queue.isEmpty()){
        int size= queue.size();
        List<Character> list=new LinkedList<>();
        while (size>0){
            TreeNode node=queue.peek();
            if (node.left!=null){
                queue.offer(node.left);
            }
            if (node.right!=null) {
                queue.offer(node.right);
            }
            list.add(queue.poll().val);
            size--;
        }
        ret.add(list);
    }
    return ret;

}

五，求二叉树的简单性质

1，一棵树的节点个数

法一：
我们遍历二叉树时，遍历了每个节点，所以只需要将遍历中打印的步骤改为count++，就可以得到节点的个数

public static  int sizeNode;
public void size2(TreeNode root) {
    if (root==null){
        return ;
    }
    sizeNode++;
    size2(root.left);
    size2(root.right);
}


法二：
一棵树的节点个数=这棵树的左子树的节点个数+右子树的节点个数+1.（这个1是根节点）

public int size(TreeNode root){
    if (root==null){
        return 0;
    }
    return 1+size(root.left)+size(root.right);
}


2，求叶子节点的个数

法一：
叶子结点的性质是左子树和右子树均为null，所以当遇到这样的节点时，返回1。整颗树的叶子结点个数=左子树叶子节点的个数+右子树叶子结点个数

public int getLeafNodeCount(TreeNode root){
    if (root==null){
      return 0;
    }
   if (root.left==null&&root.right==null){
       return 1;
   }
   return getLeafNodeCount(root.left)+getLeafNodeCount(root.right);
}


法二：
也可以遍历二叉树，找到左子树和右子树均为null的节点，count++.

public static  int sizeLeafNode;
public void getLeafNodeCount2(TreeNode root){
    if (root==null){
        return ;
    }
    if (root.left==null&&root.right==null){
       sizeLeafNode++;
    }
    getLeafNodeCount2(root.left);
    getLeafNodeCount2(root.right);

}

3，获取k层节点的个数

我们每递归一层时，让参数k-1，这样当k==1时，就是k层的节点，我们只需要返回1，整颗树的k层结点个数=左子树的k层节点的个数+右子树的k层结点个数

public int getKLevelNodeCount(TreeNode root,int k){
   if (root==null ){
       return 0;
   }
   if (k==1){
       return 1;
   }
   return getKLevelNodeCount(root.left,k-1)
           +getKLevelNodeCount(root.right,k-1);
}


4，树的高度

树的高度=左子树高度和右子树高度的最大值+1

public int getHeight(TreeNode root){
    if (root==null){
        return 0;
    }
    int leftHeight=getHeight(root.left);
    int rightHeight=getHeight(root.right);
    return Math.max(leftHeight,rightHeight)+1;
}

时间复杂度：O（n）

5，找到某个节点

如果找到该节点，返回该节点的根。左子树递归完后，如果找到了，直接返回，如果没有找到，再右子树递归，这样可以提高效率

public TreeNode find(TreeNode root,char val){
    if (root==null){
        return null;
    }
    if (root.val==val){
        return root;
    }
    TreeNode ret=find(root.left,val);
    if (ret!=null){
        return ret;
    }
    ret=find(root.right,val);
    if (ret!=null){
        return ret;
    }else {
        return null;
    }
}

六，简单应用

1，检查两棵树是否相同

如果两棵树均为空，则相同。因为我们需要用递归来实现，所以写的时候我们用if语句（两棵树一定不相同的条件）来快速排除

排除条件

（1）如果一棵树为空，一棵树不为空，直接返回false

（2）如果对应节点的值不一样，直接返回false

当两棵树对应的左树与右树均相同，则两棵树相同

public boolean isSameTree(TreeNode p,TreeNode q){
    if (p==null&&q==null){
        return true;
    }
    if (p==null&&q!=null||p!=null&&q==null){
        return false;
    }
    if (p.val!= q.val){
        return false;
    }
    return isSameTree(p.left,q.left)&&isSameTree(p.right,q.right);

}

总结：

* 时间复杂度：O(min（m,n）)
* @param p 有m个节点
* @param q 有n个节点

2，第二棵树是否是第一棵树的子树

我们先找到第一棵树是否有节点与第二棵树的根结点一致，如果有相同的节点，调用方法一，看两棵树是否相同。我们分别从左树和右树中寻找，只要有一边找到了，就说明第二棵树是第一棵树的子树

public boolean isSubTree(TreeNode root,TreeNode subRoot){
    if (root==null&&subRoot!=null){
        return false;
    }
    if (root.val== subRoot.val){
       return isSameTree(root,subRoot);
    }
    return isSubTree(root.left,subRoot)
            ||isSubTree(root.right,subRoot);
}

总结：

* 时间复杂度：O（m*n）
* @param root 有n个节点
* @param subRoot 有m个节点

3，翻转二叉树


当根为空，或者根的左右树均为空，则直接返回根。如果不是，交换左右树

private void swap(TreeNode root){
    TreeNode tmp=root.left;
    root.left=root.right;
    root.right=tmp;
}
public TreeNode reverseTree(TreeNode root){
    if (root==null||root.left==null&&root.right==null){
        return root;
    }
    swap(root);
    reverseTree(root.left);
    reverseTree(root.right);
    return root;
}


4，判断一棵二叉树是否是平衡二叉树

即：所有节点的高度差小于等于一

法一：
算左右树的高度，如果差的绝对值小于1，且左树和右树每一棵子树的左右树的高度差的绝对值小于1，则是平衡二叉树

public boolean isBalanced(TreeNode root){
    if (root==null){
        return true;
    }
    int leftHeight=getHeight(root.left);
    int rightHeight=getHeight(root.right);
    return Math.abs(leftHeight-rightHeight)<=1
            &&isBalanced(root.left)&&isBalanced(root.right);
}

总结：

* 时间复杂度：0（n*n）

法二（优化）：
重写计算书的高度的方法，如果树的左右树的高度差小于1，则返回该树的高度，如果高度差大于1，返回-1，最后看树的高度是否大于0，如果大于0，则说明每一棵树的左右子树的高度差均小于1，如果小于0，则说明有树的左右子树的高度差均大于1，则不是平衡二叉树

public int getHeight2(TreeNode root){
   if (root==null){
       return 0;
   }
   int left=getHeight2(root.left);
   if (left<0){
       return -1;
   }
   int right=getHeight2(root.right);
   if (right<0){
       return -1;
   }
   if (Math.abs(left-right)<=1){
       return Math.max(left,right)+1;
   }else {
       return -1;
   }
}
public boolean isBalanced2(TreeNode root){
    if (root==null){
        return true;
    }
    return getHeight2(root)>0;

}

总结：

* 时间复杂度：0（n）

5，对称二叉树

如果根为空或者根的左树右树均为空，则是对称二叉树。

（1）如果跟的左树，右树一个为空一个不为空，则不是对称二叉树

（2）如果根的左树和右树的值不一样，则不是对称二叉树

然后判断左右，这两棵树是否镜面对称，我们再写一个子方法。

（1）如果这两棵树的左右树均为空，则是对称二叉树

（2）如果一棵树的左树，与一棵树的右树，一颗为空，一颗不为空，则不是对称二叉树

（3）如果一棵树的右树，与一棵树的左树，一颗为空，一颗不为空，则不是对称二叉树

（4）如果一棵树的左树，与另一棵树的右树的值不相同，或者一棵树的右树，与一棵树的左树的值不相同，则不是对称二叉树

private boolean isSymmetricChild(TreeNode p,TreeNode q){
    if (p.left==null&&p.right==null&&q.left==null&&q.right==null){
        return true;
    }
    if (p.left!=null&&q.right==null
            ||p.left==null&&q.right!=null
            ||p.right!=null&&q.left==null
            ||p.right==null&&q.left!=null){
        return false;
    }
    if (p.left.val!=q.right.val
            ||p.right.val!=q.left.val){
        return false;
    }
    return isSymmetricChild(p.left,q.right)
            &&isSymmetricChild(p.right,q.left);
}

public boolean isSymmetric(TreeNode root){
    if (root==null||root.left==null&&root.right==null){
        return true;
    }
    if (root.left==null&&root.right!=null
            ||root.left!=null&&root.right==null){
        return false;
    }
    if (root.left.val!=root.right.val){
        return false;
    }
    return isSymmetricChild(root.left,root.right);
}

6，完全二叉树

前情提要：如果最后队列中含有非null的元素，则说明该树为非完全二叉树

利用队列，将根放到队列中，进入循环，弹出元素，判断元素是否为null，如果不为空，则将弹出元素的左树和右树放到队列中（注意：如果左右树为空，也要往队列里面放），如果为空，直接跳出循环。这个循环的条件为队列不为空。跳出循环后，遍历队列里面的元素，如果有不为空的元素时，这说明不是完全二叉树

public boolean isCompleteTree(TreeNode root){
    if (root==null){
        return true;
    }
   Queue<TreeNode>queue=new LinkedList<>();
   queue.offer(root);
   while (!queue.isEmpty()){
       TreeNode node=queue.poll();
       if (node==null){
           break;
       }
       queue.offer(node.left);
       queue.offer(node.right);
   }
   while (!queue.isEmpty()){
       if (queue.poll()!=null){
           return false;
       }
   }
   return true;
}

7，二叉树两节点的最近公共祖先

法一：

如果有一个节点等于根，那么公共祖先就是根，如果两个节点分别在，左树和右树上，则公共节点也是根，如果节点在同一侧树上，那么那么那侧树返回的值就是公共节点

public TreeNode lowestCommonAncestor(TreeNode root,TreeNode p,TreeNode q){
    if (root==null){
        return null;
    }
    if (p==root||q==root){
        return root;
    }
    TreeNode ret1=lowestCommonAncestor(root.left,p,q);
    TreeNode ret2=lowestCommonAncestor(root.right,p,q);
    if (ret1!=null&&ret2!=null){
        return root;
    } else if (ret1==null) {
        return ret2;
    }else {
        return ret1;
    }
}

法二：

（1）通过栈，保存下来从根到节点的路径

将根放到栈中，然后遍历根的左树，如果根的左树没有该节点，返回的是false，那么判断根的右树是否有该节点，如果也没有，那么说明这个根结点不在这条路径上，所以将这个根结点弹出。如果找到该节点，直接返回true。这时，栈里面就是这个节点的路径

（2）比较两个路径的长度，将长的路径的栈弹出栈顶元素，直到两个路径一样长。

（3）两个栈同时弹出栈顶元素，直到弹出的元素相同，则说明，该节点为他们的公共祖先

private boolean getPath(TreeNode root,TreeNode node,Stack<TreeNode> stack){
    if (root==null){
        return false;
    }
    stack.push(root);
    if (root==node){
        return true;
    }
    boolean flag1=getPath(root.left,node,stack);
    if (flag1){
        return true;
    }
    boolean flag2=getPath(root.right,node,stack);
    if (flag2){
        return true;
    }
    stack.pop();
    return false;

}
public TreeNode lowestCommonAncestor2(TreeNode root, TreeNode p,TreeNode q) {
    if (root==null){
        return null;
    }
    Stack<TreeNode> stackP=new Stack<>();
    Stack<TreeNode> stackQ=new Stack<>();
    getPath(root,p,stackP);
    getPath(root,q,stackQ);
    int size1= stackP.size();
    int size2= stackQ.size();
    int size;
    if (size1>size2){
        size=size1-size2;
        while (size>0){
            stackP.pop();
            size--;
        }
    }else {
        size=size2-size1;
        while (size>0){
            stackQ.pop();
            size--;
        }
    }
    while (!stackP.isEmpty()&&!stackQ.isEmpty()){
        if (stackP.peek()==stackQ.peek()){
            return stackP.pop();
        }else {
            stackP.pop();
            stackQ.pop();
        }
    }
    return null;
}

七，利用两种遍历结果，构造二叉树

1，前序与中序遍历来构造二叉树

根据前序遍历的第一的元素A，在中序遍历中找到这个元素的下标，然后A的左树在0，到下标的前一个寻找前序遍历的第二个元素，从而构建左树，右树也是一样的。

private static int proIndex;
private int findIndex(char[] midOrder,TreeNode node,int start,int end){
    for (int j = start; j <= end; j++) {
        if (midOrder[j]==node.val){
            return j;
        }
    }
    return -1;
}
private TreeNode buildTreePMChild(char[] proOrder,char [] midOrder,int midBegin,int midEnd){
    if (midBegin>midEnd){
        return null;
    }
    TreeNode root=new TreeNode(proOrder[proIndex]);
    int rootIndex=findIndex(midOrder,root,midBegin,midEnd);
    proIndex++;
    root.left=buildTreePMChild(proOrder,midOrder,midBegin,rootIndex-1);
    root.right=buildTreePMChild(proOrder,midOrder,rootIndex+1,midEnd);
    return root;
}
public  TreeNode buildTreePM(char[] proOrder,char [] midOrder){
    return buildTreePMChild(proOrder,midOrder,0,midOrder.length-1);

}

2，根据中序和后序进行创建一个二叉树

private static int postIndex;
private TreeNode buildTreeMPChild(char[] midOrder,char [] postOrder,int midBegin,int midEnd){
    if (midBegin>midEnd){
        return null;
    }
    TreeNode root=new TreeNode(postOrder[postIndex]);
    int midIndex=findIndex(midOrder,root,midBegin,midEnd);
    postIndex--;
    root.right=buildTreeMPChild(midOrder,postOrder,midIndex+1,midEnd);
    root.left=buildTreeMPChild(midOrder,postOrder,midBegin,midIndex-1);
    return root;


}
public  TreeNode buildTreeMP(char[] midOrder,char [] postOrder){
    postIndex=postOrder.length-1;
    return buildTreeMPChild(midOrder,postOrder,0,midOrder.length-1);
}

3，根据前序遍历（标明了空节点的位置），构造二叉树

定义一个root变量，并初始化为null。遍历字符串，如果字符不等于#，那么创建一个节点，i++，如果字符等于#，则i++，向后遍历。

private static int i;
public TreeNode createTree2(String str){
    TreeNode root=null;
    if (str.charAt(i)!='#'){
        root=new TreeNode(str.charAt(i));
        i++;
        root.left=createTree2(str);
        root.right=createTree2(str);
    }else {
        i++;
    }
    return root;
}

八，练习

根据二叉树创建一个字符串

//给你一个二叉树的根结点，请你采用前序遍历的方式，将二叉树转换成为一个由括号和字符组成的字符串
//空节点由一对括号表示，省略没有意义的括号
//输入【1，2，3，4】输出：1（2（4））（3）
//输入【1,2，3，null，4】输出：1（2（）（4））（3）
private void tree2strChild(TreeNode root,StringBuilder stringBuilder){
    if (root==null){
        return;
    }
    stringBuilder.append(root.val);
    if (root.left!=null){
        stringBuilder.append('(');
        tree2strChild(root.left,stringBuilder);
        stringBuilder.append(')');
    }else//左边为空
        {
            //两边均为空
        if (root.right==null){
            return;
        }else {
            stringBuilder.append("()");
        }
    }
    if (root.right!=null){
        stringBuilder.append('(');
        tree2strChild(root.right,stringBuilder);
        stringBuilder.append(')');
    }else {
        return;
    }
}
public String tree2str(TreeNode root){
    StringBuilder stringBuilder=new StringBuilder();
    tree2strChild(root,stringBuilder);
    return stringBuilder.toString();
}
ABdolphin
关注
  • 11
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据结构（C语言版） 第五章 树与二叉树 知识梳理 + 作业习题详解1
08-04
本文主要梳理了树与二叉树的相关知识点，并包含了相关作业习题的详解。 首先，树被定义为一个有限集合，其中包含一个特殊的根节点以及可能的子树集合。每个子树本身也是一个树，这种定义具有递归性。在树的结构中，...
考研-数据结构-殷人昆.zip
09-09
1.1 针对考研数据结构的代码书写规范以及C 与C 语言基础1 1.1.1 考研综合应用题中算法设计部分的代码书写规范1 1.1.2 考研中的C 与C 语言基础3 1.2 算法的时间复杂度与空间复杂度分析基础 12 1.2.1 考研中的算法时间...
数据结构--二叉树详解
2302_81705247的博客
07-24 841
二叉树的分类、二叉树的遍历。一棵树的节点个数，求叶子节点的个数，获取k层节点的个数，树的高度，找到某个节点，检查两棵树是否相同，第二棵树是否是第一棵树的子树，翻转二叉树，判断一棵二叉树是否是平衡二叉树，对称二叉树
二叉树习题汇总
qq_74336191的博客
05-08 875
所以，其实这道题和相同的树有点类似，都是先比较根节点，再比较根节点的左右子树。对称二叉树是左子树和右子树进行比较， 左子树的左子树与右子树的右子树进行比较，以及左子树的右子树与右子树的左子树进行比较。可以通过比较根节点的左右子节点是否相等，以及递归地比较左子树的左子节点与右子树的右子节点，左子树的右子节点与右子树的左子节点，来判断二叉树是否对称。今天我们学习了7道二叉树的练习题，说句心里话，第一次我做题的时候，也是迷迷糊糊，磕磕碰碰，但是多做几遍，多画一画图，我相信，小伙伴们都能学会~Ready Go!
化解数据结构----树与二叉树 知识梳理 + 习题详解
Hello大家好，我是Dream，如果帮得到你，那我深感荣幸！交流学习、商务合作：https://bbs.csdn.net/topics/614347534
05-08 4012
化解数据结构----树与二叉树 知识梳理 + 习题详解
数据结构-二叉树详解（原理+基本操作Java实现）
m0_62468521的博客
01-06 568
二叉树详解（原理+基本操作Java实现）通俗易懂，拿捏二叉树简简单单
分分钟带你解决数据结构------Java详解二叉树
baiyang2001的博客
02-11 786
声明：此博客涵盖众多二叉树知识点，可供学校期末考试，可供提升对二叉树的理解 文章前提： 通过本文章可以掌握： 二叉树数据结构的概念和基本实现 二叉树前中后序的递归写法 掌握二叉树层序的写法 二叉树的前中后序的非递归写法 二叉树相关的面试题 文章目录： ...
【数据结构】二叉树知识点详解
Money、坤的博客
05-20 3875
二叉树 一、概念 1. 1 定义 一棵二叉树是结点的一个有限集合，该集合或者为空，或者是由一个根节点加上两棵别称为左子树和右子树的二叉树组成。 二叉树的特点： 每个结点最多有两棵子树，即二叉树不存在度大于 2 的结点。 二叉树的子树有左右之分，其子树的次序不能颠倒，因此二叉树是有序树。 如下图为一颗二叉树：1. 2 概念 节点的度：一个节点含有的子树的个数称为该节点的度； 如上图：A的为6； 树的度：一棵树中，最大的节点的度称为树的度； 如上图：树的度为6 叶子节点或终端节点：度为0的节点称
【数据结构】---详解二叉树--- ⌈知识点总结⌋ 和 ⌈常见力扣题目⌋ 确定不来看吗？
weixin_69323265的博客
11-16 1182
🤗这就是一棵树，那它怎么表示的呢？我们一般用左孩子、右兄弟。 二、二叉树结构及遍历 1、二叉树性质 1、若根节点层数为i，则一颗非空二叉树的第i层上最多有2^(i-1)； 2、若根节点层数为i，则深度为H的最大二叉树的最大节点数为（2^H）-1； 3、对于任何一颗二叉树，如果度为0其叶节点个数为n0，度为2的分支节点个数为n2，则有 n0=n2+1；🐹我们重点说的是二叉树。。。 任何一个二叉树都可以分成三个部分： 0️⃣ 根节点 1️⃣ 左子树 2️⃣ 右子树 我们这主要用的是：分而治之，大问题分成类似
《数据结构》C语言版（清华严蔚敏考研版） 全书知识梳理 + 练习习题详解（超详细清晰易懂）
热门推荐
繁凡さん的博客
04-15 22万+
《数据结构》知识梳理，适合考前复习，高分冲刺。包含大量习题，偷偷告诉你，考试就考这个
数据结构（C语言版） 第 五 章 树与二叉树 知识梳理 + 作业习题详解
繁凡さん的博客
05-18 2万+
目录树和二叉树一.树2.有序树和无序树3.森林4.树的基本性质 本系列博客为《数据结构》（C语言版）的学习笔记（上课笔记），仅用于学习交流和自我复习 数据结构合集链接： 《数据结构》C语言版（严蔚敏版） 全书知识梳理（超详细清晰易懂） 树和二叉树 一.树 树：是N(N≥0)个结点的有限集合，N=0时，称为空树，这是一种特殊情况。在任意一棵非空树中应满足： 有且仅有一个特定的称为根的结点。 当N>1时，其余结点可分为m(m>0)个互不相交的有限集合T1,T2,…,Tm，其中每一个集合本身
严蔚敏《数据结构》（C语言版）笔记和习题（含考研真题）详解
01-15
这本书以C语言为编程工具，深入浅出地讲解了数据结构这一核心课程的知识点。数据结构是计算机科学中的基石，它探讨如何有效地组织和管理数据，以便在计算机程序中实现高效的数据操作。 首先，数据结构是计算机科学...
数据结构习题解析-第二版殷人昆
04-16
通过《数据结构习题解析-第二版殷人昆》，读者可以逐步熟悉并掌握这些关键知识点，同时通过习题实践，加深对理论的理解，提高编程技巧。书中的习题覆盖了各种难度，从基础练习到挑战性问题，适合不同程度的学习者。...
数据结构与算法期末练习题(含答案).doc
06-11
#### 二、选择题知识点详解 1. **数据结构类型与特性** - **循环队列**：是一种特殊的队列，通过将队列的头部和尾部连接起来形成一个循环的形式来解决队列的“假溢出”现象。 - **链表**：是由一系列节点组成的...
Python-MNE-源定位和逆问题01：源估计（SourceEstimate）数据结构
weixin_58312922的博客
08-25 672
stc是MNE-Python的一个类，表示从源估计中获得的转换的时间序列。对于两个半球，数据分别存储在和中，储存形式为的形式为一个m*n的矩阵，m是这个半球的空间位置的数量，n是时间点的个数。和对应和。这些是表面表征的位置索引。表面的坐标存储在和中，分别表示左半球和右半球。
排序------快速排序（C语言实现）
markingyi的博客
08-25 842
讲解快速排序原理，并通过例题使用C语言实现。
八股总结-----C++、数据结构、算法
最新发布
m0_48022770的博客
08-25 331
存储可执行代码（程序指令）。：存储全局变量和静态变量（已初始化和未初始化）。：用于动态内存分配，由程序员管理。：存储函数调用中的局部数据（局部变量、参数、返回地址）。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值