刷刷笔试题~~[二叉树编程]

最新推荐文章于 2022-06-23 20:46:14 发布
最新推荐文章于 2022-06-23 20:46:14 发布
阅读量1.8k 收藏 1
点赞数
分类专栏： 笔试题 文章标签： 二叉树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/nanaMasuda/article/details/52436572
版权

1.给定一颗二叉树，以及其中的两个node（地址均非空），要求给出这两个node的一个公共父节点，使得这个父节点与两个节点的路径之和最小。描述你程序的最坏时间复杂度，并实现具体函数

C++函数原型：

1
2
3
4
5
6
7
strucy TreeNode{
      TreeNode* left;    //指向左子树
      TreeNode* right;    //指向右子树
      TreeNode* father;    //指向父亲节点
};
TreeNode* LowestCommonAncestor(TreeNode* first,TreeNode* second){
}
解析：

这里给出了父节点指针，难度一下就降下来了

方法一：首先找到两个节点的高度差，然后从较靠近根节点的一层开始向上找，若父节点为同一节点则该节点为解

最坏时间复杂度为O(n)

public class SameFather {
	class Node{
		public Node father;
		public Node left;
		public Node right;
		
	}
	public int getHeight(Node node){
		int h=0;
		while(node!=null){
			h++;
			node=node.father;
		}
		return h;
	}
	public Node LowestCommonAncestor(Node first,Node second){
		int h1=getHeight(first);
		int h2=getHeight(second);
		int diff=h1-h2;
		if(diff<0){//first在上面
			diff=-diff;
			while(diff--!=0){//先判断不为0，之后再减1
				second=second.father;//second往上赶
			}
		}else{
			while(diff--!=0){
				first=first.father;
			}
		}
		while(first!=second){
			first=first.father;
			second=second.father;
		}
		return first;
	}
}


2..二叉树的下一个结点

给定一个二叉树和其中的一个结点，请找出中序遍历顺序的下一个结点并且返回。注意，树中的结点不仅包含左右子结点，同时包含指向父结点的指针。

解析：

画一个二叉树，求出该二叉树的中序遍历

(1)如果树为空，return null

(2)如果树有右子树，找到右子树最左节点

(3)如果没有右节点，它的下一个节点应该是，以自己为左孩子的父节点，如果自己不是自己父节点的左孩子，就继续向上找


<span style="font-family:Microsoft YaHei;font-size:14px;">/*
public class TreeLinkNode {
    int val;
    TreeLinkNode left = null;
    TreeLinkNode right = null;
    TreeLinkNode next = null;

    TreeLinkNode(int val) {
        this.val = val;
    }
}
*/
public class Solution {
    public TreeLinkNode GetNext(TreeLinkNode pNode)
    {
        if(pNode==null)
            return null;
        if(pNode.right!=null){//如果右子树不为空
            pNode=pNode.right;
            if(pNode.left!=null)
                pNode=pNode.left;
            return pNode;
        }
        while(pNode.next!=null){//因为要一直往上找
            if(pNode.next.left==pNode)
                return pNode.next;
            pNode=pNode.next;
        }
        return null;
    }
}</span>

3.对称的二叉树

请实现一个函数，用来判断一颗二叉树是不是对称的。注意，如果一个二叉树同此二叉树的镜像是同样的，定义其为对称的。

解析：

一看到这种题，就有感觉要用递归来做

判断两个子树是否对称

左子树的左子树应该等于右子树的右子树

左子树的右子树应该等于右子树的左子树


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

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

    }

}
*/
public class Solution {
    boolean isSymmetrical(TreeNode pRoot)
    {
        if(pRoot==null)//记得判断为空的情况，这个在递归里面判断不了
            return true;
        return same(pRoot.left,pRoot.right);
    }
    boolean same(TreeNode leftNode,TreeNode rightNode){
        if(leftNode==null&&rightNode!=null)return false;
        if(leftNode!=null&&rightNode==null)return false;
        if(leftNode==null&&rightNode==null)return true;
        if(leftNode.val==rightNode.val)
            return same(leftNode.left,rightNode.right)&&same(leftNode.right,rightNode.left);
        return false;
    }
}


