数据结构及算法练习--树相关

最新推荐文章于 2022-07-01 16:38:06 发布
最新推荐文章于 2022-07-01 16:38:06 发布
阅读量327 收藏 1
点赞数
分类专栏： 算法及数据结构 文章标签： 树 二叉树 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013679744/article/details/79182367
版权

   上一章写了总结了一些链表的算法操作，另外，在实际中树尤其是二叉树的操作也是很重要的，接下来再总结一下。类名后边的数字是剑指offer书上的题号，题目都是在牛客网上AC的，但是它们的那个平台的方法入口名有些不规范。

判断是否是二叉搜索树的后序遍历

/**
 * 题目描述:输入一个整数数组，判断该数组是不是某二叉搜索树的后序遍历的结果。如果是则输出Yes,否则输出No。
             假设输入的数组的任意两个数字都互不相同。
			 
   注意：二叉搜索树后序遍历的特点
 */
public class VerifySquenceOfBST24 {
    public boolean verifySquenceOfBST(int [] sequence) {
        if (sequence == null || sequence.length <= 0) {
            return false;
        }
        
        return verifyBST(sequence, 0, sequence.length - 1);
        
    }
    
    public boolean verifyBST(int [] sequence, int start, int end) {
        // 如果start >= end 就说明没有左右子树了
        if (start >= end) {
            return true;
        }
        //后序遍历最后一个是根
        int root = sequence[end];
        //找左子树部分
        int i = start;
        for (; i < end; i++) {
            if (sequence[i] > root) {
                break;
            }
        }
        // 右子树部分 如果右子树部分还有小于根的，就要直接返回false
        int index = i;
        for (i = index; i < end; i++) {
            if (sequence[i] < root) {
                return false;
            }
        }
        // 再递归验证
        return verifyBST(sequence, start, index - 1) && verifyBST(sequence, index, end - 1);
    }
    
}

二叉树的深度

/**
public class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;

    public TreeNode(int val) {
        this.val = val;

    }

}
*/
/**
 * 输入一棵二叉树，求该树的深度。
 * 从根结点到叶结点依次经过的结点（含根、叶结点）形成树的一条路径，最长路径的长度为树的深度。
 * 树的遍历  递归实现
 */
public class TreeDepth39 {
    public int TreeDepth(TreeNode root) {
		if (root == null) {
            return 0;
        }
        return 1 + Math.max(TreeDepth(root.left), TreeDepth(root.right));
    }
}

序列化二叉树

/*
public class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;

    public TreeNode(int val) {
        this.val = val;

    }

}
*/
/**
 * 序列化和反序列化树
 * 1. 生成中序、前序遍历，然后实现反序列化
   2. 前序遍历，但是将null用特殊符号来表示，从而实现反序列化 递归实现
 */
public class SerializeTree62 {
    // index用来记录字符串序列化的位置
    int index = -1;
    // 前序遍历，null用'#'字符表示，并节点用','号分割
    String Serialize(TreeNode root) {
        StringBuilder sb = new StringBuilder();
        if (root == null) {
            sb.append("#,");
            return sb.toString();
        }
        sb.append(root.val);
        sb.append(",");
        sb.append(Serialize(root.left));
        sb.append(Serialize(root.right));
        return sb.toString();
    }
    //反序列化，按照序列化的规则
    TreeNode Deserialize(String str) {
        index++;
        TreeNode root = null;
        String[] splits = str.split(",");
        // 这个判断其实是递归退出条件
        if (!"#".equals(splits[index])) {
            root = new TreeNode(Integer.valueOf(splits[index]));
            root.left = Deserialize(str);
            root.right = Deserialize(str);
        }
        return root;
    }
}

重建二叉树

/**
 * Definition for binary tree
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
/**
 * 题目描述
   输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。
   假设输入的前序遍历和中序遍历的结果中都不含重复的数字。
   例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。
 * 前序遍历，第一个是根，然后把中序遍历分为两部分，再根据中序遍历的分的左子树、右子树部分，再把前序遍历分为两部分
   从而又和原问题一样了，所以继续递归
 */
public class ReConstructBinaryTree06 {
    public TreeNode reConstructBinaryTree(int [] pre,int [] in) {
        if (pre == null || in == null || pre.length <= 0 || in.length <= 0 || pre.length != in.length) {
            return null;
        }
       return constructBinaryTree(pre, in, 0, pre.length - 1, 0, in.length - 1);
    }
    
