Fork me on GitHub

导航

公告

反转二叉树

输入一个二叉树,输出其镜像。

如下图,即交换所有节点的左右子树。

\

 

这里提供两种思路:使用递归和不使用递归。

使用的二叉树定义如下:

 

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

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

    }
}


解决方法:

 

 

import java.util.LinkedList;
import java.util.Scanner;

/*
 * 题目描述:输入一个二叉树,输出其镜像。
 * */
public class Solution {
	Scanner scanner = new Scanner(System.in);
	
	// 建立二叉树
	public TreeNode createTree(TreeNode root) {
		String val;
		val = scanner.next(); // next方法每次取到一个间隔符前面的数据
		if(val.equals("#")) {
			return null;
		}
		root = new TreeNode(Integer.parseInt(val));  System.out.println("输入的数据为:" + val);
		root.left = createTree(root.left);
		root.right = createTree(root.right);
		return root;
	}
	// 得到二叉树的镜像  —— 递归的方式
    public void Mirror(TreeNode root) {
    	if(root == null) {
    		return;
    	}
    	if((root.left == null) && (root.right == null)) {
    		return;
    	}
    	TreeNode temp = root.left;
    	root.left = root.right;
    	root.right = temp;
    	Mirror(root.left);
    	Mirror(root.right);
    }
    // 得到二叉树的镜像 —— 不使用递归
    public void MirrorNotRecursive(TreeNode root) {
    	java.util.LinkedList stack = new java.util.LinkedList();
    	TreeNode temp = null;
    	if(root == null) {
    		return;
    	}
    	stack.add(root);
    	while(stack.size() != 0) {
    		TreeNode node = stack.removeFirst();
    		temp = node.left;
    		node.left = node.right;
    		node.right = temp;
    		if(node.right != null) {
    			stack.add(node.right);
    		}
    		if(node.left != null) {
    			stack.add(node.left);
    		}
    	}
    }
    
    // 层次遍历二叉树
    public void levelTraverse(TreeNode root) {
    	if (root == null) {
    		return;
    	}
    	LinkedList list = new LinkedList();
    	list.add(root);
    	while (list.size() != 0) {
    		TreeNode node = list.removeFirst(); // list.removeFirst() 该方法LinkedList才有
    		System.out.print(node.val + " ");
    		if(node.left != null) {
    			list.add(node.left);
    		}
    		if(node.right != null) {
    			list.add(node.right);
    		}
    	}
    }
    
    public static void main(String[] args) {
    	Solution solution = new Solution();
    	TreeNode root = null;
    	root = solution.createTree(root);
    	System.out.println("原二叉树的层次遍历");
    	solution.levelTraverse(root);
    	solution.Mirror(root);
    	System.out.println("\n输出该二叉树的镜像");
    	solution.levelTraverse(root);
    	solution.MirrorNotRecursive(root);
    	System.out.println("\n输出该二叉树的镜像(非递归方式)");
    	solution.levelTraverse(root);
    }
}

/*
 * 测试数据:
 * 1 2 3 # 4 # # 5 6 # # # 7 8 # # 9 10 # # 11 # #  (说明:其中#说明左右子树为空)
 * 用先序遍历来建立树后,层次遍历结果为: 1 2 7 3 5 8 9 4 6 10 11
 * 反转二叉树之后:1 7 2 9 8 5 3 11 10 6 4 
 */

算法之:翻转二叉树

 
 

事情大概是说,Max Howell 去 Google 面试,面试官说:虽然在 Google 有 90% 的工程师用你写的 Homebrew,但是你居然不能在白板上写出翻转二叉树的代码,所以滚蛋吧。

 


/** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode(int x) { val = x; } * } */ public class Solution { public TreeNode invertTree(TreeNode root) { if (root == null) {//一定要检查指针为空 return null; } root.left = invertTree(root.left); root.right = invertTree(root.right); TreeNode tmp = root.left; root.left = root.right; root.right = tmp; return root; } }


那么这道题考查了什么呢?我觉得主要是考查了递归的思想。递归是程序设计的精髓,掌握了他可以将一个大问题分解成小问题,继而求解。比如对于此题来说,反转一个二叉树其实就是:

  1. 反转二叉树的左右子树
  2. 将左右子树交换

而第 1 步又是一个反转二叉树的问题,所以就可以用递归来处理了。然后再考虑好递归的结束条件,这道题就可以解决了。

 

考查算法题会不会太片面?

是的,算法在工作中运用得比较少,一般人也不会在工作中专门积累解算法题的能力。所以通常做算法题最强的是应届生,因为他们有时间去刷题。而在实际 工作中,很多能力,都比算法能力重要。比如对代码的洁癖,对设计模式的理解,对计算机底层(操作系统、网络)的理解,对待工作的态度等。

那么,为什么那么多公司不考查,或者不重点考查这些,而只是问算法题呢?

答案很简单,因为要在几个小时内了解一个人太难了。通常一场面试只有一个小时,如果要在一个小时内把上面说到的知识点都面面俱到的考查,是做不到 的。但是如果花几天来考查,对于公司和求职者都是不可接受的。所以,很多大公司就用面算法题的方式来偷懒,因为这种方式虽然可能会误伤很多优秀的人才,但 是不合格的人,要混进去还是相当困难的。

讲一句不好听的,很多公司在招聘的时候,首先根据学校,把非 985 的学校简历都过滤掉,也是一种不太合理,但是有效的方法。清华北大的人一定就牛逼吗?不一定,但是从概率上讲,比南翔技校的人通过面试的机会要高一些。所 以,为了提高面试效率和成本,就直接把一般学校的简历过滤掉,这是一个不人道,但是从经济上合理的行为。

 

所以熟悉算法题是必须的。

posted on 2017-09-20 09:13 HackerVirus 阅读(...) 评论(...) 编辑 收藏

统计