4.按之字形顺序打印二叉树

请实现一个函数按照之字形打印二叉树，即第一行按照从左到右的顺序打印，第二层按照从右至左的顺序打印，第三行按照从左到右的顺序打印，其他行以此类推。

解析：

层次遍历+每一层单行输出，这个是之前做过的题，改编一下

定义两个变量，curNum和nextNum来分别保存当前层的节点数和下一层的节点数

初始化时curNum=1，nextNum=0

层次遍历用队列，先把根节点压入，开始循环

弹出队列头节点，输出，curNum--，判断弹出的节点有没有左右孩子，有的话压入队列，每压入一个，nextNum++

判断if(curNum==0),等于0的话说明，这一行已经遍历完了，curNum=nextNum,nextNum=0;

这里每输出一层，按顺序存放在arrayList中，可以用一个标志位flag，true的时候从左到右，false的时候从右到左，每当curNum==0时转换,

转换之前判断是true还是false，true的话正常把这一次的arraylist加到总的结果中，否则，反转这个arraylist后再添加进去



import java.util.*;

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

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

    }

}
*/
public class Solution {
    public ArrayList<ArrayList<Integer> > Print(TreeNode pRoot) {
        ArrayList<ArrayList<Integer> > res=new ArrayList<ArrayList<Integer> >();
        if(pRoot==null)//不要忘记判断
            return res;
        int curNum=1;
        int nextNum=0;
        boolean flag=true;
        ArrayList<Integer> list=new ArrayList<Integer>();
        Queue<TreeNode> queue=new LinkedList<TreeNode>();//记得这里是链表，才能生成的队列
        queue.add(pRoot);
        while(!queue.isEmpty()){
            TreeNode node=queue.poll();
            list.add(node.val);
            curNum--;
            if(node.left!=null){
                queue.add(node.left);
                nextNum++;
            }
            if(node.right!=null){
                queue.add(node.right);
                nextNum++;
            }
            if(curNum==0){
                if(flag)
                    res.add(list);
                else{
                    res.add(reverse(list));
                }
                
                flag=!flag;
                curNum=nextNum;
                nextNum=0;
                list=new ArrayList<Integer>();//只有打印完一行才再重新声明
            }
            
        }
        return res;
    }
    public ArrayList<Integer> reverse(ArrayList<Integer> list){
        int len=list.size();
        ArrayList<Integer> list2=new ArrayList<Integer>();
        for(int i=len-1;i>=0;i--){
            list2.add(list.get(i));
        }
        return list2;
    }

}


5.把二叉树打印成多行

从上到下按层打印二叉树，同一层结点从左至右输出。每一层输出一行。

解析：这个就是层次遍历按层输出的那个


import java.util.ArrayList;
import java.util.*;

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

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

    }

}
*/
public class Solution {
    ArrayList<ArrayList<Integer> > Print(TreeNode pRoot) {
        ArrayList<ArrayList<Integer> > res=new ArrayList<ArrayList<Integer> >();
        if(pRoot==null)
            return res;
        ArrayList<Integer> list=new ArrayList<Integer>();
        Queue<TreeNode> queue=new LinkedList<TreeNode>();
        int curNum=1;
        int nextNum=0;
        queue.add(pRoot);
        while(!queue.isEmpty()){
            TreeNode node=queue.poll();
            list.add(node.val);
            curNum--;
            if(node.left!=null){
                queue.add(node.left);
                nextNum++;
            }
            if(node.right!=null){
                queue.add(node.right);
                nextNum++;
            }
            if(curNum==0){
                res.add(list);
                curNum=nextNum;
                nextNum=0;
                list=new ArrayList<Integer>();
            }
        }
        return res;
    }
    
}


6.序列化二叉树

