(1)二叉树镜像
两字:递归
代码为
public static void main(String[] arg) {
Node a = new Node('A');
a.left=new Node('B');
a.rigth=new Node('C');
a.left.left=new Node('D');
a.left.rigth=new Node('E');
a.rigth.left=new Node('F');
a.rigth.rigth=new Node('G');
System.out.print("原二叉树为");
levelRecur.levelRecur(a);
Mirror(a);
System.out.print("\n"+"二叉树镜像为");
levelRecur.levelRecur(a);
}
private static void Mirror(Node a) {
if(a==null) {
return ;
}
if(a.left!=null||a.rigth!=null) {
Node temp=a.left;
a.left=a.rigth;
a.rigth=temp;
}
if(a.left!=null) {
Mirror(a.left);
}
if(a.rigth!=null) {
Mirror(a.rigth);
}
}
(2)树的子结构
public static void main(String[] arg) {
Node a = new Node('A');
a.left=new Node('B');
a.rigth=new Node('C');
a.left.left=new Node('D');
a.left.rigth=new Node('E');
a.rigth.left=new Node('F');
a.rigth.rigth=new Node('G');
Node b = new Node('C');
b.left=new Node('F');
b.rigth=new Node('G');
System.out.print("是否为子结构");
boolean result=HasSubtree(a,b);
System.out.print(result);
}
private static boolean HasSubtree(Node root1, Node root2) {
boolean result=false;
if(root1!=null&&root2!=null) {
if(root1.val==root2.val) {
result=isSubTree(root1,root2);
}
if(!result) {
result=isSubTree(root1.left,root2);
result=isSubTree(root1.rigth,root2);
}
}
return result;
}
private static boolean isSubTree(Node root1, Node root2) {
if(root2==null) {
return true;
}
if(root1==null&&root2!=null) {
return false;
}
if(root1.val!=root2.val) {
return false;
}
return isSubTree(root1.left,root2.left)&&isSubTree(root1.rigth,root2.rigth);
}
(3)从上往下打印二叉树
四字:层序遍历
public static void main(String[] arg) {
Node a = new Node('A');
a.left=new Node('B');
a.rigth=new Node('C');
a.left.left=new Node('D');
a.left.rigth=new Node('E');
a.rigth.left=new Node('F');
a.rigth.rigth=new Node('G');
System.out.print("从上往下打印二叉树节点为:");
PrintFromTopToBottom(a);
}
private static void PrintFromTopToBottom(Node a) {
if(a==null) {
return ;
}
Queue<Node> queue=new LinkedList<Node>();
queue.offer(a);
while(!queue.isEmpty()) {
Node nd=queue.poll();
System.out.print(nd.val+" ");
if(nd.left!=null) {
queue.offer(nd.left);
}
if(nd.rigth!=null) {
queue.offer(nd.rigth);
}
}
}
(4)二叉搜索树的后序遍历序列
题目描述
输入一个整数数组,判断该数组是不是某二叉搜索树的后序遍历的结果。如果是则输出true,否则输出false。假设输入的数组的任意两个数字都互不相同。
思路:二叉树后序遍历的特点、递归
public static void main(String[] arg) {
int a[] = { 51, 46, 20, 18, 65, 97, 82, 30, 77, 50 };
System.out.println("是否为二叉搜索树的后序遍历:");
System.out.print(VerifySquenceOfBST(a));;
}
private static boolean VerifySquenceOfBST(int[] a) {
if(a==null||a.length==0) {
return false;
}
return vsofBST(a,0,a.length-1);
}
private static boolean vsofBST(int[] a, int start, int end) {
int count=end;
while(count>0&&a[count]>=a[end]) {
count--;
}
for(int i=start;i<count;i++) {
if(a[i]>a[count]) {
return false;
}
}
return vsofBST(a,start,count)&&vsofBST(a,count+1,end-1);
}
(5)二叉树的深度
题目描述
输入一棵二叉树,求该树的深度。从根结点到叶结点依次经过的结点(含根、叶结点)形成树的一条路径,最长路径的长度为树的深度
思路:层次遍历思想、递归写法为后序遍历
public static void main(String[] arg) {
Node a = new Node('A');
a.left=new Node('B');
a.rigth=new Node('C');
a.left.left=new Node('D');
a.left.rigth=new Node('E');
a.rigth.left=new Node('F');
a.rigth.rigth=new Node('G');
System.out.println("递归求树的高度为:");
int heigth=TreeDepth(a);
System.out.print(heigth);
System.out.println("\n"+"非递归求树的高度为:");
int heigths=TreeDepths(a);
System.out.print(heigths);
}
private static int TreeDepths(Node a) {
if(a==null) {
return 0;
}
int count=0,nextcount=1,depth=0;
Queue<Node> queue=new LinkedList<Node>();
queue.offer(a);
while(!queue.isEmpty()) {
Node nd=queue.poll();
count++;
if(nd.left!=null) {
queue.offer(nd.left);
}
if(nd.rigth!=null) {
queue.offer(nd.rigth);
}
if(count==nextcount) {
depth++;
count=0;
nextcount=queue.size();
}
}
return depth;
}
private static int TreeDepth(Node a) {
if(a==null) {
return 0;
}
int left=TreeDepth(a.left);
int rigth=TreeDepth(a.rigth);
return Math.max(left,rigth)+1;
}
(6)平衡二叉树
题目描述
输入一棵二叉树,判断该二叉树是否是平衡二叉树。
思路:后序遍历
public class Solution {
public boolean IsBalanced_Solution(TreeNode root) {
if (root == null)
return true;
if (Math.abs(getHeight(root.left) - getHeight(root.right)) > 1)
return false;
return IsBalanced_Solution(root.left) && IsBalanced_Solution(root.right);
}
public int getHeight(TreeNode root) {
if (root == null)
return 0;
return max(getHeight(root.left), getHeight(root.right)) + 1;
}
private int max(int a, int b) {
return (a > b) ? a : b;
}
}
(7)二叉树的下一个结点
题目描述
给定一个二叉树和其中的一个结点,请找出中序遍历顺序的下一个结点并且返回。注意,树中的结点不仅包含左右子结点,同时包含指向父结点的指针。
public static void main(String[] arg) {
Node a = new Node('A');
a.left=new Node('B');
a.rigth=new Node('C');
a.left.left=new Node('D');
a.left.rigth=new Node('E');
a.rigth.left=new Node('F');
a.rigth.rigth=new Node('G');
System.out.println("二叉树的下一个结点:");
System.out.print(GetNext(a).val);
}
public static Node GetNext(Node pNode)
{
if(pNode==null){
return null;
}
if(pNode.rigth!=null){
pNode=pNode.rigth;
while(pNode!=null&&pNode.left!=null){
pNode=pNode.left;
}
return pNode;
}
while(pNode.next!=null){
if(pNode==pNode.next.left){
return pNode.next;
}else{
pNode=pNode.next;
}
}
return null;
}
(8)对称的二叉树
题目描述
请实现一个函数,用来判断一颗二叉树是不是对称的。注意,如果一个二叉树同此二叉树的镜像是同样的,定义其为对称的。
思路:递归判断左右子树是否相同
public static void main(String[] arg) {
Node a = new Node('A');
a.left=new Node('B');
a.rigth=new Node('C');
a.left.left=new Node('D');
a.left.rigth=new Node('E');
a.rigth.left=new Node('F');
a.rigth.rigth=new Node('G');
System.out.println("是否为对称二叉树:");
System.out.print(isSymmetrical(a));
}
private static boolean isSymmetrical(Node a) {
if(a==null) {
return false;
}
return isSymmet(a.left,a.rigth);
}
private static boolean isSymmet(Node left, Node rigth) {
if(left==null&&rigth==null) {
return true;
}
return left.val==rigth.val&&isSymmet(left.left, rigth.rigth)&&isSymmet(left.rigth, rigth.left);
}
(8)按之字形顺序打印二叉树
题目描述
请实现一个函数按照之字形打印二叉树,即第一行按照从左到右的顺序打印,第二层按照从右至左的顺序打印,第三行按照从左到右的顺序打印,其他行以此类推。
思路:层序非递归遍历思想
public static void main(String[] arg) {
Node a = new Node('A');
a.left=new Node('B');
a.rigth=new Node('C');
a.left.left=new Node('D');
a.left.rigth=new Node('E');
a.rigth.left=new Node('F');
a.rigth.rigth=new Node('G');
System.out.println("二叉树按之字形打印节点:");
Print(a);
for(int i=0;i<Print(a).size();i++) {
System.out.print(Print(a).get(i)+" ");
}
}
private static ArrayList<ArrayList<Integer>> Print(Node a) {
if(a==null) {
return null;
}
ArrayList<ArrayList<Integer>> listall=new ArrayList<ArrayList<Integer>>();
ArrayList<Integer> list=new ArrayList<Integer>();
Queue<Node> queue=new LinkedList<>();
queue.offer(a);
int start=0,end=1;
boolean lefttoright=true;
while(!queue.isEmpty()) {
Node nd=queue.poll();
list.add(nd.val);
start++;
if(nd.left!=null) {
queue.offer(nd.left);
}
if(nd.rigth!=null) {
queue.offer(nd.rigth);
}
if(start==end) {
start=0;
end=queue.size();
if(lefttoright) {
listall.add(list);
}else {
listall.add(revesor(list));
}
lefttoright=!lefttoright;
list=new ArrayList<Integer>();
}
}
return listall;
}
private static ArrayList<Integer> revesor(ArrayList<Integer> list) {
if(list==null||list.size()==0) {
return null;
}
ArrayList<Integer> revesorlist=new ArrayList<Integer>();
for(int i=list.size()-1;i>=0;i--) {
revesorlist.add(list.get(i));
}
return revesorlist;
}
(9)二叉搜索树的第k个结点
题目描述
给定一颗二叉搜索树,请找出其中的第k大的结点。例如, 5 / \ 3 7 /\ /\ 2 4 6 8 中,按结点数值大小顺序第三个结点的值为4。
思路:中序非递归排序
public static void main(String[] arg) {
Node a = new Node(5);
a.left=new Node(3);
a.rigth=new Node(7);
a.left.left=new Node(2);
a.left.rigth=new Node(4);
a.rigth.left=new Node(6);
a.rigth.rigth=new Node(8);
System.out.println("二叉树第k大节点为:");
KthNode(a,4);
}
private static void KthNode(Node a, int i) {
if(a==null||i<1) {
return ;
}
Stack<Node> stack=new Stack<Node>();
ArrayList<Integer> list=new ArrayList<Integer>();
while(!stack.isEmpty()||a!=null) {
if(a!=null) {
stack.push(a);
a=a.left;
}else {
Node nd=stack.pop();
list.add(nd.val);
a=nd.rigth;
}
}
System.out.print(list.get(i-1));
}