面试题目——《CC150》树与图
面试题4.1：实现一个函数，检查二叉树是否平衡。在这个问题中，平衡树的定义如下：任意一个结点，其两颗子树的高度差不超过1。
思路：两个方法，第一种速度较快
package cc150;
public class Balance {
public static void main(String[] args) {
// TODO 自动生成的方法存根
}
public class TreeNode {
int val = 0;
TreeNode left = null;
TreeNode right = null;
public TreeNode(int val) {
this.val = val;
}
}
public static boolean isBalance(TreeNode root){
if(checkHeight(root) == -1)
return false;
else
return true;
}
public static int checkHeight(TreeNode root){
if(root == null)
return 0;
//检查左子树是否平衡
int leftHeight = checkHeight(root.left);
if(leftHeight == -1)
return -1;
//检查右子树是否平衡
int rightHeight = checkHeight(root.right);
if(rightHeight == -1)
return -1;
//检查当前结点是否平衡
int heightDiff = leftHeight - rightHeight;
if(Math.abs(heightDiff) > 1)
return -1;
else
return Math.max(leftHeight, rightHeight) + 1;//返回当前结点的高度
}
// public boolean isBalance(TreeNode root) {
// // write code here
// int countLeft = 0;
// TreeNode temp=root;
// if(root == null){
// return true;
// }
// if(root.left==null && root.right==null){
// return true;
// }
// if(Math.abs(treeDepth(root.left)-treeDepth(root.right)) > 1){
// return false;
// }
// return isBalance(root.left) && isBalance(root.right);
//
// }
//
// public int treeDepth(TreeNode root){
// if(root == null) //如果pRoot为NULL，则深度为0，这也是递归的返回条件
// return 0;
// //如果pRoot不为NULL，那么深度至少为1，所以left和right=1
// int left=1;
// int right=1;
// left += treeDepth(root.left); //求出左子树的深度
// right += treeDepth(root.right); //求出右子树深度
//
// return (left>right?left:right); //返回深度较大的那一个
// }
}
面试题4.2： 给定有向图，设计一个算法，找出两个结点之间是否存在一条路径。
思路：解法中使用了递归以及深度遍历，并没有通过栈来优化空间的占用（参考牛客网更好的解法），注意图中可能存在环和反向的问题
package cc150;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
public class Path {
public static void main(String[] args) {
// TODO 自动生成的方法存根
UndirectedGraphNode a = new UndirectedGraphNode(1);
UndirectedGraphNode a1 = new UndirectedGraphNode(2);
UndirectedGraphNode a2 = new UndirectedGraphNode(3);
UndirectedGraphNode a3 = new UndirectedGraphNode(4);
UndirectedGraphNode a11 = new UndirectedGraphNode(5);
UndirectedGraphNode a12 = new UndirectedGraphNode(6);
UndirectedGraphNode a13 = new UndirectedGraphNode(7);
UndirectedGraphNode b = new UndirectedGraphNode(8);
a1.neighbors.add(a);
a.neighbors.add(a2);
a.neighbors.add(a3);
a.neighbors.add(a1);
a11.neighbors.add(a1);
a1.neighbors.add(a12);
a1.neighbors.add(a13);
b.neighbors.add(a11);
System.out.println(checkPath(a,b));
}
public static boolean checkPath(UndirectedGraphNode a, UndirectedGraphNode b) {
map.clear();
boolean bool1 = checkPathCore(a,b);
map.clear();
boolean bool2 = checkPathCore(b,a);
return bool1 || bool2;
}
public static Map<UndirectedGraphNode,Boolean> map = new HashMap<UndirectedGraphNode,Boolean>();
public static boolean checkPathCore(UndirectedGraphNode a, UndirectedGraphNode b) {
// write code here
if(a == null || b == null)
return false;
if(a == b)
return true;
map.put(a, true);
int num = a.neighbors.size();
for(int i=0;i<num;i++){
if(map.containsKey(a.neighbors.get(i)) == false && checkPathCore(a.neighbors.get(i),b))//深度遍历
return true;
}
return false;
}
public static class UndirectedGraphNode {
int label = 0;
UndirectedGraphNode left = null;
UndirectedGraphNode right = null;
ArrayList<UndirectedGraphNode> neighbors = new ArrayList<UndirectedGraphNode>();
public UndirectedGraphNode(int label) {
this.label = label;
}
}
}
package graph;
public class Graph { //建立图和添加顶点
private Node vertices[];
public int count;
public Graph() {
vertices = new Node[6];
count = 0;
}
public void addNode(Node x) {
if (count < 30) {
vertices[count] = x;
count++;
} else {
System.out.print("Graph full");
}
}
public Node[] getNodes() {
return vertices;
}
}
package graph;
class Node {
private Node adjacent[]; //邻接的所有顶点，存放在一个数组中
public int adjacentCount;
private String vertex; //当前顶点的值
public Question.State state;
public Node(String vertex, int adjacentLength) { //adjacentLength是和该顶点邻接的顶点的数量
this.vertex = vertex;
adjacentCount = 0; //每实例化一个顶点，邻接顶点的数量开始是0
adjacent = new Node[adjacentLength];
}
public void addAdjacent(Node x) { //添加邻接的顶点
if (adjacentCount < 30) { //邻接的顶点的数量不要操作30
this.adjacent[adjacentCount] = x;
adjacentCount++; //邻接的顶点的数量加1
} else {
System.out.print("No more adjacent can be added");
}
}
public Node[] getAdjacent() { //返回所有的邻接顶点的数组
return adjacent;
}
public String getVertex() { //取得当前顶点的值
return vertex;
}
}
package graph;
import java.util.LinkedList;
public class Question {
public enum State {
Unvisited, Visited, Visiting;
}
public static void main(String a[]){ //cc150面试题4.2，给定有向图，找出两个结点之间是否存在一条路径
Graph g = createNewGraph();
Node[] n = g.getNodes();
Node start = n[3];
Node end = n[5];
System.out.println(search(g, start, end));
}
public static Graph createNewGraph()
{
Graph g = new Graph();
Node[] temp = new Node[6];
temp[0] = new Node("a", 3);
temp[1] = new Node("b", 0);
temp[2] = new Node("c", 0);
temp[3] = new Node("d", 1);
temp[4] = new Node("e", 1);
temp[5] = new Node("f", 0);
temp[0].addAdjacent(temp[1]);
temp[0].addAdjacent(temp[2]);
temp[0].addAdjacent(temp[3]);
temp[3].addAdjacent(temp[4]);
temp[4].addAdjacent(temp[5]);
for (int i = 0; i < 6; i++) {
g.addNode(temp[i]);
}
return g;
}
public static boolean search(Graph g,Node start,Node end) {
LinkedList<Node> q = new LinkedList<Node>();
for (Node u : g.getNodes()) {
u.state = State.Unvisited;
}
start.state = State.Visiting;
q.add(start);
Node u;
while(!q.isEmpty()) {
u = q.removeFirst();
if (u != null) {
for (Node v : u.getAdjacent()) {
if (v.state == State.Unvisited) {
if (v == end) {
return true;
} else {
v.state = State.Visiting;
q.add(v);
}
}
}
u.state = State.Visited;
}
}
return false;
}
}
面试题4.3：给定一个有序整数数组，元素各不相同且按升序排列，编写一个算法，创建一颗高度最小的二叉查找书。
思路：要创建一颗高度最小的树，必须让左右子树的结点数量越接近。即要用数组中间的值作为根节点，然后递归。
注意：题目要求的是这颗二叉树的高度 还是 创建这颗二叉树
package cc150;
public class MinimalBST {
public static void main(String[] args) {
// TODO 自动生成的方法存根
int[] Arr = {0,1,2,3,4,5,6,7,8,9,10};
System.out.println(buildMinimalBST(Arr));
}
public static int buildMinimalBST(int[] vals) {
// write code here
if(vals == null || vals.length <= 0)
return 0;
return creatMinimalBST(vals,0,vals.length-1);
}
// public static TreeNode creatMinimalBST(int[] vals,int start,int end) {
// if(end < start)
// return null;
// int mid = (start+end)/2;
//
// TreeNode n = new TreeNode(vals[mid]);
// count++;
// n.left = creatMinimalBST(vals,start,mid-1);
// n.right = creatMinimalBST(vals,mid+1,end);
// return n;
// }
public static int creatMinimalBST(int[] vals,int start,int end) {
if(end <= start)
return 1;
int mid = (start+end) >> 1;
int left = 1 + creatMinimalBST(vals,start,mid-1);
int right = 1 + creatMinimalBST(vals,mid+1,end);
return Math.max(left, right);
}
public static class TreeNode {
int val = 0;
TreeNode left = null;
TreeNode right = null;
public TreeNode(int val) {
this.val = val;
}
}
}
面试题4.4：给定一颗二叉树，设计一个算法，创建含有某一深度上所有结点的链表（比如，若一棵树的深度为D，则会创建出D个链表）。
牛客网上求的是输出单层结点
思路：方法1 层次遍历
方法2 递归遍历
使用递归遍历，去掉程序中的static用例就可以跑过，不然有用例不通过
package cc150;
public class TreeLevel {
public static void main(String[] args) {
// TODO 自动生成的方法存根
TreeNode a1 = new TreeNode(1);
TreeNode a2 = new TreeNode(2);
TreeNode a3 = new TreeNode(3);
TreeNode a4 = new TreeNode(4);
TreeNode a5 = new TreeNode(5);
TreeNode a6 = new TreeNode(6);
TreeNode a7 = new TreeNode(7);
a1.left = a2;
a1.right = a3;
a2.left = a4;
a2.right = a5;
a3.left = a6;
a3.right = a7;
TreeLevel tl = new TreeLevel();
ListNode Arr = tl.getTreeLevel(a1,2);
while(Arr != null){
System.out.println(Arr.val);
Arr = Arr.next;
}
}
public ListNode start = new ListNode(-1); //链表头
public ListNode start_temp = start; //链表头的拷贝
public ListNode getTreeLevel(TreeNode root, int dep) {
// write code here
if (root == null || dep <= 0) //当root为null或者dep小于等于0的时候结束
return null;
if (dep == 1) { //只有当dep等于1的时候加入链表
start_temp.next = new ListNode(root.val);
start_temp = start_temp.next;
} else {
getTreeLevel(root.left, dep - 1);
getTreeLevel(root.right, dep - 1);
}
return start.next;
}
public static class ListNode {
int val;
ListNode next = null;
ListNode(int val) {
this.val = val;
}
}
public static class TreeNode {
int val = 0;
TreeNode left = null;
TreeNode right = null;
public TreeNode(int val) {
this.val = val;
}
}
}
面试题4.5：实现一个函数，检查一颗二叉树是否为二叉查找树。
思路：方法1 中序遍历法 中序遍历的顺序是：左 中 右，把中序遍历的结果存放在一个数组之中，之后判断数组是否是升序的即可。
方法2 最小/最大法 使用递归，深度遍历并判断每一个左结点的范围是否在MIN_VALUE和父节点之间，右结点范围是否在父节点和MAX_VALUE之间
package cc150;
public class CheckBST {
public static void main(String[] args) {
// TODO 自动生成的方法存根
TreeNode a1 = new TreeNode(4);
TreeNode a2 = new TreeNode(2);
TreeNode a3 = new TreeNode(6);
TreeNode a4 = new TreeNode(1);
TreeNode a5 = new TreeNode(3);
TreeNode a6 = new TreeNode(5);
TreeNode a7 = new TreeNode(7);
a1.left = a2;
a1.right = a3;
a2.left = a4;
a2.right = a5;
a3.left = a6;
a3.right = a7;
CheckBST ch = new CheckBST();
System.out.println(ch.checkBST(a1));
}
public boolean checkBST(TreeNode root) {
// write code here
return checkBST(root,Integer.MIN_VALUE,Integer.MAX_VALUE);
}
public boolean checkBST(TreeNode root,int min,int max) {//不断的缩小范围
// write code here
if(root == null)
return true;
if(root.val < min || root.val >= max)
return false;
//每一个左结点的范围在MIN_VALUE和父节点之间，右结点范围在父节点和MAX_VALUE之间
if(!checkBST(root.left,min,root.val) || !checkBST(root.right,root.val,max))
return false;
return true;
}
public static class TreeNode {
int val = 0;
TreeNode left = null;
TreeNode right = null;
public TreeNode(int val) {
this.val = val;
}
}
}
面试题4.6：设计一个算法，找出二叉查找树中指定结点的“下一个”结点（也即中序后继）。可以假定每个结点都含有指向父节点的连接。
思路：情况1：结点2的情况，有右子树，下一个结点为右子树中最小的结点
情况2：结点1的情况，无右子树且为左孩子，返回父结点
情况3：结点3的情况，无右子树且为右孩子，返回父节点的父节点
有parent指针的解法：
package cc150;
public class Successor {
public static void main(String[] args) {
// TODO 自动生成的方法存根
TreeNode a1 = new TreeNode(4);
TreeNode a2 = new TreeNode(2);
TreeNode a3 = new TreeNode(6);
TreeNode a4 = new TreeNode(1);
TreeNode a5 = new TreeNode(3);
TreeNode a6 = new TreeNode(5);
TreeNode a7 = new TreeNode(7);
a1.left = a2;
a1.right = a3;
a2.parent = a1;
a3.parent = a1;
a2.left = a4;
a2.right = a5;
a4.parent = a2;
a5.parent = a2;
a3.left = a6;
a3.right = a7;
a6.parent = a3;
a7.parent = a3;
Successor su = new Successor();
System.out.println(su.findSucc(a2,2).val);
System.out.println(su.findSucc(a4,1).val);
System.out.println(su.findSucc(a5,3).val);
}
public TreeNode findSucc(TreeNode root, int p) {
// write code here
if(root == null)
return null;
if(root.right != null) //当右子树不为空的情况，找到右子树的最小值
return rightMinChild(root.right);
else{
TreeNode root_copy = root;
TreeNode par = root_copy.parent;
while(par != null && par.left != root_copy){//向上直到位于左边，3在2的右边继续向上，直到2在4的左边
root_copy = par;
par = par.parent;
}
return par;
}
}
public TreeNode rightMinChild(TreeNode root){
if(root == null)
return null;
while(root.left != null)
root = root.left;
return root;
}
public static class TreeNode {
int val = 0;
TreeNode left = null;
TreeNode right = null;
TreeNode parent = null;
public TreeNode(int val) {
this.val = val;
}
}
}
无parent指针的解法：//使用中序遍历，按遍历的顺序放进ArrayList，然后通过p的值查找下一个结点
package cc150;
import java.util.ArrayList;
public class Successor {
public static void main(String[] args) {
// TODO 自动生成的方法存根
TreeNode a1 = new TreeNode(4);
TreeNode a2 = new TreeNode(2);
TreeNode a3 = new TreeNode(6);
TreeNode a4 = new TreeNode(1);
TreeNode a5 = new TreeNode(3);
TreeNode a6 = new TreeNode(5);
TreeNode a7 = new TreeNode(7);
a1.left = a2;
a1.right = a3;
a2.parent = a1;
a3.parent = a1;
a2.left = a4;
a2.right = a5;
a4.parent = a2;
a5.parent = a2;
a3.left = a6;
a3.right = a7;
a6.parent = a3;
a7.parent = a3;
Successor su = new Successor();
System.out.println(su.findSucc(a1,2));
System.out.println(su.findSucc(a1,1));
System.out.println(su.findSucc(a1,3));
}
public ArrayList<TreeNode> theList = new ArrayList<TreeNode>();
public int findSucc(TreeNode root, int p) { //使用中序遍历，按遍历的顺序放进ArrayList，然后通过p的值查找下一个结点
find(root); //其中最开始root要是树的根节点
int size = theList.size();
for(int i=0;i<size-1;i++){ //是size-1
if(theList.get(i).val == p)
return theList.get(i+1).val;
}
return -1;
}
public void find(TreeNode root){ //按中序遍历的顺序把结点放进ArrayList
if(root != null){
find(root.left);
theList.add(root);
find(root.right);
}
}
public TreeNode rightMinChild(TreeNode root){
if(root == null)
return null;
while(root.left != null)
root = root.left;
return root;
}
public static class TreeNode {
int val = 0;
TreeNode left = null;
TreeNode right = null;
TreeNode parent = null;
public TreeNode(int val) {
this.val = val;
}
}
}
面试题4.7：设计并实现一个算法，找出二叉树中某两个结点的第一个公共祖先。不得将额外的结点存储在另外的数据结构中。注意：这不一定是二叉查找树。
《剑指Offer》 最后的一两题
面试题4.8：你有两棵非常大的二叉树：T1，有几百万个结点；T2，有几百个结点。设计一个算法，判断T2是否为T1的子树。
如果T1有这么一个结点n，其子树与T2一模一样，则T2为T1的子树。也就是说，从结点n处把树砍掉，得到的树与T2完全相同。
package cc150;
import cc150.PathSum.TreeNode;
public class ContainsTree {
public static void main(String[] args) {
// TODO 自动生成的方法存根
TreeNode a1 = new TreeNode(4);
TreeNode a2 = new TreeNode(2);
TreeNode a3 = new TreeNode(6);
TreeNode a4 = new TreeNode(5);
TreeNode a5 = new TreeNode(7);
TreeNode a6 = new TreeNode(1);
TreeNode a7 = new TreeNode(3);
a1.left = a2;
a1.right = a3;
a2.left = a4;
a2.right = a5;
a3.left = a6;
a3.right = a7;
TreeNode a66 = new TreeNode(6);
TreeNode a11 = new TreeNode(1);
TreeNode a33 = new TreeNode(3);
a66.left = a11;
a66.right = a33;
ContainsTree ct = new ContainsTree();
System.out.println(ct.subTree(a1,a66));
}
public boolean subTree(TreeNode r1,TreeNode r2){ //r1是大树，r2是小树，在大树中寻找和小树的根节点相等的结点
if(r1 == null)
return false;
if(r1.val == r2.val){ //找到和小树根节点相等的结点
if(matchTree(r1,r2)) //判断是否所有的结点都相等，相等返回true
return true;
}
return (subTree(r1.left,r2) || subTree(r1.right,r2)); //递归所有左孩子和右孩子
}
public boolean matchTree(TreeNode r1,TreeNode r2){
if(r1 == null && r2 == null) //子树中已经没有结点，子树相同
return true;
if(r1 == null || r2 == null) //不同时为空说明两棵树不一样
return false;
if(r1.val != r2.val) //两个结点的值不想等，说明两棵树不一样
return false;
return (matchTree(r1.left,r2.left)) && (matchTree(r1.right,r2.right)); //递归左结点和右结点
}
public static class TreeNode {
int val = 0;
TreeNode left = null;
TreeNode right = null;
TreeNode parent = null;
public TreeNode(int val) {
this.val = val;
}
}
}
面试题4.9：给定一棵二叉树，其中每个结点都含有一个数值。设计一个算法，打印结点数值总和等于某个给定值的所有路径。注意，路径不一定非得从二叉树的根节点或叶节点开始或结束。——《Leetcode》112 Path Sum
package cc150;
import java.util.ArrayList;
import java.util.Iterator;
public class PathSum {
public static void main(String[] args) {
// TODO 自动生成的方法存根
TreeNode a1 = new TreeNode(4);
TreeNode a2 = new TreeNode(2);
TreeNode a3 = new TreeNode(6);
TreeNode a4 = new TreeNode(5);
TreeNode a5 = new TreeNode(7);
TreeNode a6 = new TreeNode(1);
TreeNode a7 = new TreeNode(3);
a1.left = a2;
a1.right = a3;
a2.left = a4;
a2.right = a5;
a3.left = a6;
a3.right = a7;
PathSum sum = new PathSum();
ArrayList<ArrayList<Integer>> theArr =sum.PathSum(a1,13);
Iterator ire = theArr.iterator();
while(ire.hasNext())
System.out.println(ire.next());
}
public ArrayList<ArrayList<Integer>> PathSum(TreeNode root, int sum) {
ArrayList<ArrayList<Integer>> arr = new ArrayList<ArrayList<Integer>>();
if(root == null)
return arr;
ArrayList<Integer> a = new ArrayList<Integer>();
depthTraversal(root,sum,0,arr,a);
return arr;
}
public void depthTraversal(TreeNode root, int sum,int currentSum,ArrayList<ArrayList<Integer>> arr,ArrayList<Integer> a){
if(root == null)
return;
if(root != null){
currentSum += root.val;
if(root.left == null && root.right == null){ //如果无子节点
if (currentSum == sum){ //如果相等
a.add(root.val); //把结点加进ArrayList
arr.add(new ArrayList<Integer>(a));
//System.out.println(a);
a.remove(a.size()-1); //如果相等，把ArrayList存起来，并去掉最后一个
}
return;
}
a.add(root.val); //如果还有子结点的话，加上这个结点之后，重复左右结点
depthTraversal(root.left,sum,currentSum,arr,a);
depthTraversal(root.right,sum,currentSum,arr,a);
a.remove(a.size()-1); //遍历完左右子节点，去掉本身结点
}
}
public static class TreeNode {
int val = 0;
TreeNode left = null;
TreeNode right = null;
TreeNode parent = null;
public TreeNode(int val) {
this.val = val;
}
}
}