请实现两个函数，分别用来序列化和反序列化二叉树

解析：

第一种方法：

序列化二叉树，就是把二叉树变成一串字符串，先序遍历，最开始str="",不停往上面加，最后返回str

每遍历一个节点后面加上！，遇到空节点输出#！

遇到空节点返回#!，先加上根节点！，再对根节点的左孩子调用这个方法，然后对根节点的右孩子调用这个方法，最后返回str，递归

反序列化：对用先序遍历序列化的字符串进行反序列化

用到队列，先把字符串用split("!")变成字符串数组，遍历把每个元素添加到队列中，空的时候返回null，这个在后面的递归中要用到

弹出的第一个节点是根节点，然后根节点的左孩子是队列中剩下的元素调用这个函数得到的节点，遍历到#后，说明当前结点的左孩子后面没有东西了，返回当前结点，看他的右孩子，再遍历到#后，再回到当前结点，找到当前结点的父节点，也使用递归实现

！！注意，因为是递归，所以每轮只算自己的！！不用哪一步都str+=

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

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

    }

}
*/
import java.util.*;
public class Solution {
    //序列化
    String Serialize(TreeNode root) {
        if(root==null){
            return "#!";//这里return#!就行，不用加上str
        }
        String str=root.val+"!";//每次只算自己的！！
        str+=Serialize(root.left);
        str+=Serialize(root.right);
        return str;
  }
    //反序列化！
    TreeNode Deserialize(String str) {
       Queue<String> queue=new LinkedList<String>();//这里存放的是String类型
       String[] s=str.split("!");
        for(int i=0;i<s.length;i++){
            queue.add(s[i]);
        }
        return reconPre(queue);
  }
    public TreeNode reconPre(Queue<String> queue){
        String value=queue.poll();
        if(value.equals("#"))
            return null;
        TreeNode head=new TreeNode(Integer.valueOf(value));
        head.left=reconPre(queue);
        head.right=reconPre(queue);
        return head;
    }
}


第二种方法：

层次遍历来序列化：序列化的时候要用到队列，序列化的字符串是str，初始时为空

最开始判断是否为空，为空的话return #！

先将节点压入队列，队列是TreeNode类型的，然后层次遍历

先压入头节点，当队列不为空的时候，循环，弹出队首的元素，将val！加入到str中，

看看这个节点有没有左孩子右孩子，有的话分别压入队列，没有的话str+"#!" , 循环，


反序列化：先把字符串split("!")拆成String数组

其实反序列化就相当于再来一遍层次遍历，之前用先序遍历时就相当于再来一遍先序遍历。遇到#，表示是null，其他的就是正常节点

声明一个队列，TreeNode类型的，把String数组中第一个数放进去，然后index++，队列不为空的时候循环

取出队首元素，通过一个函数把它变成节点，然后按理来说后面两个是它的左右孩子，判断一下是不是空节点，是的话不要管了，

是正常节点的话以左孩子或者右孩子的身份添加到队列中

思路一定要清晰！！

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

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

    }

}
*/
import java.util.*;
public class Solution {
    String Serialize(TreeNode root) {
        Queue<TreeNode> queue=new LinkedList<TreeNode>();
        if(root==null)
            return "#!";
        String str=root.val+"!";
        queue.add(root);
        while(!queue.isEmpty()){
            root=queue.poll();
            if(root.left!=null){
                str+=root.left.val+"!";
                queue.add(root.left);
            }else{
                str+="#!";
            }
            if(root.right!=null){
                str+=root.right.val+"!";
                queue.add(root.right);
            }else{
                str+="#!";
            }
        }
        return str;
  }
    TreeNode Deserialize(String str) {
        String[] s=str.split("!");
        Queue<TreeNode> queue=new LinkedList<TreeNode>();
        int index=0;//指针在数组中移动
        TreeNode head=createNode(s[index++]);
        if(head!=null){
            queue.add(head);
        }
        TreeNode node=null;//这个node要放在外面，因为里面一直用一个
        while(!queue.isEmpty()){
            node=queue.poll();
            node.left=createNode(s[index++]);
            node.right=createNode(s[index++]);
            if(node.left!=null){
                queue.add(node.left);
            }
            if(node.right!=null){
                queue.add(node.right);
            }
            
        }
        return head;
  }
    public TreeNode createNode(String a){
        if(a.equals("#"))
            return null;
        return new TreeNode(Integer.valueOf(a));
    }
}