    // 关键问题是划分 前、中序遍历。找到相应的位置即可实现递归
    public TreeNode constructBinaryTree(int [] pre,int [] in,int start1, int end1, int start2, int end2) {
        if (start1 > end1 || start2 > end2) {
            return null;
        }
        TreeNode root = new TreeNode(pre[start1]);
        int indexIn = start2;
        for (; indexIn <= end2; indexIn++) {
            if (in[indexIn] == root.val) {
                break;
            }
        }
        int num = indexIn - start2;
        
        root.left = constructBinaryTree(pre, in, start1 + 1, start1 + num, start2, indexIn - 1);
        
        root.right = constructBinaryTree(pre, in, start1 + num + 1, end1, indexIn + 1, end2);
        
        return root;
    }
}

从上到下打印二叉树


import java.util.*;
/**
public class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;

    public TreeNode(int val) {
        this.val = val;

    }

}
*/
/**
 * 题目描述:从上往下打印出二叉树的每个节点，同层节点从左至右打印。
 * 层次遍历  队列
 */
public class PrintTreeFromTopToButtom23 {
    public ArrayList<Integer> printFromTopToBottom(TreeNode root) {
		ArrayList<Integer> list = new ArrayList<Integer>();
        if (root == null) {
            return list;
        }
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while (!queue.isEmpty()) {
            TreeNode node = queue.poll();
            list.add(node.val);
            if (node.left != null) {
                queue.offer(node.left);
            }
            if (node.right != null) {
                queue.offer(node.right);
            }
        }
        return list;
    }
}

按之字形打印二叉树

import java.util.*;

/*
public class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;

    public TreeNode(int val) {
        this.val = val;

    }

}
*/
/**
 * 之字形打印树，用两个栈来实现，第一个奇数行（首行为第一行）左右遍历放入第一个栈1，
 * 然后遍历第二行时右左遍历放在栈2，用两个栈来实现，第一个奇数行（首行为第一行）左右遍历放入第一个栈1，
 * 然后遍历第二行时右左遍历放在栈2
 */
public class PrintTreeByZhi61 {
    public ArrayList<ArrayList<Integer> > Print(TreeNode pRoot) {
        ArrayList<ArrayList<Integer>> list = new ArrayList<ArrayList<Integer>>();
        if (pRoot == null) {
            return list;
        }
        LinkedList<TreeNode> stack1 = new LinkedList<>();
        LinkedList<TreeNode> stack2 = new LinkedList<>();
        int level = 1;    //用来判断是左右遍历还是右左遍历
        
        stack1.push(pRoot);

        while(!stack1.isEmpty() || !stack2.isEmpty()) {
            ArrayList<Integer> nodeList = new ArrayList<>();
            // 需要左右遍历stack1，子节点放入stack2
            if ((level & 1) == 1) {
                level++;
                while(!stack1.isEmpty()) {
                    TreeNode node = stack1.pop();
                    nodeList.add(node.val);
                    if (node.left != null) {
                        stack2.push(node.left);
                    }
                    if (node.right != null) {
                        stack2.push(node.right);
                    }
                }
            } else {
                level++;
                while(!stack2.isEmpty()) {
                    TreeNode node = stack2.pop();
                    nodeList.add(node.val);
                    if (node.right != null) {
                        stack1.push(node.right);
                    }
                    if (node.left != null) {
                        stack1.push(node.left);
                    }
                }
            }
            list.add(nodeList);
        }
        return list;
    }

}

二叉树层次遍历

import java.util.*;
/*
public class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;

    public TreeNode(int val) {
        this.val = val;

    }

}
*/
/**
 * 树的层次遍历，用队列实现
 * 第一步就要先把root入队
 */
public class PrintTree60 {
    ArrayList<ArrayList<Integer> > Print(TreeNode pRoot) {
        ArrayList<ArrayList<Integer>> list = new ArrayList<>();
        if (pRoot == null) {
            return list;
        }
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(pRoot);
        while (!queue.isEmpty()) {
            ArrayList<Integer> nodeVal = new ArrayList<>();
            // 用一个数来判断此层需要打印的数目   
            int end = queue.size();
            // 一次把这层所有的节点的值保存
            while (end != 0) {
                TreeNode node = queue.poll();
                nodeVal.add(node.val);
                if (node.left != null) {
                    queue.offer(node.left);
                }
                if (node.right != null) {
                    queue.offer(node.right);
                }
                end--;
            }
            list.add(nodeVal);
        }
        return list;
    }
    
}

