第四课:二叉树

最新推荐文章于 2024-08-04 08:53:22 发布
最新推荐文章于 2024-08-04 08:53:22 发布
阅读量129 收藏
点赞数
分类专栏： 左神数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhiyongbo/article/details/114965625
版权

1.二叉树递归遍历
前序：

	public static void preOrderRecur(Node head) {
		if(head==null){
			return;
		}
		System.out.println(head.value);
		preOrderRecur(head.left);
		preOrderRecur(head.right);
	}

中序：

	public static void inOrderRecur(Node head) {
		if(head==null){
			return;
		}
		inOrderRecur(head.left);
		System.out.println(head.value);
		inOrderRecur(head.right);
	}

后序：

	public static void posOrderRecur(Node head) {
		if(head==null){
			return;
		}
		posOrderRecur(head.left);
		posOrderRecur(head.right);
		System.out.println(head.value);
	}

2.二叉树非递归遍历
前序：

	public static void preOrderUnRecur(Node head) {
		Stack<Node> stack = new Stack<>();
		stack.push(head);
		while(!stack.isEmpty()){
			Node h=stack.pop();
			System.out.println(h.value);
			if(h.right!=null){
				stack.push(h.right);
			}
			if(h.left!=null){
				stack.push(h.left);
			}
		}

中序：需要注意：第一次没写出来

	public static void inOrderUnRecur(Node head) {
		Stack<Node> stack=new Stack<>();
		while(!stack.isEmpty()||head!=null){
			if(head!=null){
				stack.push(head);
				head=head.left;
			}else{
				head = stack.pop();
				System.out.println(head.value);
				head=head.right;
			}
		}
	}

后序：

	public static void posOrderUnRecur1(Node head) {
		if(head!=null){
			Stack<Node> stack1=new Stack<>();
			Stack<Node> stack2=new Stack<>();
			stack1.push(head);
			while(!stack1.isEmpty()){
				head=stack1.pop();
				stack2.push(head);
				if(head.left!=null){
					stack1.push(head.left);
				}
				if(head.right!=null){
					stack1.push(head.right);
				}
			}
			while(!stack2.isEmpty()){
				System.out.println(stack2.pop().value);
			}
		}
	}

3.求二叉树的宽度
方法一：hashmap存当前节点的层数

	public static int getMaxWidth(Node head) {
		Queue<Node> queue=new LinkedList<>();
		queue.add(head);
		int maxWidth=Integer.MIN_VALUE;
		int curLevel=1;
		int curLevelNode=0;
		HashMap<Node,Integer> hashMap=new HashMap<>();
		hashMap.put(head,1);
		while(!queue.isEmpty()){
			head=queue.poll();
			if(hashMap.get(head)==curLevel){
				curLevelNode++;
			}else{
				maxWidth=Math.max(curLevelNode,maxWidth);
				curLevel++;
				curLevelNode=1;
			}
			if(head.left!=null){
				queue.add(head.left);
				hashMap.put(head.left,curLevel+1);
			}
			if(head.right!=null){
				queue.add(head.right);
				hashMap.put(head.right,curLevel+1);
			}
		}
		return maxWidth;
	}

方法二：

public static int getMaxWidth1(Node head){
		Queue<Node> queue=new LinkedList<>();
		Node curEnd=head;
		Node nextEnd=null;
		int curLevelNode=0;
		int max=0;
		queue.add(head);
		while(!queue.isEmpty()){
			head=queue.poll();
			curLevelNode++;
			if(head.left!=null){
				queue.add(head.left);
				nextEnd=head.left;
			}
			if(head.right!=null){
				queue.add(head.right);
				nextEnd=head.right;
			}
			if(head==curEnd){
				max=Math.max(max,curLevelNode);
				curEnd=nextEnd;
				curLevelNode=0;
			}
		}
		return max;
	}

4.判断一棵二叉树是否为搜索二叉树（左子树的值小于根，右子树的值大于根）
法一：中序遍历，拿list集合存，最终看是否为升序

	public static class Node {
		public int value;
		public Node left;
		public Node right;
		public Node(int data) {
			this.value = data;
		}
	}
	public static boolean isBST(Node head) {
		if(head==null){
			return true;
		}
		List<Node> inOrderList = new ArrayList<>();
		process(head,inOrderList);
		for (int i = 0; i < inOrderList.size()-1; i++) {
			if(inOrderList.get(i).value>inOrderList.get(i+1).value){
				return false;
			}
		}
		return true;
	}
	public static void process(Node node, List<Node> inOrderList) {
		if(node==null){
			return;
		}
		process(node.left,inOrderList);
		inOrderList.add(node);
		process(node.right,inOrderList);
	}

法二：二叉树的套路：看左树右树能提供什么信息（不熟练，需注意）

	public static class Information{
		public boolean isBst;
		public int max;
		public int min;

		public Information(boolean isBst, int max, int min) {
			this.isBst = isBst;
			this.max = max;
			this.min = min;
		}
	}
	
	public static boolean isBST1(Node head){
		if(head==null){
			return true;
		}
		Information infor=process1(head);
        return infor.isBst;
	}
	
	public static Information process1(Node node){
		if(node==null){
			return null;
		}
		Information inforLeft=process1(node.left);
		Information inforRight=process1(node.right);
		int max=node.value;
		int min=node.value;
		if(inforLeft!=null){
		    max=Math.max(max,inforLeft.max);
		    min=Math.min(min,inforLeft.min);
        }
        if(inforRight!=null){
            max=Math.max(max,inforRight.max);
            min=Math.min(min,inforRight.min);
        }
        boolean isBst=true;
		if(inforLeft!=null&&(inforLeft.isBst==false||inforLeft.max>=max)){
		    isBst=false;
		}
		if(inforRight!=null&&(inforRight.isBst==false||inforRight.min<=min)){
		    isBst=false;
        }
        return new Information(isBst,max,min);
	}

5.判断是否是完全二叉树
（1）任一节点，有右无左，false
（2）在（1）符合的条件下，遇到第一个左右孩子不双全，后续节点都为叶子节点

	public static boolean isCBT(Node head) {
		if(head==null){
			return true;
		}
		Queue<Node> queue=new LinkedList<>();
		queue.add(head);
		boolean isZi=false;//遇到第一个左右孩子不双全的节点变为true
		while(!queue.isEmpty()){
			Node poll = queue.poll();
			if (poll.left==null&&poll.right!=null){
				return false;
			}
			if(isZi==true){
				if (poll.left!=null||poll.right!=null){
					return false;
				}
			}
			if(poll.left!=null){
				Node left=poll.left;
				queue.add(left);
			}else{
				isZi=true;
			}
			if(poll.right!=null){
				Node right=poll.right;
				queue.add(right);
			}else{
				isZi=true;
			}
		}
		return true;
	}

6.判断是否是满二叉树
法一：求深度，求节点个数，满足nodeNum=2^depth-1

	public static boolean isFullTree(Node head){
		int depth = depth(head);
		int count = count(head);
		if(count==Math.pow(2,depth)-1){
			return true;
		}
		return false;
	}

	private static int depth(Node head) {
		int depth=1;
		while(head.left!=null){
			head=head.left;
			depth++;
		}
		return depth;
	}

	private static int count(Node head) {
		List<Node> list=new ArrayList<>();
		process(head, list);
		return list.size();
	}
	
	public static void process(Node head, List<Node> list){
		if(head==null){
			return;
		}
		list.add(head);
		process(head.left,list);
		process(head.right,list);
	}

法二：套路：管左子树要信息（左子树的节点个数，深度），管右子树要信息，判断自身

	public static class Info{
		public int depth;
		public int nodeNum;
		public Info(int depth,int nodeNum){
			this.depth=depth;
			this.nodeNum=nodeNum;
		}
	}
	public static boolean isFull(Node head){
		Info info=process(head);
		if(Math.pow(2,info.depth)-1==info.nodeNum){
			return true;
		}
		return false;
	}
	public static Info process(Node head){
		if(head==null){
			return new Info(0,0);
		}
		Info infoLeft=process(head.left);
		Info infoRight=process(head.right);
		int depth=Math.max(infoLeft.depth,infoRight.depth)+1;
		int num=infoLeft.nodeNum+infoRight.nodeNum+1;
		return new Info(depth,num);
	}

7.判断是否是平衡二叉树

	public static boolean isBalanced(Node head) {
		return process(head).isBalanced;
	}
	public static class Info{
		boolean isBalanced;
		int height;

		public Info(boolean isBalanced, int height) {
			this.isBalanced = isBalanced;
			this.height = height;
		}
	}


	public static Info process(Node x) {
		if(x==null){
			return new Info(true,0);
		}
		Info infoLeft = process(x.left);
		Info infoRight=process(x.right);
//		boolean isBalanced=false;
//		int height=0;
//		if(infoLeft.isBalanced&&infoRight.isBalanced){
//			if(Math.abs(infoLeft.height-infoRight.height)<=1){
//				isBalanced=true;
//				height=Math.max(infoLeft.height,infoRight.height)+1;
//			}
//		}
//两种写法都可，下面的更简洁
		int height=Math.max(infoLeft.height,infoRight.height)+1;
		boolean isBalanced=(infoLeft.isBalanced&&infoRight.isBalanced)&&(Math.abs(infoLeft.height-infoRight.height)<=1);
		return new Info(isBalanced,height);
	}

7.寻找公共祖先节点
法一：Map保存所有节点的父节点
node1往上的链存入set
node2再往上走，看节点是否在set中

	public static Node lowestAncestor(Node head, Node o1, Node o2) {
		HashMap<Node ,Node > hashMap=new HashMap<>();
		Node h=head;
		hashMap.put(head,head);
		Queue<Node> queue = new LinkedList<>();
		queue.add(head);
		//层序遍历存节点
		while(!queue.isEmpty()){
			Node poll=queue.poll();
			if(poll.left!=null){
				hashMap.put(poll.left,poll);
				queue.add(poll.left);
			}
			if(poll.right!=null){
				hashMap.put(poll.right,poll);
				queue.add(poll.right);
			}
		}
		HashSet<Node> hashSet=new HashSet<>();
		while(o1!=hashMap.get(o1)){
			hashSet.add(o1);
			o1=hashMap.get(o1);
		}
		while(o2!=hashMap.get(o2)){
			if(hashSet.contains(o2)){
				return o2;
			}
			o2=hashMap.get(o2);
		}
		return h;
	}

法二：（很模糊）

	public static Node lowestAncestor1(Node head, Node o1, Node o2){
		if(head==null||head==o1||head==o2){
			return head;
		}
		Node left=lowestAncestor1(head.left,o1,o2);
		Node right=lowestAncestor1(head.right,o1,o2);
		if(left!=null&&right!=null){
			return head;
		}
		return left!=null?left:right;
	}

8.二叉树中找一个节点的后继节点
法一：拿list存中序遍历顺序，直接找该节点的下一个节点（这种情况必须把头节点传进来）

    public static Node getSuccessorNode(Node head, Node x) {
        List<Node> list = new ArrayList<>();
        process(head, list);
        Node node = null;
        for (int i = 0; i < list.size(); i++) {
            if (list.get(i) == x) {
                if ((i + 1) < list.size()) {
                    node = list.get(i + 1);
                } else {
                    node = null;
                }
            }
        }
        return node;
    }

    public static void process(Node head, List<Node> list) {
        if (head == null) {
            return;
        }
        process(head.left, list);
        list.add(head);
        process(head.right, list);
    }

法二：（1）x有右树–右树上的最左节点
（2）x无右树–是父节点的左孩子吗？不是，往上，是返回父节点

    public static Node getSuccessorNode(Node node) {
        if (node == null) {
            return null;
        }
        if (node.right != null) {
            node = getLeft(node);
        } else {
            while (node.parent != null && node != node.parent.left) {//注意node.parent != null这个条件，第一次没写陷入了窘境
                node = node.parent;
            }
            node = node.parent;
        }
        return node;
    }
	//获取最左边的节点
    public static Node getLeft(Node node) {
        if (node == null) {
            return node;
        }
        node = node.right;
        while (node.left != null) {
            node = node.left;
        }
        return node;
    }

9.二叉树的序列化与反序列化
序列化：

    public static String serialByPre(Node head) {
        if (head == null) {
            return "#_";
        }
        String str = head.value + "_";
        String left = serialByPre(head.left);
        str = str+left;
        String right = serialByPre(head.right);
        str += right;
        return str;
    }

反序列化：（模糊）

    public static Node reconByPreString(String preStr) {
        String [] strs= preStr.split("_");
        Queue<String> queue=new LinkedList<>();
        for (int i = 0; i < strs.length; i++) {
            queue.add(strs[i]);
        }
        return null;
    }

    public static Node reconPreOrder(Queue<String> queue) {
        String str=queue.poll();
        if(str=="#"){
            return null;
        }
        Node head=new Node(Integer.valueOf(str));
        head.left=reconPreOrder(queue);
        head.right=reconPreOrder(queue);
        return head;
    }

10.折纸问题（模糊）

	public static void printAllFolds(int N) {
		printProcess(1, N, true);
	}

	public static void printProcess(int i, int N, boolean down) {
		if(i>N){
			return;
		}
		printProcess(i+1,N,true);
		System.out.println(down?"down":"up");
		printProcess(i+1,N,false);
	}

	public static void main(String[] args) {
		int N = 1;
		printAllFolds(N);
	}
飞翔的代码人
关注
专栏目录
数据结构——二叉树
Dcwjh的博客
03-08 207
遍历 实现二叉树的先序、中序、后序遍历 递归： //根左右 public static void preOrder(Node head){ if(head == null) return; System.out.println(head.data); preOrder(head.left); preOr...
第四课：二叉树
欢迎来到【技术拾光者】，在这里，我们专注分享编程教程、技术趋势、实战案例和优质资源。不定期举办技术问答、专家访谈和职业指导。加入我们，共同探索技术世界，提升技能，拓展职业道路！
08-07 177
左程云算法初级班 第四课 实现二叉树的先序、中序、后序遍历，包括递归方式和非递归方式 上图中，左图为二叉树，右图为遍历结点过程 先序遍历：第一次到达结点时输出该节点值；中序遍历：第二次到达结点时输出该节点值；后序遍历：第三次到达结点时输出该节点值； 递归方式：对于先序比遍历，先打印当前结点的值，再对该结点的左孩子进行先序遍历，最后对右该结点的孩子进行先序遍历；对于中序比遍历，先对该结点...
第七节课：9.3：二叉树
chj2535812707的博客
09-05 433
第七节课：9.3：二叉树 一、二叉树 1.概念： 是树的一种，其存储结构及其算法都较为简单，因此二叉树显得特别重要 每一层最多只有两个节点的树； 子树有左子树和右子树之分； 注意：二叉树可以只有右子树没有左子树 2.分类： 分为五类： 3.特性： 1.每一层的节点数不能超过2的（i-1）次方个 2.深度为k的树的节点数最大为2的k次方-1个 3.一个节点的度只能为0,1,2 4.二叉树的子树有左右之分 5.任意一课二叉树，度为2的节点数为n，则度为0的节点数为n+1； 二、满二叉树 1.概念： 当思考到用
左神课程笔记——第五节课：二叉树
qq_45552815的博客
08-20 355
b站左神算法课笔记
寒假集训营第二课：二叉树
2201_75796127的博客
01-03 167
二叉树
《左神算法初级班》第四节课：二叉树结构
肉丸不肉
03-31 298
目录： 1）二叉树结构 2）二叉树的递归与非递归遍历 3）打印二叉树 4）判断搜索二叉树 5）判断完全二叉树 6）判断平衡二叉树 7）折纸问题 8）二叉树节点的前驱节点与后继节点 9）二叉树的序列化和反序列化 题目一：实现二叉树的先序、中序、后序遍历，包括递归方式和非递归 方式 题目二：如何直观的打印一颗二叉树 题目三：在二叉树中找到一个节点的后继节点 题目四：介绍二叉树的序列化和反序列化 题目五：折纸问题 题目六：判断一棵二叉树是否是平衡二叉树 题目七：判断一棵树是否是搜索二叉树、判断一棵
头歌实训作业：二叉树——课上练（链式存储结构）
cjj2543107638的博客
10-14 1500
头歌实训作业：二叉树——课上练（链式存储结构）
计算机二叉树知识点,2017计算机考研专业课：二叉树重要知识点
weixin_42363231的博客
06-22 222
原标题：2017计算机考研专业课：二叉树重要知识点二叉树是数据结构中的重点内容，在这两年的考试中也将二叉树作为重点内容来考查。二叉树这部分内容要求大家掌握二叉树的定义、性质、存储结构、遍历、线索化、森林和二叉树的转换等内容。算法的重点是二叉树的遍历及其应用，这也是二叉树这部分的重点和难点。遍历是二叉树各种操作的基础，可以在遍历过程中对结点进行各种操作。例如：求二叉树结点总数，建立二叉树，建立二叉树...
计算机二叉树知识点,2016计算机考研专业课：二叉树重要知识点
weixin_35965648的博客
06-22 85
二叉树是数据结构中的重点内容，在这两年的考试中也将二叉树作为重点内容来考查。二叉树这部分内容要求大家掌握二叉树的定义、性质、存储结构、遍历、线索化、森林和二叉树的转换等内容。算法的重点是二叉树的遍历及其应用，这也是二叉树这部分的重点和难点。遍历是二叉树各种操作的基础，可以在遍历过程中对结点进行各种操作。例如：求二叉树结点总数，建立二叉树，建立二叉树的存储结构等。二叉树的很多算法是在遍历算法基础上改...
数据结构第十讲：二叉树OJ题
2301_79761834的博客
08-04 894
数据结构第十讲：二叉树OJ题
项目实战：SPSS Modeler数据挖掘项目实战培训-第20课：回归与决策树增补 共4页.pptx
11-25
在本课程"项目实战：SPSS Modeler数据挖掘项目实战培训-第20课：回归与决策树增补"中，我们重点探讨了两种在数据挖掘中常用的分析方法：回归分析和决策树。以下是这两部分的详细知识要点： **回归分析** 回归分析是...
word2vec班第2课：词向量到word2vec与相关应用
08-29
Hierarchical Softmax则构建了一个二叉树结构，每个词在树上的路径表示其向量，减少了每次预测时需要评估的词汇数量。 四、Word2Vec的特性 Word2Vec学习到的词向量具有丰富的语义信息，例如“king-man+woman=queen...
第五课 常见的二叉树：线索二叉树
weixin_42430208的博客
06-29 537
第五章 常见的二叉树：线索二叉树1 定义2 特点3 线索化二叉树3.1 前序线索化二叉树3.2 中序线索化二叉树3.3 后序线索化二叉树4 代码实现 1 定义 线索二叉树相比普通二叉树而言，就是利用了普通二叉树的空闲内存，记录了某些结点的前趋和后继元素信息，存在n个结点的二叉链表必定存在n + 1个空指针域，线索二叉树就是利用这n+1个空间来存储 2 特点 （1）利用了这些浪费的空指针域 （2）利用好前趋结点和后继结点的信息，可以更快的进行前，中，后序等遍历 （3）特殊的双向链表：假如A指向B，A存的B孩子
(王道408考研数据结构)第五章树-第三节1：二叉树遍历（先序、中序和后序）
快乐江湖的博客
11-17 3367
文章目录一：二叉树遍历概述二：二叉树深度优先遍历（1）先序遍历-根左右(NLR)（2）中序遍历-左根右(LNR)（3）后序遍历-左右根(LRN)总结：三种遍历方式动图演示三：二叉树的层序遍历 一：二叉树遍历概述 二叉树遍历（traversing binary tree）：从根节点开始，按照某种次序依次访问二叉树中的所有结点，使得每个结点被访问一次且仅被访问一次 访问： 访问是一个抽象操作，是指具体你遍历到这个节点应该做什么？比如说最简单的打印，修改值等等 次序：二叉树比遍历有别于普通线性结构，因为树的结点
基于Ssm和Mysql的高校普法系统代码（程序，中文注释）
09-29
高校普法系统-高校普法系统-高校普法系统-高校普法系统-高校普法系统-高校普法系统-高校普法系统-高校普法系统-高校普法系统-高校普法系统-高校普法系统-高校普法系统 1、资源说明：高校普法系统源码，本资源内项目代码都经过测试运行成功，功能ok的情况下才上传的。 2、适用人群：计算机相关专业(如计算计、信息安全、大数据、人工智能、通信、物联网、自动化、电子信息等)在校学生、专业老师或者企业员工等学习者，作为参考资料，进行参考学习使用。 3、资源用途：本资源具有较高的学习借鉴价值，可以作为“参考资料”，注意不是“定制需求”，代码只能作为学习参考，不能完全复制照搬。需要有一定的基础，能够看懂代码，能够自行调试代码，能够自行添加功能修改代码。 4. 最新计算机软件毕业设计选题大全(文章底部有博主联系方式): https://blog.csdn.net/2301_79206800/article/details/135931154 技术栈、环境、工具、软件： ① 系统环境:Windows ② 开发语言：Java ③ 框架：Ssm ④ 架构:B/S、MVC ⑤ 开发环境:IDEA、JDK、M
学生心理咨询评估系统 源码+数据库+论文（SpringBoot+Vue.JS+MySQL）
最新发布
09-29
学生心理咨询评估系统 源码+数据库+论文（SpringBoot+Vue.JS+MySQL） 启动教程：https://www.bilibili.com/video/BV11ktveuE2d
基于asp.net的实验室设备管理平台设计与实现.docx
09-29
基于asp.net的实验室设备管理平台设计与实现.docx
BCG：处方药零售业发展趋势2021年度洞察报告
09-29
BCG：处方药零售业发展趋势2021年度洞察报告.
电子资源管理系统代码系统 Ssm电子资源管理系统（程序，中文注释）
09-29
电子资源管理系统-电子资源管理系统-电子资源管理系统-电子资源管理系统-电子资源管理系统-电子资源管理系统-电子资源管理系统-电子资源管理系统-电子资源管理系统-电子资源管理系统-电子资源管理系统-电子资源管理系统 1、资源说明：电子资源管理系统源码，本资源内项目代码都经过测试运行成功，功能ok的情况下才上传的。 2、适用人群：计算机相关专业(如计算计、信息安全、大数据、人工智能、通信、物联网、自动化、电子信息等)在校学生、专业老师或者企业员工等学习者，作为参考资料，进行参考学习使用。 3、资源用途：本资源具有较高的学习借鉴价值，可以作为“参考资料”，注意不是“定制需求”，代码只能作为学习参考，不能完全复制照搬。需要有一定的基础，能够看懂代码，能够自行调试代码，能够自行添加功能修改代码。 4. 最新计算机软件毕业设计选题大全(文章底部有博主联系方式): https://blog.csdn.net/2301_79206800/article/details/135931154 技术栈、环境、工具、软件： ① 系统环境:Windows ② 开发语言：Java ③ 框架：Ssm ④ 架构
数据结构实验：二叉树的遍历与操作
实验于2017年4月28日第一节课在7-216教室进行，评估标准包括实验过程、程序运行、回答问题以及实验报告的完整性。实验成绩的评定还考虑了功能实现、代码错误和学生在实验中的参与度。 实验的主要任务是通过二叉链表...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值