7.二叉搜索树的第k个结点

给定一颗二叉搜索树，请找出其中的第k小的结点。例如， 5 / \ 3 7 /\ /\ 2 4 6 8 中，按结点数值大小顺序第三个结点的值为4。

解析：

中序遍历，存到数组里，取出第k-1个


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

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

    }

}
*/
import java.util.*;
public class Solution {
    ArrayList<TreeNode> list=new ArrayList<TreeNode>();
    public void inorder(TreeNode node){
        if(node==null)
            return ;
        inorder(node.left);
        list.add(node);
        inorder(node.right);
        
    }
    TreeNode KthNode(TreeNode pRoot, int k)
    {
        inorder(pRoot);
        if(k>list.size()||k<=0)
        	return null;
        return list.get(k-1);
    }
    


}


8.

二叉树的深度

输入一棵二叉树，求该树的深度。从根结点到叶结点依次经过的结点（含根、叶结点）形成树的一条路径，最长路径的长度为树的深度

解析：

递归求解：
假如是空节点，则返回0；
否则，原树的深度由左右子树中深度较的深度加1，为原树的深度。

/*
public class TreeNode {
	int val = 0;
	TreeNode left = null;
	TreeNode right = null;
	public TreeNode(int val) {
        this.val = val;
    }
};*/
public class Solution {
	public int TreeDepth(TreeNode pRoot)
    {
        if(pRoot==null)
            return 0;
        return Math.max(1+TreeDepth(pRoot.left),1+TreeDepth(pRoot.right));
    }
}


9.平衡二叉树

输入一棵二叉树，判断该二叉树是否是平衡二叉树。 

/*
 * 输入一棵二叉树，判断该二叉树是否是平衡二叉树
 */
public class BalanceTree {
	class TreeNode{
		TreeNode left;
		TreeNode right;
	}
	//声明了一个全局变量来判断是否是平衡树
	private boolean isBalanced=true;
    public boolean IsBalanced_Solution(TreeNode root) {
        getDepth(root);
        return isBalanced;
    }
    //这个函数其实是在求树的高度
    public int getDepth(TreeNode root){
    	if(root==null)//递归到底部的时候
    		return 0;
    	int left=getDepth(root.left);//递归来求树的高度，递归就相当于自底向上了
    	int right=getDepth(root.right);
    	//每次求完子树的高度，就判断一下
    	if(Math.abs(left-right)>1)
    		isBalanced=false;//不是记为false，但无论如何都要遍历一遍，最后把isBalanced输出来
    	return right>left?right+1:left+1;
    }
}


/*
 * 输入一棵二叉树，判断该二叉树是否是平衡二叉树
 */

public class BalanceTree2 {
	class TreeNode{
		TreeNode left;
		TreeNode right;
	}
	//这里用了一个class来传值，声明对象后就可以根据对象来保存这个值n
	//这里n其实相当于树的深度
	private class Holder{
		int n;
	}
	public boolean IsBalanced_Solution(TreeNode root){
		return judge(root,new Holder());
	}
	public boolean judge(TreeNode root,Holder h){
		if(root==null)
			return true;
		Holder l=new Holder();
		Holder r=new Holder();
		//这边的两个judge是在递归，先跑到树的最下面
		//如果最下面的两个子数都是平衡树，那就判断一下他俩的高度差
		if(judge(root.left,l)&&judge(root.right,r)){
			if(Math.abs(l.n-r.n)>1)
				return false;
			h.n+=(l.n>r.n?l.n:r.n)+1;
			return true;
		}
		return false;
	}
}