二叉树镜像

/**
public class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;

    public TreeNode(int val) {
        this.val = val;

    }

}
*/
/**
 * 二叉树镜像
 * 递归实现  
 */ 
public class Mirror19 {
    public void mirror(TreeNode root) {
		mirrorTree(root);
    }
    
    public TreeNode mirrorTree(TreeNode root) {
        if (root == null) {
            return null;
        }
        TreeNode temp = mirrorTree(root.left);
        root.left = mirrorTree(root.right);
        root.right = temp;
        return root;
    }
}

数据流中的中位数

import java.util.*;
/**
 * 题目描述:
		如何得到一个数据流中的中位数？如果从数据流中读出奇数个数值，
		那么中位数就是所有数值排序之后位于中间的数值。如果从数据流中读出偶数个数值，那么中位数就是所有数值排序之后中间两个数的平均值。
 * 解决此问题有多种方法：1. 利用无序数组，实现O(1)插入，O(n)获取  partition函数获取
                      2. 插入排序实现有序插入O(n)，O(1)实现获取
                      3. AVL树实现O(logn)
                      4. 两个堆，一个最小堆，一个最大堆，把数据分为两部分，从而实现O(logn)插入，O(1)获取
 */
public class MedianData64 {
    //默认是小顶堆   存的是数据流的后半部分
    private PriorityQueue<Integer> minHeap = new PriorityQueue<>();
    //自定义排序规则，实现大顶堆  实际上存的是数据流的前半部分
    private PriorityQueue<Integer> maxHeap = new PriorityQueue<>(new Comparator<Integer>() {
       @Override
        public int compare(Integer o1, Integer o2) {
            return o2 - o1;
        }
    });
    //记录总数  奇数放在大顶堆（前半部分），但要经过小顶堆的判断，，偶数个放在小顶堆  且要经过大顶堆判断
    private int count = 0;

    public void Insert(Integer num) {
        count++;
        // 奇数放在最大堆，且确保最大堆放的是数据流的前半部分（即：排序的小的部分）
        if ((count & 1) == 1) {
            if (!minHeap.isEmpty() && minHeap.peek() < num) {
                maxHeap.offer(minHeap.poll());
                minHeap.offer(num);
            } else {
                maxHeap.offer(num);
            }
        } else {
            if (!maxHeap.isEmpty() && maxHeap.peek() > num) {
                minHeap.offer(maxHeap.poll());
                maxHeap.offer(num);
            } else {
                minHeap.offer(num);
            }
        }
    }

    public Double GetMedian() {
         if ((count & 1) == 1) {
             return maxHeap.peek() * 1.0;
         } else {
             return (maxHeap.peek() + minHeap.peek()) / 2.0;
         }
    }

}

二叉搜索树的第K大的数

/*
public class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;

    public TreeNode(int val) {
        this.val = val;

    }

}
*/
/**
 * 题目描述：
   给定一颗二叉搜索树，请找出其中的第k大的结点。例如， 5 / \ 3 7 /\ /\ 2 4 6 8 中，按结点数值大小顺序第三个结点的值为4。
 * 中序遍历到第k个元素即可 1. 用一个容器来保存遍历结果
                        2. 递归实现，需要用一个全局变量来保存遍历的数目
 */
public class KthNode63 {
    private int kthNum = 0;
    TreeNode KthNode(TreeNode pRoot, int k) {
        if (pRoot == null || k <= 0) {
            return null;
        }
        kthNum = k;
        return KthNodeCore(pRoot);
    }
    
     //中序遍历，实现肯定就是在中间的逻辑    
     TreeNode KthNodeCore(TreeNode pRoot) {
         // 感觉如果在遍历时写 if(pRoot.left != null){}  那么就可以不写这个边界
         // 但是，如果是在循环中遍历，就得写 if(pRoot.left != null) 才能进行下一步遍历
         //if (pRoot == null) {
           //  return null;
         //}
         TreeNode target = null;
         // 左中右
         if(pRoot.left!=null) {
             target = KthNodeCore(pRoot.left);
         }
         // 左子树没找到
         if (target == null) {
             if (kthNum == 1) {
                 target = pRoot;
             }
             kthNum--;
         }
         // 当前节点也不是
         if (target == null && pRoot.right != null) {
             target = KthNodeCore(pRoot.right);
         }
         return target;
     }
}

二叉树是不是对称的

/*
public class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;

    public TreeNode(int val) {
        this.val = val;

    }

}
*/
/**
 * 题目描述:请实现一个函数，用来判断一颗二叉树是不是对称的。注意，如果一个二叉树同此二叉树的镜像是同样的，定义其为对称的。
 * 有两种思想来解决此问题：1. 就是左==右，右==左，就是对称的
 *                      2. 剑指offer的思想，就是判断前序遍历（跟左右）是否等于对称遍历（根右左），这个思想还要考虑null
 */
public class IsSymmetrical59 {
    boolean isSymmetrical(TreeNode pRoot)
    {
        if (pRoot == null) {
            return true;
        }
        // 递归判断左右子树是否相等
        return isSymmetricalLeftAndRight(pRoot.left, pRoot.right);
    }
    
    boolean isSymmetricalLeftAndRight(TreeNode left, TreeNode right) {
        if (left == null && right == null) {
            return true;
        }
        if (left == null || right == null) {
            return false;
        }
        // 当前需相等，并且其子树也要对称
        if (left.val == right.val) {
           return isSymmetricalLeftAndRight(left.left, right.right) && isSymmetricalLeftAndRight(left.right, right.left);
        }
        return false;
    }
}

二叉树是否是平衡二叉树

/**
 * 题目描述：输入一棵二叉树，判断该二叉树是否是平衡二叉树。
 * 只要判断左右子树的高度不超过1，递归实现
 * 这样做应该会有大量的子问题存在，子树高度被算了很多次
 */
public class IsBalancedTree {
    public boolean IsBalanced_Solution(TreeNode root) {
        if(root == null) {
            return true;
        }
        int leftHeight = getHeight(root.left);
        int rightHeight = getHeight(root.right);
        if (Math.abs(leftHeight - rightHeight) > 1) {
            return false;
        }
        return IsBalanced_Solution(root.left) && IsBalanced_Solution(root.right);
    }
    
    /**
     * 求树的高度
     */
    public int getHeight(TreeNode root) {
        if (root == null) {
            return 0;
        }
        return 1 + Math.max(getHeight(root.left), getHeight(root.right));
    }
}

判断是否是其子树

/**
public class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;

    public TreeNode(int val) {
        this.val = val;

    }

}
*/
/**
 * 题目描述:输入两棵二叉树A，B，判断B是不是A的子结构。（ps：我们约定空树不是任意一个树的子结构）
 * 递归实现，先找相等节点，再每个节点递归判断
 */
public class HasSubtree18 {
    public boolean HasSubtree(TreeNode root1,TreeNode root2) {
        if (root1 == null || root2 == null) {
            return false;
        }
        // 如果当前节点相等，就进行判断子树是否相等
        boolean result = false;
		// 先判断当前节点是不是
        result = doesTree1HaveTree2(root1, root2) &&  doesTree1HaveTree2(root1, root2);

        // 如果当前节点不是，再判断子树中是否存在
        if (!result) {
           result = HasSubtree(root1.left, root2);
        }
        if (!result) {
           result = HasSubtree(root1.right, root2);
        }
        return result;
    }
 
    public boolean doesTree1HaveTree2(TreeNode node1, TreeNode node2) {
        if (node2 == null) {
            return true;
        }
        // node1结束了，node2还存在
        if (node1 == null) {
            return false;
        }
        // 当前节点和子节点都要相等
        if (node1.val == node2.val) {
            return doesTree1HaveTree2(node1.left, node2.left) && doesTree1HaveTree2(node1.right, node2.right);
        }
        return false;
    }
}

中序遍历顺序的下一个结点