nanaMasuda
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构——二叉树编程实现
qq_45362263的博客
04-27 1022
//二叉链树的存储定义 typedef struct node{ ElemType data; //数据元素 struct node *lchild; //定义左孩子结点 struct node *rchild; //定义右孩子结点 }BTNode; //基本运算及实现 1.创建二叉树 #include "btree.h" //包含二叉树的结构声明 void createBTree(BTNode *&b,char *str){ BTNode *st[maxsize],*p; int to
树相关知识及编程练习总结
热门推荐
张彦峰的博客
10-27 1万+
树相关知识及编程练习总结：背景知识+树的应用举例（Spring中的应用举例+其他框架中的应用举例+实际开发中的应用举例）+相关编程练习（二叉树遍历：包括前序遍历、中序遍历、后序遍历、层序遍历等+二叉树的最大深度+二叉树的最小深度+对称二叉树+二叉树的最近公共祖先+二叉树的直径+二叉树的路径和+二叉搜索树中的插入操作+二叉搜索树中的删除操作+二叉搜索树中的搜索操作+二叉树的层平均值+二叉树的镜像+二叉树的序列化与反序列化+二叉树的右视图+二叉树的最大宽度+前序遍历和中序遍历构造二叉树+平衡二叉树）
二叉树原理及编程详解(一)完全二叉树|堆排序|遍历|重建
祥瑞的技术博客
07-27 1503
目录 一、二叉树基础概念 1.1 基础概念： 1.2 二叉树的性质 二、二叉树的遍历 2.1 三种遍历方法 2.2 二叉树的构建 2.3 重建方法及解析 2.4 重建二叉树的代码实现 c++重建二叉树 python重建二叉树 三、二叉树编程汇总 3.1 树的子结构 c++树的子结构 3.2 镜像二叉树 c++镜像二叉树 3.3 按层打印二叉树 c++按层打印二叉树...
二叉树编程
Mr.魏
12-11 271
二叉树编程 #define _CRT_SECURE_NO_WARNINGS #include<stdio.h> #include<string.h> #include<stdlib.h> struct BiNode { char ch; struct BiNode *lchild; struct BiNode *rchild; }; //int n...
二叉树的高
1900的博客
12-21 875
Description 给定一颗二叉树的先序序列，求该二叉树的高。 Input 输入包括两部分第一部分：一个正整数n，代表有n颗二叉树第二部分：包括n行，每行代表一颗二叉树的先序遍历序列，空指针用字符^占位 Output n行，每行一个整数，代表对应二叉树的高度 Sample Input 2 ABC^^^^ AB^^^ Sample Output 3 2 求二叉树的高是二叉树...
c语言编程题之树操作二叉树的最大深度.zip
最新发布
04-02
在C语言编程中，二叉树是一种非常重要的数据结构，它具有两个子节点，分别称为左子节点和右子节点。二叉树可以用来解决多种问题，如搜索、排序、文件系统等。本主题聚焦于如何计算二叉树的最大深度，这是一个经典的...
C语言软件工程师笔试题大全.docx
10-25
C语言软件工程师笔试题大全 本文档总结了C语言软件工程师笔试题大全，涵盖了网络安全、C语言基础知识、数据结构、算法、实时系统等多方面内容。以下是详细的知识点总结： 一、网络安全 * 网络安全的五个方面特征...
校招C&C++笔试题大全
01-08
【标题】：“校招C&C++笔试题大全” 在求职过程中，尤其是对于计算机科学和技术相关专业的学生来说，参加公司的校园招聘笔试是至关重要的一步。"校招C&C++笔试题大全"是一个集各大公司历年校招笔试题目的资源库，...
虹软算法岗笔试题
08-03
【虹软算法岗笔试题】涉及的是一场2017年的算法专业笔试，这类考试通常涵盖计算机科学与技术、软件工程等相关领域的核心知识。在准备这类笔试时，需要对算法设计、数据结构、编程语言、计算理论等有扎实的理解。下面...
图形化编程 scratch 递归 二叉树（带叶子）.sb3
09-19
通过自制积木实现递归画出一颗树，每次画的效果都不一样。
编程题分类——树
保持一颗敬畏之心，简单地调用C++，适当地向C++妥协，让以后的自己看懂代码，让别人看懂代码。
10-23 382
目录前言正文按之字形顺序打印二叉树参考 前言 正文 按之字形顺序打印二叉树 code /* struct TreeNode { int val; struct TreeNode *left; struct TreeNode *right; TreeNode(int x) : val(x), left(NULL), right(NULL) { } }; */ class Solution { public: vector<vecto
求二叉树两节点的最小父节点（有父节点指针）
快乐的鱼儿学敲码
09-13 2201
给定一颗二叉树，以及其中的两个node（地址均非空），要求给出这两个node的一个公共父节点，使得这个父节点与两个节点的路径之和最小。描述你程序的最坏时间复杂度，并实现具体函数，函数输入输出请参考如下的函数原型： C++函数原型： 1 2 3 4 5 6 7 strucy TreeNode{
二叉树的基本操作及编程题总结（C++）
Meliorem的博客
12-05 2390
**二叉树编程题万变不离其宗在于对递归的理解和使用要弄懂用好递归 重要的在于一下几条：1.搞清楚函数递归调用栈帧的变化 特别是二叉递归时的栈帧变化2.搞清楚各个函数参数 传值和传引用 的函数参数在递归调用时值的变化。 本文中不加注明 所说的二叉树都是普通二叉树1.定义并构建一颗二叉树对于一颗普通二叉树的节点 至少要定义出他的值域 和指向其左右子树的左右指针域。 并定义出节点的构造函数 该函
树（二叉树）系列算法编程考题
qq_20110551的博客
08-01 3637
树（二叉树）系列算法编程考题 部分内容是从网上其他博客中整理而来，方便大家对相关内容有一个总结。 主要进行以下几个方面的总结 1）计算一棵树的深度（高度）非递归实现 2）计算一棵树的宽度（并输出每一层的宽度） 3）判断一棵树是否是平衡二叉树（至少两种方法） 4）输出一棵树的所有路径（从根节点到叶子结点） 5）判断两棵树是否相同 6）判断一棵树是否是另一棵树的子树 7）判断一棵树是否是对称二...
网易实习生笔试编程题 二叉树
E01014165的专栏
07-26 1230
有一棵二叉树，树上每个点标有权值，权值各不相同，请设计一个算法算出权值最大的叶节点到权值最小的叶节点的距离。二叉树每条边的距离为1，一个节点经过多少条边到达另一个节点为这两个节点之间的距离。 给定二叉树的根节点root，请返回所求距离。 import java.util.*; /* public class TreeNode { int val = 0;
二叉树笔试题
luxiaoxun的专栏
05-05 7259
题目：输入两棵二叉树A和B，判断树B是不是A的子结构 递归判断：如果当前结点值相等，就判断左子树和右子树是否是子结构 bool IsChildTree(Node * father, Node * son) { if(father == NULL && son == NULL) return true; if(father == NULL && son
【王道数据结构编程题】- 二叉树编程练习
m0_56051805的博客
06-23 791
王道代码题具体实现，可以运行。树章节算法练习已经完结。
多叉树的实现
成长的足迹
04-29 1万+
多叉树的结点： template struct multreenode{ T data; //数据 multreenode *parent; //父节点 multreenode *left; //左兄弟 multreenode *right; //又兄弟 multreenode *firstChild,*lastChild; //第一个子节点，最后一个子节点 };
数据结构编程题二叉树
08-19
- *1* [王道数据结构编程题（二叉树）](https://blog.csdn.net/qq_43686863/article/details/123334790)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值