/*
public class TreeLinkNode {
    int val;
    TreeLinkNode left = null;
    TreeLinkNode right = null;
    TreeLinkNode next = null;

    TreeLinkNode(int val) {
        this.val = val;
    }
}
*/
/*
  题目描述:
     给定一个二叉树和其中的一个结点，请找出中序遍历顺序的下一个结点并且返回。注意，树中的结点不仅包含左右子结点，同时包含指向父结点的指针。
  中序遍历：左根右 pNode是给的节点，返回其下一个节点
  1. 如果给定节点有右子树，那么下一个节点肯定是右子树的最左节点
  2. 如果没有右子树： 2.1 如果当前节点是其父节点的左子树，那么父节点肯定是下一个数
  					2.2 如果当前节点还是其父节点的右子树，那么就一直向上找，直到它是其父节点的左子树为止，或者为空（说明它是最右的那一个）
*/

public class GetNextNode58 {
    public TreeLinkNode getNext(TreeLinkNode pNode) {
        if (pNode == null) {
            return null;
        }
        // 如果有右子树，则返回右子树的最左节点
        if (pNode.right != null) {
            TreeLinkNode node = pNode.right;
            while (node.left != null) {
                node = node.left;
            }
            return node;
        } else {
            // 没有右子树，且是父节点的左子树，则下一个节点是其父节点
            if (pNode.next != null && pNode.next.left == pNode) {
                return pNode.next;
            } 
            // 没有右子树，且是父节点的右子树，则下一个节点是直到是父节点的左子树为止
            if (pNode.next != null && pNode.next.right == pNode) {
                pNode =  pNode.next;
                while (pNode.next != null && pNode.next.left != pNode) {
                    pNode =  pNode.next;
                }
                return pNode.next;
            }
        }
        // pNode.next == null 则返回null
        return null;
 
    }
}

打印二叉树中结点值的和为整数K的所有路径

import java.util.ArrayList;
/**
public class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;

    public TreeNode(int val) {
        this.val = val;

    }

}
*/
/**
 * 题目描述:输入一颗二叉树和一个整数，打印出二叉树中结点值的和为输入整数的所有路径。
           路径定义为从树的根结点开始往下一直到叶结点所经过的结点形成一条路径。
		   
 * 递归是一个回溯的过程，其实递归的调用也是一个压栈和出栈的过程
 * 采用前序遍历，查找路径，并回溯（其实也是一个DFS的过程）
 */
public class FindPathEqualsK25 {
    //声明为全局变量
    private ArrayList<ArrayList<Integer>> listAll = new ArrayList<ArrayList<Integer>>();
    private ArrayList<Integer> list = new ArrayList<Integer>();
    
    public ArrayList<ArrayList<Integer>> FindPath(TreeNode root,int target) {
        if(root == null) {
			return listAll;
		}
        list.add(root.val);
        target -= root.val;
        //到达叶节点且值相等
        if(target == 0 && root.left == null && root.right == null) 
            listAll.add(new ArrayList<Integer>(list));
        //前序遍历  因为是全局变量，所以返回值是没什么卵用的
        //从宏观角度来看  中左右 递归就是一个回溯过程
        FindPath(root.left, target);
        FindPath(root.right, target);
        //返回到父节点前，路径要删除当前节点
        list.remove(list.size()-1);
        return listAll;
    }
}

将二叉搜索树转换成一个排序的双向链表

/**
public class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;

    public TreeNode(int val) {
        this.val = val;

    }

}
*/
/**
 *题目描述:输入一棵二叉搜索树，将该二叉搜索树转换成一个排序的双向链表。要求不能创建任何新的结点，只能调整树中结点指针的指向。
 
 * 排序的双向链表，肯定是中序遍历实现，则逻辑在中间实现
 * 双向链表：用一个tailNode来记录链表的尾节点，则当前节点指向尾，尾再指向当前
 */
public class ConvertSearchTreeToList27 {
    TreeNode head = null;  // 记录整个双向链表的头节点
    TreeNode curTrailHead = null;  // 记录当前形成的链表的尾节点  需要全局的
    public TreeNode Convert(TreeNode pRootOfTree) {
        if (pRootOfTree == null) {
            return null;
        }
        // 左中右
        Convert(pRootOfTree.left);
        
        if (head == null) {
            head = pRootOfTree;
            curTrailHead = pRootOfTree;
        } else {
            pRootOfTree.left = curTrailHead;
            curTrailHead.right = pRootOfTree;
            // 更新其尾节点
            curTrailHead = pRootOfTree;
        }

        
        Convert(pRootOfTree.right);
        return head;
    }

}





冷面寒枪biu
关注
专栏目录
数据结构作业练习题（树-1）
m0_47084156的博客
11-27 890
数据结构作业练习题（树） 数据结构(C语言版)第2版—严蔚敏 （学习代码中。。。） 问题描述： 以二叉链表作为二叉树的存储结构，编写以下算法 （1）统计二叉树叶节点个数 （3）交换二叉树每个结点的左孩子和右孩子 题目分析： （1）如果二叉树为空，返回0，如果二叉树不为空且左右子树为空，返回1，如果二叉树不为空，且左右子树不同时为空，返回左子树中叶子节点个数加上右子树中叶子节点个数。 （3）如果某结点左右子树为空，返回，否则交换该结点左右孩子，然后递归交换左右子树。 解决方案： #include &l
数据结构与算法分类练习－－树 图
明日世界
07-29 501
生产力专家说，突破是通过“非线性”来思考的，树就是计算树中最重要的非线性数据结构之一。树结构确实是数据组织中的一个突破，因为它们允许我们实现比使用线性数据结构（如基于数组的列表或链表）快很多的算法。树的主要的用途是用来提高查找效率，如二叉排序树、FP-树。另外可以用来提高编码效率，如哈弗曼树。 树也为数据提供了自然的组织，因此在文件系统、图形用户界面、数据库、网站和其他计算机系统中已经成为无处不在...
数据结构-树的一些练习题
12-02
包含数据结构考试以及面试的一些题目,供读者进行练习
数据结构树练习
huayu8086的博客
07-01 372
1、请写出二叉树的二叉链表存储结构，基于此结构，设计算法：统计二叉树中结点个数。 2、请写出树的带双亲的孩子链表法存储结构，基于此结构，设计算法：计算树的度。
新手数据结构练习——二叉树
以和为贵
12-20 357
作为新手，写了一个二叉树作练习，希望能得到大佬的指点。package dataStructureSamples;import java.util.ArrayList; import java.util.List;import javax.security.auth.Destroyable;/** * 二叉树 * @author Miko * */ public class BinaryTre
7.数据结构与算法--电子课件.zip
最新发布
03-14
- 电子课件可能包括PPT讲解、示例代码、练习题和解答，帮助学习者全面掌握数据结构和算法的理论与实践。 通过学习这些内容，你可以提升编程能力，更好地理解和解决实际问题，为未来的软件开发打下坚实基础。记得...
数据结构与算法--二叉排序树（C++实现）
DeeperBlue的博客
04-16 1万+
二叉树也是常用的数据结构。一棵二叉树由根节点（可以为空）和左右子树（也是二叉树）构成。通常情况下，二叉树的效率比线性链表高，因为二叉树上的查询、插入等操作即相当于二分法操作。本文用C++实现二叉树的算法，是C++、数据结构及算法学习的一个小练习。供大家参考。
小甲鱼数据结构与算法课件+源码.zip_-baijiahao_expresschs_once4l3_小甲鱼 ppt_小甲鱼数据结
07-15
数据结构与算法是计算机科学的基础，对于任何编程和软件开发工作都至关重要。小甲鱼是一位知名编程教育者，他的课程以其通俗易懂、生动有趣的教学风格受到许多初学者的欢迎。"小甲鱼数据结构与算法课件+源码.zip" 是...
数据结构和算法-综合指南：数据结构和算法-综合指南
02-05
:high_voltage: 数据结构和算法-综合指南 数据结构和算法综合指南 目录 可靠的简单方法是走下坡的数据结构和算法，无风险且被广泛使用，请遵循： ！ 确保您详细了解了每个步骤，每个单独的链接中也提供了说明！ ...
【HBU】数据结构树练习题
热门推荐
韩旭051的博客
10-15 4万+
4-1 某二叉树的前序和后序遍历序列正好相反，则该二叉树一定是(4分) 空或只有一个结点 高度等于其结点数 任一结点无左孩子 任一结点无右孩子 作者: DS课程组 单位: 浙江大学 4-2 已知一棵二叉树的先序遍历结果是ABC，则以下哪个序列是不可能的中序遍历结果：(4分) ABC BAC CBA CAB 作者: DS课程组 单位: 浙江大学 4-3 ...
数据结构：树----刷题集（一）
Taro小峰的博客
09-16 3671
数据结构：树----刷题集（一）
数据结构二叉树题库
闲狗的博客
08-01 1万+
《数据结构二叉树之闲死攻略（一）》 目录 华文课后题 王道课后题 华文课后题 1、一棵有512个结点的完全二叉树的高度为多少？（独根树高度为1） 解析： 答案： 10 2、请写出下面这棵二叉树的中序遍历 解析： 左-根-右 left-root-right 答案： LXMECKPBQHDA 3、下列关于二叉树性质的说法正确的有： A、非空满二叉树的结点个数...
笔试题集锦（编程题）
weixin_33825683的博客
09-10 130
题目描述输入一个整数数组，判断该数组是不是某二叉搜索树的后序遍历的结果。如果是则输出Yes,否则输出No。假设输入的数组的任意两个数字都互不相同。//递归public class Solution {public boolean VerifySquenceOfBST(int [] sequence) {if(sequence.length==0)...
【无标题】
m0_62853794的博客
11-28 346
数据结构第五章算法设计题 ．算法设计题 以二叉链表作为二叉树的存储结构，编写以下算法： （ 1）统计二叉树的叶结点个数。 [ 题目分析 ] 如果二叉树为空，返回 0，如果二叉树不为空且左右子树为空，返回 1，如果 二叉树不为空，且左右子树不同时为空，返回左子树中叶子节点个数加上右子树中叶子 节点个数。 [ 算法描述 ] int LeafNodeCount(BiTree T) { if(TNULL) return 0; // 如果是空树，则叶子结点个数为 0 else if(T->lchildNULL&
[数据结构]关于树的练习题(1)
weixin_43962381的博客
01-10 5118
1.下列关于树的叙述正确的是（ ） A.树中可以有环 B.树的度是指所有结点中度最小的结点的度 C.树的深度指的是结点数最多的那一层的深度 D.树的根结点是所有结点的祖先结点 答案：D 解析： A: 树中的节点不能相交 B: 树的度为所有节点中最大节点的度 C: 树的深度为根节点到叶子节点的最大深度 2.2-3树是一种特殊的树，它满足两个条件： (1) 每个内部结点有两个或三个子结点 (2) 所有的叶结点到根的距离相同 如果一颗2-3树有10个结点，那么它有( )个叶结点。 A.7 B.8 C.7 或
数据结构树题库
闲狗的博客
08-01 5648
《数据结构树之切腹攻略》 目录 华文课后题 王道课后题 华文课后题 1、给出一棵树的逻辑结构T=(N,R),其中： N={A,B,C,D,E,F,G,H,I,J,K} R={r} r={(A,B),(B,E),(B,F),(F,G),(F,H),(A,C),(C,I),(C,J),(J,K),(A,D)} 试回答下列问题： （1）哪个是F的父结点？ （2）哪些是B的子孙？...
【数据结构习题】树
我的技术栈碎碎念空间
04-26 2847
关于一些数据结构中树的小练习与知识点，不定期更新总结内容 1、前中后缀表达式 中：A-B/C+D*E 加完整括号：((A-(B/C))+(D*E)) 移动符号并去掉括号 前：+(-(A/(B C))*(D E)) ------> +-A/BC*DE 后：((A (B C)/)-(D E)*)+ ------> ABC/-DE*+ 2、一棵树的度是可以小于2的 3、100个结点的完...
算法设计与分析——并查集（Union-find Disjoint Sets）
冯·诺依曼
02-25 1万+
一些应用涉及将nnn个不同的元素分成一组不相交的集合。这些应用经常需要进行两种特别的操作： 寻找包含给定元素的唯一集合 合并两个集合 一个不相交集合数据结构维护了一个不相交动态集的集合S={S1,S2,⋯ ,Sk}\mathbb{S}=\{S_1, S_2, \cdots, S_k\}S={S1​,S2​,⋯,Sk​}。我们用一个代表来标识每个集合，它是这个集合的某个成员。在一些应用中，我们不关心哪个成员被用来作为代表，仅仅关心的是2次查询动态集合的代表中，如果这些查询没有修改动态集合，则这两次查询应该
数据结构与算法分析-严蔚敏《数据结构》解读
Shaffer的《数据结构与算法分析》以及李春葆的《数据结构习题与解析》等书籍，这些资源能提供更丰富的视角和实践练习。 通过学习数据结构，程序员可以更好地理解和设计复杂系统中的数据组织，从而提高程序的性能...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值