Career on Bro Nan's Journal

楠哥甲午年末的跳槽总结【楠哥原创】

Mon, 23 Mar 2015 07:14:34 +0000

楠哥的帖子只在一亩三分地和我个人的某个人迹罕至的博客发表，转载、引用请注明作者、出处。谢谢。原帖发于http://www.1point3acres.com/bbs/thread-125808-1-1.html

好久没有在地里发干货了，趁着跳槽之间的gap，来总结一下跳槽这段经历。

##背景介绍

可能对这个id熟悉的人,应该已经了解我基本信息了。简单说来就是川大本科，哥大Master，都是CS专业。毕业后于2013年初入职微软，据这次跳槽正式离职工作总计两年零十天。2014年11月Google电面，12月Onsite，2015年1月拿到Offer，3月入职（为什么战线拖了这么长，后面会解释）。工作地点在Google Seattle。

##跳槽起因

因为Master是在纽约读的，所以跳槽最本质的原因是长期以来心中都有着一个声音，“要找机会回纽约去生活”。而跳槽的导火索，则源于微软组里的Re-Org和2014年的大裁员。Re-Org之后，原来的老板H换到别的组了，新来的老板S和原来老板的风格完全不一样，而且很多事情的思路也与原来老板相左。最最重要的是，新老板并不是那种愿意为手下人的职业生涯考虑的类型，所以总感觉在组里的发展受到限制。

其实我一直很享受在微软的感觉，原来的老板H对我也很好，入职10个月就给我升到了60级，而且答应1年到1年半之内升到61级。可是Re-Org之后，老板S有一次提到“三年内你会升到下一级的”，而且从平时的工作中也可以看出丝毫没有给我安排有助于我成长和发展的工作。前后两个老板的反差，让我萌生了跳槽的想法。就在这时，微软开始了有史以来最大规模的裁员，虽然没有波及到我，但是不安全感萦绕在每一个人的心头，自然刷题和跳槽就成了一种自我解救的手段。2014年9月，正式开始查资料、刷题、看面经。

##跳槽准备

跳槽和刚毕业找工作有稍许的不同。好处是，毕竟不是第一次找工作了，知道应该把有限的经历放在什么地方；坏处是每天白天上班，晚上刷题，还有生活上的杂事，很累也很容易放弃。分几部分来说说我的准备过程：

###简历准备

我的简历基本上完全重写了一遍，原来写在简历上的project全部都用工作之后的project替代了。因为本文不是简历写作的攻略，所以我就不展开说了，重点推荐一本书，the google resume, 也是CtCI的作者写的，我前前后后看了多遍，感觉里面的思路非常不错。作为跳槽的简历，注意不要透露Confidential的信息。有的正在进行中的project，应该注意不要透露更多的细节。也应该避免过多的使用缩写和专有名词，有的时候在一个公司干的久了，难免会把简历写成工作报告。

另外，工作一段时间后，对于经济上的投入相对学生时代变得不是很敏感，而对于时间上的投入则变得分秒必争。所以简历写好了之后，在网上找了一个改简历的服务。网申很多类似的服务，价格不等，一般几十元的大多是从HR的角度帮助修改，100-200元这个价位的就可以找到experienced engineer帮忙修改了，我觉得后者要更有用一些。

###算法题准备

算法题仍然是这个level面试的关键因素，曾经听说过这个级别的职位，一般说来算法题决定hiring decision，设计题决定package如何。算法题的准备最关键的其实是“恒心”两个字。工作之后，每天在公司工作8个小时，晚上再回家刷题确实是一件非常辛苦的事情，但是如果像我这样没有做过什么ACM的同学，算法题还是要花时间去准备的。Leetcode我准备的主要材料，网上还有一些类似的算法课，甚至是专门针对面试的算法课可以去听一听。在准备的过程中，刷题的遍数是一个方面，总结归纳是另一个方面。在前期可以强迫自己每天做N道leetcode，后期就可以每天做1类leetcode题了。至于CtCI和其他的材料，可以作为leetcode的补充，但是如果leetcode还有一多半没有写过，我觉得完全没必要去分散精力。

###设计题准备

从来没有准备过设计题，所以在网上找了很多资料。网上最多的说法是说去看大公司的Engineering Blog，我相信会有一定作用，但是问题是，我在准备跳槽的过程当中，算法题的准备已经花去了我大部分的精力，毫无头绪的看技术博客，非常的没有效率。所以，我只是简单的看了一些这类题目的作答技巧，其中有一个Harvard的课的最后一节，大概两个小时（连接是 https://www.youtube.com/watch?v=-W9F__D3oY4），我觉得对我的帮助特别特别的大。网上也有别人做过重点推荐，我觉得如果没有什么时间，就认真看一看这个会起到非常大的作用。全部准备完之后，在网上约了一个小时的Design mock interview，一个session大概可以mock4个题，有很全面的feedback，很适合面试前突击。

###联系Recruiter，投简历

因为最开始的想法是回纽约，所以所有的职位全部都是选择的NYC。

Google和Facebook刚好在2014年5月份左右有Recruiter加我的LinkedIn，当时来回发过几封邮件，所以当我准备跳槽时候，给他们发过去简历，很快就安排了面试。

Amazon比较特别，因为和Microsoft同在Greater Seattle，所以一年当中会不断地有Recruiter给你发邮件，当时刚好接到了一个组的邮件，号称要做High Confidential Project，所以决定面这家。

LinkedIn的面试来自于同学的推荐，并不是内推，而是LinkedIn让我的同学去面试，他无意跳槽，就把我介绍给了那个Recruiter。所以如果你打算跳槽，多问问周围的同学说不定会有意想不到的机会。注意，我说的是同学，不是同事。

进入十月份，因为一些原因Seattle成为了我的候选地点之一，于是我找同学内推了Apple Seattle，我自己还投了Twitter Seattle，以及NYC的Square和Dropbox。结果连电话面试都没有接到。

##面试经历

一共面了4家，都拿到了onsite。

Google整个面试流程拖得非常长。电面是纽约的一个工程师打电话过来的，两个题目都很简单，之后安排了纽约的Onsite。Onsite一共五轮+一轮吃饭，每轮45分钟，每轮1题，全部是算法题。Google的面试题第一个特点，就是题都是自己编的，没有在别的地方看到过。Google面试的第二个特点就是题目编的都不是严谨，很多时候面试官也没想的很完善，你如果提出来了感觉是非常好的加分。其实我觉得，Google题目整体难度不高，基本是Leetcode上的中等题目的水平。但是因为是新题，所以相比Leetcode上面见过的题，可能会有一些陌生的感觉。

Facebook电面只有一轮，题目不算简单，我答的也不好，但是没想到竟然给了onsite。Onsite两轮算法，一轮Design，一轮behavior+Design。设计题没答好，算法题感觉难度基本是Leetcode上面较难的一部分题目，可以明显的看出面试题是从Leetcode上面改编的。design没答好，最后没offer是自然。

LinkedIn安排了两轮电面，每一轮都有两个人。电面都是Leetcode原题。在纽约Onsite，一共五轮（onsite当天早晨5点才到纽约，紧接着面试我也是够拼的），其中两轮behavior，一轮Design，两轮算法。除了design和其中一轮behavior以外，都是两个面试官。算法题基本全部都是leetcode原题，design题也非常简单。只是不知道为什么最后没有发offer。

Amazon收到邮件后，安排了一次电面，电面直接和Hiring Manager进行，问了一道很简单的算法题和很多behavior的题目。紧接着安排了Onsite，奇怪的是，onsite也没有什么很难的算法题，事实上，应该说onsite也没有什么算法题，一共5轮，一轮behavior，一轮纯算法，两轮OO Design，一轮System Design。

所有面经的具体题目，用小号放出。

##Offer选择

无奈一共只有两个Offer，Amazon和Google，没什么好选择的。其实两家的base都没有我在Microsoft的base高，不过Google的annual bonus和stock高一些，而切Google毕竟是包括我在内的很多码农向往的地方，所以最后选了Google。在地点上，Google当时可选Seattle，NYC和MTV，我自己都不敢相信，两年来心心念念的NYC，我却在最后放弃了。留在Seattle，但愿我不会后悔。

##H1b与绿卡 H1B Transfer应该是每一个第一次跳槽的人都很关心的问题。先来说一下流程，基本流程是你拿到新公司的Offer，确认接受Offer，公司进行背景调查。北京调查后公司开始为你办理H1B Transfer。（H1B Transfer办理前，公司会首先提交一个LCA application，一般这个公司可能不会告诉你详情，但是很多公司的Immigration System里面会有显示。）公司首先提交H1B Transfer Petition，从USCIS收到Case Number，理论上来讲，这个时候你就可以通知现在的雇主你打算换工作了，因为即便现在的雇主当时辞退你，你也可以直接到新公司上班，不需要等到你的H1B Case被批准。如果新公司帮你办理的是Premium Processing，那么你的Case会在15日内被批准，如果是Regular Processing，那么你需要等1个多月到若干月不等，具体要看当时USCIS公布的处理时间。无论需要等多长时间，一旦你拿到了Case Number，都不影响你到新的公司入职工作（有些公司有自己的Policy除外）。还需要特别说明的是，我在网上查到的资料显示，你在H1B Transfer提交申请的整个过程当中，你的现任雇主不会知道H1B Transfer这件事情。具体到我个人，直到我的H1B Case被批准，我的现有雇主都不知道我要换工作这件事情。

现在越来越多的公司开始为刚入职的员工办理绿卡了，所以，跳槽的过程当中，绿卡自然也是一个重要的考量因素。绿卡的详细过程可以参见W大多年前写的关于绿卡的系列文章，我在这里就跳槽相关的事情简单解释一下。楼主的老雇主M和新雇主G都从入职第一天开始办理绿卡。（事实上，可能对于1-2年工作经验的同学，为了增加offer的吸引力，即便像Amazon这样的公司，也愿意提供绿卡。）绿卡办理大体上分为三步，PERM，I-140和I-485。对于中国大陆出生的同学来说，要经过一个大致5年的排期过程，排期一般发生在I-140和I-485之间，所以基本上前面两步视公司律师的配合程度，一般情况下在一年-两年之间可以完成。排期的时候，你进入Queue的日期，叫做Priority Date，是按照PERM的提交日期进行计算。跳槽的时候，一旦进入新的公司都要从头再来，这是无法改变的，我们能够做的是，进入新公司从新开始办绿卡时，继续使用以前的Priority Date，这样就可以保证排期的等待时间不会因为跳槽而增加。为了达到这个目标，我们就要等待I-140批准后（不是递交之后）再辞职，这也就是为什么楼主跳槽从拿到offer到最后入职经历了两个多月的时间。I-140现在审理时间为4-6个月，其实也是可以办理Premium Processing的，但是微软的政策是办理Premium Processing需要Manager批准，所以我就老老实实的等了5个月。

Pow(x, n)

Thu, 20 Dec 2012 00:35:00 +0000

指数计算应该是递归程序设计的入门级题目，但是在一场面试中写一个bug-free的代码还是需要多多注意边界条件。首先是底数的正负会影响结果，其次是指数的正负，也会影响结果。因为函数原型是pow(int x, int n),所以指数一定是整数。题目的一个简单思路是使用一个循环计算n遍x的乘积，但是这样的计算复杂度太高。如果我们想计算pow(x,16),我们需要做15次乘法，这样的开销很大。使用分治法换一个角度考虑，pow(x,16)其实可以分成两个pow(x,8)的乘积，同样的，pow(x,8)可以分成两个pow(x,4)的乘积，这样计算下去，只需要计算4次乘法就可以完成。如果pow(x,15)该怎么算？其实只要计算两个pow(x,7)的乘积再乘以x即可。在实现的时候有一个细节需要注意。当写递归的代码时，不要使用return pow(x,n/2)*pow(x,n/2)这样的语句，因为这样会造成重复计算pow(x,n/2)两次，增加运算的复杂度。使用一个变量保存pow(x,n/2)的结果才是正解。此题同样是Leetcode OJ上的题目，下面是其Java实现。

public class Solution {

	/**
	 * Implement pow(x, n).
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		System.out.println(new Solution().pow(2.0,10));

	}
	
	public double pow(double x, int n) {
		// Start typing your Java solution below
		// DO NOT write main() function
		boolean neg = false;
		
		if((x == 0 &amp;&amp; n == 0) || (x == 1)){
			return 1;
		}
		else if(x == 0){
			return 0;
		}
		else if (x &gt; 0){
			neg = false;
		}
		else{
			if(neg){
				return pow(x*(-1),n);
			}
			else{
				return (-1)* pow(x*(-1),n);
			}
		}	
		
		if(n == 0){
			return 1;
		}
		else if(n == 1){
			return x;
		}
		else if (n &gt; 0){
			if( n % 2 == 0){
				double temp = pow(x, n/2);
				return temp * temp;
			}
			else{
				double temp = pow(x, (n-1)/2);
				return temp * temp * x;
			}
		}
		else{
			double temp = pow(x, n*(-1));
			return 1.0 / temp;
		}	
	}
}

Valid Parentheses

Wed, 19 Dec 2012 03:01:31 +0000

括号题目是一类经典的算法题目，有很多变形。这类题目乍一看上去没有什么思路，但是实质上就是最近成对括号的匹配问题。常用的方法有记录括号数目和使用栈两种方式。

合法括号的判断问题是指在一串由()[]和{}组成的字符串中，判断括号是否合法。比如{()[]}是一个合法序列，但是(])就是非法的。该题目的解决可以使用栈来完成。当发现一个左括号([{时，将其压入栈中；当扫描到一个右括号时，判断栈顶元素（java中使用peek()函数）是否是与当前元素匹配的括号字符。如果不匹配，则整个字符串不合法；如果匹配，则弹出栈顶元素（java中使用pop()）函数。该题目是Leetcode OJ上的题目，其java实现如下

public class Solution {

	/**
	 * Given a string containing just the characters '(', ')', '{', '}', '[' and
	 * ']', determine if the input string is valid.
	 * 
	 * The brackets must close in the correct order, &quot;()&quot; and &quot;()[]{}&quot; are all
	 * valid but &quot;(]&quot; and &quot;([)]&quot; are not.
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		System.out.println(new Solution().isValid(&quot;[]{}()&quot;));
	}
	
	public boolean isValid(String s) {
        // Start typing your Java solution below
        // DO NOT write main() function
		Stack &lt;Integer&gt; stack = new Stack&lt;Integer&gt;();
		
        for(int i = 0; i &lt; s.length();i++){
        	switch(s.charAt(i)){
        	case '(':
        		stack.push(1);
        		break;
        	case '[':
        		stack.push(2);
        		break;
        	case '{':
        		stack.push(3);
        		break;
        	case ')':
        		if(stack.empty())
        			return false;
        		if(stack.peek() == 1){
        			stack.pop();
        		}
        		else{
        			return false;
        		}
        		break;
        	case ']':
        		if(stack.empty())
        			return false;
        		if(stack.peek() == 2){
        			stack.pop();
        		}
        		else{
        			return false;
        		}
        		break;
        	case '}':
        		if(stack.empty())
        			return false;
        		if(stack.peek() == 3){
        			stack.pop();
        		}
        		else{
        			return false;
        		}
        		break;
        	default:
        			return false;
        	}
        }
        
        if(!stack.empty())
        	return false;
        else
        	return true;
    }

}

Climbing Stairs

Tue, 18 Dec 2012 00:41:55 +0000

爬楼梯问题是一道典型的递归问题和动态规划问题的入门级题目。题目描述是：给定一个n个台阶楼梯，每次可以上一个或者两个台阶，请问最终可以有多少种方法爬到顶层。使用递归的思路解决是，到达第K个楼梯的方法数目是到达地k-1个楼梯的方法数与到达地k-2的楼梯的方法数的和。所以，如果函数原型是int cal(int n)，那么我们可以得到递归规则是cal(k)=cal(k-1)+cal(k-2）。边界条件是cal(1)=1,cal(2)=2。但是，这样计算会有很多的重复性计算，所以可以使用动态规划来解决。如果使用一位数组ways来存储到达第k个楼梯的方法数，那么ways[k+1] = ways[k]+ways[k-1];从0一直结算到n，可以避免很多的重复计算。该题目是leetcode上OJ的题目，也是CtCI的原题的变形。下面是给题目的Java实现。

public class Solution {

	/**
	 * You are climbing a stair case. It takes n steps to reach to the top.
	 * Each time you can either climb 1 or 2 steps. In how many distinct 
	 * ways can you climb to the top?
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		System.out.println(new Solution().climbStairs(10));

	}
	
	public int climbStairs(int n) {
        // Start typing your Java solution below
        // DO NOT write main() function
		
		if(n &lt; 0)
			return 0;
		
		int[] ways = new int [n+1];
		
		ways[0] = 1;
		ways[1] = 1;
		
		for(int i = 2; i &lt; n+1; i++){
			ways[i] = ways[i-1]+ways[i-2];
		}		
		return ways[n];        
       }

}

Balanced Binary Tree

Sun, 16 Dec 2012 00:40:56 +0000

判定平衡二叉树的题目是一道基本的数据结构题目，在Leetcode的OJ上也有相关的测试用例。二叉树的结构请参见《Leetcode中使用的二叉树结构》。

可以使用一个递归函数，递归的判断每个节点的左子树和右子树的高度是否相差1，但是这样的算法会产生很多次重复的计算，效率并不高。另外一种方法是设计一个递归函数，返回以每个节点为根的二叉树的高度，当左右子树返回的高度相差超过1时，则返回-1表示该树不平衡。这样的算法时间复杂度为O(n)。该算法的Java实现如下。

public class Solution {

	/**
	 * Given a binary tree, determine if it is height-balanced.
	 *For this problem, a height-balanced binary tree is defined as a binary 
	 *tree in which the depth of the two subtrees of every node never differ 
	 *by more than 1.
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		TreeNode root = new TreeNode(1);
		root.left = new TreeNode(2);
		root.right = new TreeNode(3);
		root.left.left = new TreeNode(4);
		root.left.right = new TreeNode(5);
		root.right.left = new TreeNode(6);
		root.right.right = new TreeNode(7);

		
		System.out.print(new Solution().isBalanced(root));
	}
	
	public boolean isBalanced(TreeNode root) {
        // Start typing your Java solution below
        // DO NOT write main() function
		
		if(height(root) == -1)
			return false;
		else
			return true;
    }
	
	public int height(TreeNode n){
		int left_b, right_b;
		
		if(n == null){
			return 0;
		}
		else{
			left_b = height(n.left);
			right_b = height(n.right);

			if (left_b == -1 || right_b == -1) {
				return -1;
			} else if (Math.abs(left_b - right_b) &lt;= 1) {
				return Math.max(left_b, right_b)+1;
			} else {
				return -1;
			}
		}
	}

}

Leetcode中使用的二叉树结构

Sun, 16 Dec 2012 00:32:11 +0000

在leetcode中使用的二叉树,大多是"双指针"二叉树,即每个节点有指向其两个孩子的两个指针。同时，每个节点都有一个域存储该节点的int型值。每个节点写成一个类，该类每个域都是默认的public型的，可以从类外直接访问。该类提供一个构造函数，用于创建一个新的节点并将int型的value赋值。每个节点的java实现如下：

public class TreeNode {
	int val;
	TreeNode left;
	TreeNode right;

	TreeNode(int x) {
		val = x;
	}
}

Best Time to Buy and Sell Stock

Sat, 15 Dec 2012 00:57:28 +0000

股票买卖是面试当中另外一个常见的问题。问题的描述是：给出一个数组，数组中的的数表示每个时刻股票的价格。如果只允许买卖一次，请写出一个算法给出可能的最大收益。基础的算法是对于一个个时刻，搜索其能得到的最大收益，最后在所有的最大收益当中选择一个最大值输出。这样的算法复杂度为O（n^2）。一个比较好的算法是，使用两个变量一个记录当前遇到的最低股价，一个计算当前的最大收益。从左到右搜索数组，如果当前价格与最低股价的差大于最大收益，则将当前最大收益保存下来。扫描结束后，便可得到最大的收益。该题目在leetcode的OJ上面有，下面是该算法的Java实现。

public class Solution {

	/**
	 * Say you have an array for which the ith element is the price of a given
	 * stock on day i.
	 * 
	 * If you were only permitted to complete at most one transaction (ie, buy
	 * one and sell one share of the stock), design an algorithm to find the
	 * maximum profit.
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int [] A = {2,1,4};
		System.out.print(new Solution().maxProfit(A));

	}
	public int maxProfit(int[] prices) {
        // Start typing your Java solution below
        // DO NOT write main() function
		
		if(prices == null || prices.length == 0)
			return 0;
		
		int maxprofit = 0;
		int lowest_before = Integer.MAX_VALUE;
		
		for(int i = 0; i &lt; prices.length; i++){
			if(lowest_before &gt; prices[i])
				lowest_before = prices[i];
			else if(prices[i] - lowest_before &gt; maxprofit){
				maxprofit = prices[i] - lowest_before;
			}
			
		}		
		return maxprofit;        
    }
}

Two Sum

Fri, 14 Dec 2012 03:50:22 +0000

Two Sum是各种面试题当中的经典题目。题目是给定一个目标和和一个数组，找出和等于目标和的所有数对。题目的解法有很多，比如使用hash map把数组进行hash存储，之后查找每个元素是否可以找到对应的值是否存在于hashmap当中。这样的解法的时间复杂度是O(n)，空间复杂度也是O(n)。另外一种方法是将一个数组排序，之后使用两个指针，一个向后搜索，一个向前搜索，如果当前和小于目标和，左指针向右移动；反之右指针向左移动。这样的话时间复杂度是O(n)依赖于排序的复杂度，空间复杂度最好可以做到O(1)。往往面试官希望能给出第二种解法。第二种解法的java实现如下。

public class sol {

	/**
	 * Given an array of integers, find two numbers such that they add up to a
	 * specific target number.
	 * 
	 * The function twoSum should return indices of the two numbers such that
	 * they add up to the target, where index1 must be less than index2. Please
	 * note that your returned answers (both index1 and index2) are not
	 * zero-based.
	 * 
	 * You may assume that each input would have exactly one solution.
	 * 
	 * Input: numbers={2, 7, 11, 15}, target=9 Output: index1=1, index2=2
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int [] A = {150,24,79,50,88,345,3};
		int [] B = new sol().twoSum(A,200);
		System.out.println(B[0]);
		System.out.println(B[1]);
	}
	
	public int[] twoSum(int[] numbers, int target) {
        // Start typing your Java solution below
        // DO NOT write main() function
		if(numbers == null || numbers.length == 0)
			return new int[2];
		
		int [] nums = numbers.clone();
		Arrays.sort(numbers);
		
		int i = 0;
		int j = numbers.length-1;
		
		while(i &lt; j){
			if(numbers[i]+numbers[j] == target){				
				break;
			}
			else if(numbers[i]+numbers[j] &lt; target){
				i++;
			}
			else {
				j--;
			}
		}
		
		int [] results = {-1,-1};
		for(int k = 0;k &lt; nums.length;k++){
			if(numbers[i] == nums[k] &amp;&amp; results[0] == -1){
				results[0] = k+1;
			}
			else if(numbers[j] == nums[k]&amp;&amp; results[1] == -1){
				results[1] = k+1; 
			}
		}
		Arrays.sort(results);
		return results;        
    }
}

工作基本敲定，我的找工作总结【楠哥原创】

Fri, 14 Dec 2012 03:10:41 +0000

简单说说教科书吧【楠哥原创】

Tue, 24 Jul 2012 05:09:00 +0000

吃货开贴为12级童鞋介绍美国生活（做饭篇）【楠哥原创】

Fri, 13 Jul 2012 02:56:37 +0000

简单说说留学生的移动硬盘和资料下载【楠哥原创】

Fri, 13 Jul 2012 02:53:17 +0000

原文发表于http://www.1point3acres.com/bbs/thread-36332-1-1.html

首先，仍然是背景介绍。lz人在纽约，哥大，平常使用哥大的校园WIFI和有线网。据我所认识的其它学校的朋友大多与我的情况相仿。本文所述皆基于以上的背景。

关于网络：

WIFI下载速度可达3M/s左右，速度稳定。但是需要你的无线网卡支持802.11的h模式。没有的话速度一般不超过1M。

有线网和WIFI速度一致。但是一些建筑内WIFI信号不是很好，所以还是有必要带一个网线的。

关于下载：

http模式完全没有问题。

P2P的话，迅雷的普通下载是没有速度的，但是离线下载可达1M/s左右。电驴和BT的情况比较复杂，使用学校的网络是绝对不行的，用了不到5分钟，MAC地址就被封了。但是我的同学自己租的房子，用att的网络下载无压力。

关于下载的建议：

过来之后开迅雷会员，淘宝上有便宜的。基本能下载到所有的东西。

关于过来时候带的移动硬盘：

娱乐类：

喜欢电影电视剧的还是带一些，国内的很多在线视频在米国是不能看的。不过这面学习忙，估计也没什么时间看。

音乐带一些，不过音乐这东西还是要不断更新，所以带太多了没有用。顺便提一句，百度在这里没有办法使用，可以用酷狗下载，不过速度偏慢。

游戏的话，如果不是游戏迷就不要带了。没时间玩。

动漫，我是动漫迷，带了不少，还是挺有用的。不过迅雷离线下载也能随时下载到。

其它自己的各类爱好视情况而带。

软件：

windows还是有必要带的，虽然我估计大部分同学过来之后要换电脑。

office也建议带上，不过有些学校可以在学校得到免费版，我们学校没有TT……

office有一些软件不在套间里，如visio，如果你平时用，也请带上

PS也带上，以及其他你喜欢的常用软件

至于其他的软件，就仁者见仁，智者见智了，除了win和office以外，lz基本都找到了开源软件或者免费软件进行替代。而且现在web技术如此发达，很多软件都已经在云端了。

CS专业：

我再补充一些CS专业的软件。

VS可以在dreamspark下载免费的学生版，（本人第一次用正版……），不用带

Eclipse是开源的，不用带。（这个用的最多）

其它大小IDE，多为开源或者免费的，所以都不用带。

matlab，我们学校工学院可以有免费的license，如果你们学校没有，请果断带上

数据库的话，大多用的是mysql或者oracle的免费产品，MS的SQL同样在dreamspark免费下载。

如果你做front-end的东西，最好带DW fireworks什么的

Java中树的遍历——菜鸟学数据结构（五）

Sat, 18 Feb 2012 01:54:51 +0000

上次分享了二叉树的数据结构，这次楠哥专门拿出一节来分析二叉树的遍历（Traverse）问题。事实上，二叉树的搜索（Search）问题和遍历问题非常相似，不同的是遍历问题会访问树的每一个节点，而搜索问题一旦找到了所需要的结点就停止操作了。搜索问题楠哥会在后续算法相关的文章当中详解，本次主要分析最常用的两种遍历方法。(楠哥计算机学习网www.liubonan.com)

深度优先遍历（Depth First）是指对于一颗树，首先访问其左节点，后访问右节点，再访问其根节点；对于节点本身是子树的情况，则按此规则继续深入，直到叶节点位置。这种方法有两种实现的思路。第一种是使用递归（Recursion）的方式，即如果该节点不是叶节点则访问其左子树、右子树，在访问节点本身；另外一种思路是递推（Iteration）的方式，这里需要定义一个栈（Stack），即LIFO队列，如果栈顶结点不是叶节点，就将其左右子树压入栈；循环的从栈顶取结点，再按此规则进行处理。栈的实现Java已经给出，当然也可以使用自定义的类型，具体方式详见《Java中栈的实现》。

广度优先遍历（Breadth First）是指对一棵树，首先访问第一层的结点，在访问第二层的结点，依次类推。这里我们需要用一个FIFO队列（Queue）来实现：将每一个结点的所有子结点加入到队列中，再从队列中选取队首元素出队，依次规则进行循环直到所有结点全部出队。队列的实现Java同样也有现成的类，如果想自定义该数据结构，可以参考《Java中队列的实现》。(楠哥计算机学习网www.liubonan.com)

下面的代码实现了两种深度优先遍历方式和一种广度优先遍历方式，因为树的具体代码已经在上次文章中给出，本文只列出遍历函数的代码。全部代码详见《Java中的二叉树》。(楠哥计算机学习网www.liubonan.com)

public void dfs_re(Node current)
	{
		if((current.getLeft() == null)&amp;amp;&amp;amp;(current.getRight() == null))
			System.out.print(current.getData() + &quot; &quot;);
		else
		{
			if(current.getLeft() != null)
				dfs_re(current.getLeft());

			if(current.getRight() != null)
				dfs_re(current.getRight());

			System.out.print(current.getData() + &quot; &quot;);
		}
	}

	public void bfs()
	{
		Queue q = new LinkedList();

		q.add(root);

		while(!q.isEmpty())
		{
			Node temp = q.remove();
			if(temp.getLeft()!=null)
				q.add(temp.getLeft());
			if(temp.getRight()!=null)
				q.add(temp.getRight());
			System.out.print(temp.getData() + &quot; &quot;);
		}

	}

	public void dfs_it()
	{
		Stack s = new Stack();

		s.push(root);

		while(!s.isEmpty())
		{
			Node temp = s.pop();

			if(((temp.getLeft() == null)&amp;amp;&amp;amp;(temp.getRight() == null)) || (temp.isVisited()))
				System.out.print(temp.getData() + &quot; &quot;);
			else
			{

				if(temp.getRight() == null)
				{
					Node left = temp.getLeft();
					temp.setVisited(true);

					s.push(temp);
					s.push(left);

				}
				else
				{
					if(temp.getLeft() == null)
					{
						Node right = temp.getRight();
						temp.setVisited(true);

						s.push(temp);
						s.push(right);
					}
					else
					{
						Node left = temp.getLeft();
						Node right = temp.getRight();
						temp.setVisited(true);
						s.push(temp);
						s.push(right);
						s.push(left);
					}
				}
			}
		}

	}

Java中的二叉树——菜鸟学数据结构（四）

Wed, 15 Feb 2012 23:52:12 +0000

今天楠哥和大家一起来讨论一下Java当中二叉树的实现。树是一种高级数据结构，但是却十分常用，稍微复杂的问题就会涉及到树的应用。本文先就树（Tree）的最简单形式——二叉树进行一些简单的分析。顾名思义，二叉树（Binary Tree）即为每个节点至多只有两个子结点（Child Node）的树，因为子结点的个数具有一个固定的范围，所以就可以用顺序存储的办法进行存储。第i个结点的左右子结点分别储存于2i和2i+1的位置。顺序存储的实现可参见本系列文章之《Java链表——菜鸟学数据结构（一）》（http://www.liubonan.com/articles/349.html）。（楠哥计算机学习网www.liubonan.com）

但是由于并不是每个二叉树结点都一定有子结点，这样就会浪费很大的存储空间。为此，我们可以使用非顺序存储的方式，本文也就这种方式进行详细的介绍。使用非顺序存储所使用的结点可以使用三种设计方式，分别是单指向、双指向和三指向式。单指向式的结点中有一个指向其父节点的属性，但是这样的方式会造成从根到叶节点无法顺利的进行遍历。另外一种方法是双指向式，每个节点指向其左右子结点（没有则为NULL），本文基于这种设计实现。另外一种三指向式包含了前两种的特点，但是只有特定问题才使用这种设计，所以在此不作阐述。（楠哥计算机学习网www.liubonan.com）

下面的代码当中实现了一个二叉排序树，每个节点的左节点或左子树的值都小于其本身，而其右节点或右子树的值都大于其本身，该算法将在后面详解，此例的重点在于描述二叉树的数据结构。下文中，将详细介绍该树的各种遍历方法。（楠哥计算机学习网www.liubonan.com）

package ds;
//楠哥计算机学习网www.liubonan.com
public class Node {

	private int data;
	private int depth;
	private boolean visited;

	private Node left, right;

	public Node(int data)
	{
		this.setData(data);
		this.setLeft(null);
		this.setRight(null);
		this.setVisited(false);
	}

	public Node getLeft() {
		return left;
	}

	public void setLeft(Node left) {
		this.left = left;
	}

	public Node getRight() {
		return right;
	}

	public void setRight(Node right) {
		this.right = right;
	}

	public int getData() {
		return data;
	}

	public void setData(int data) {
		this.data = data;
	}

	public int getDepth() {
		return depth;
	}

	public void setDepth(int depth) {
		this.depth = depth;
	}

	public boolean isVisited() {
		return visited;
	}

	public void setVisited(boolean visited) {
		this.visited = visited;
	}
}

package ds;

import java.util.LinkedList;
import java.util.Queue;
import java.util.Stack;
//楠哥计算机学习网www.liubonan.com
public class BinaryTree {

	private Node root;

	public BinaryTree(int data)
	{
		Node temp = new Node(data);
		setRoot(temp);
	}

	public Node getRoot() {
		return root;
	}

	public void setRoot(Node root) {
		this.root = root;
	}
	//楠哥计算机学习网www.liubonan.com
	public void add_it(int data)
	{
		Node current = root;
		Node prev=null;
		boolean childflag = false;

		while(current != null)
		{
			prev = current;

			if(data  q = new LinkedList();

		q.add(root);

		while(!q.isEmpty())
		{
			Node temp = q.remove();
			if(temp.getLeft()!=null)
				q.add(temp.getLeft());
			if(temp.getRight()!=null)
				q.add(temp.getRight());
			System.out.print(temp.getData() + &quot; &quot;);
		}

	}
	//楠哥计算机学习网www.liubonan.com
	public void dfs_it()
	{
		Stack s = new Stack();

		s.push(root);

		while(!s.isEmpty())
		{
			Node temp = s.pop();

			if(((temp.getLeft() == null)&amp;amp;&amp;amp;(temp.getRight() == null)) || (temp.isVisited()))
				System.out.print(temp.getData() + &quot; &quot;);
			else
			{

				if(temp.getRight() == null)
				{
					Node left = temp.getLeft();
					temp.setVisited(true);

					s.push(temp);
					s.push(left);

				}
				else
				{
					if(temp.getLeft() == null)
					{
						Node right = temp.getRight();
						temp.setVisited(true);

						s.push(temp);
						s.push(right);
					}
					else
					{
						Node left = temp.getLeft();
						Node right = temp.getRight();
						temp.setVisited(true);
						s.push(temp);
						s.push(right);
						s.push(left);
					}
				}
			}
		}

	}

}

package ds;
//楠哥计算机学习网www.liubonan.com
public class Tester {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		BinaryTree t = new BinaryTree(5);

		t.add_re(6,t.getRoot());
		t.add_re(7,t.getRoot());
		t.add_re(2,t.getRoot());
		t.add_re(3,t.getRoot());
		t.add_re(1,t.getRoot());

		t.add_it(8);
		t.add_it(10);
		t.add_it(4);
		t.add_it(9);

		t.dfs_re(t.getRoot());

		System.out.println();
		t.dfs_it();

		System.out.println();
		t.bfs();
	}

}

Java中队列的实现——菜鸟学数据结构（三）

Tue, 14 Feb 2012 00:40:37 +0000

上次文章说到Java中栈的实现，这次楠哥和大家一起学习Java中队列的实现。事实上，队列（Queue）这种数据结构其实和linklist十分的相似，只是在linklist当中可以直接的获取每一个结点的值，而queue只能从一端获取。严格意义上说，队列有很多种，如FIFO队列（先进先出）、LIFO队列（后进先出）和Priority队列（优先级队列）。通常所说的队列即为FIFO队列，而栈其实就是LIFO队列。对于Priority队列，因为涉及到排序算法，将在本系列文章的后面进行分析。(楠哥计算机学习网www.liubonan.com)

Java有已经写好的Queue类，通常编程当中可以直接使用，本文为了深入分析数据结构的细节，所以自己定义这样一个类。在Java中实现队列，和linklist方法基本一致。Queue类中需要定义两个成员属性header和tail，用于记录队首元素和队尾元素。事实上，可以不记录tail，但是这样的话，会耗费很多的时间用于寻找队尾，对于push操作十分的不合算。Pop，Push和Peek操作与栈的实现基本相似，因为前文中使用char作为数据类型，本次使用int型给出样例代码。(楠哥计算机学习网www.liubonan.com)

package ds;
//楠哥计算机学习网www.liubonan.com
public class Node {

	private char data;
	private Node next;

	public Node (char data)
	{
		this.setData(data);
		this.setNext(null);
	}

	public char getData() {
		return data;
	}
	public void setData(char data) {
		this.data = data;
	}
	public Node getNext() {
		return next;
	}
	public void setNext(Node next) {
		this.next = next;
	}
}

//楠哥计算机学习网www.liubonan.com
public class Queue {

	private Node head,tail;

	public Queue (){}

	public void init(char data)
	{
		head = new Node(data);
		tail = head;
	}

	public void push(char data)
	{
		Node temp = new Node(data);
		tail.setNext(temp);
		tail = tail.getNext();
	}

	public char pop()
	{
		Node temp = head;
		head = head.getNext();
		return temp.getData();
	}
        //楠哥计算机学习网www.liubonan.com
	public char peek()
	{
		return head.getData();
	}

	public boolean empty()
	{
		if(head == null)
			return true;
		else
			return false;
	}

}

package ds;
//楠哥计算机学习网www.liubonan.com
public class Tester {

	public static void main(String[] args)
	{
		Queue q= new Queue();
		String test = &quot;abcdefghijklmn&quot;;

		q.init(test.charAt(0));	

		for(int i = 1; i &amp;lt; test.length(); i++)
			q.push(test.charAt(i));

		while(!q.empty())
		{
			System.out.print(q.peek()+&quot; &quot;);
			System.out.print(q.pop() + &quot; &quot;);
		}
	}
}

用Lisp解决简单的模式匹配(Pattern Match)问题

Sat, 11 Feb 2012 23:31:57 +0000

Lisp是人工智能中比较常用的语言之一，本文以一个经典的模式匹配(Pattern Match)问题为例，简要分析一下Lisp的语言结构。(楠哥计算机学习网www.liubonan.info)

Lisp的语言结构非常简单，有些牛人甚至称“学会七种操作即掌握了lisp的精髓”。Lisp有一篇开山之作《The roots of lisp》，现在已经译为了中文，参看此文，即可大体上掌握Lisp中最精华的内容。(楠哥计算机学习网www.liubonan.info)

一个AI中的经典问题——模式匹配(Pattern Match)是这样的，对于一个模式，可以找到与之相符合的内容，并将变量的部分形成匹配的序列进行返回。使用Lisp来描述就是用一些特定的符号如“=x”来匹配一些常量的值，如33（数字）、dog（字符串、符号）等。(楠哥计算机学习网www.liubonan.info)

使用Lisp解决这类问题的基本思路是将读入的内容看做一个list，依次取出list当中的各个元素，按照事先设定好的逻辑判断其是否为变量（即“=x"的形式），如果是，则寻找实力当中对应部分是否与之匹配，如匹配则将其加入到“匹配表”当中。当然，判断之前需要先判断一个变量是否已经匹配了其它的元素。(楠哥计算机学习网www.liubonan.info)

在下面的代码中，matcher方法不仅可以匹配=x的变量，还可以完成>x， <x，!x等形式，另外可以完成匹配条件的逻辑“并”操作（操作符为&）。可以通过调用（match （object =x =y）（object ‘3 ‘high））进行匹配，程序将返回（（x 3）（y high））的匹配表。该程序还可以将变量与list匹配，如=x可以匹配’（a b）。(楠哥计算机学习网www.liubonan.info)

程序的核心代码如下。代码的完全版可以在楠哥的个人简历站中course目录下载。(楠哥计算机学习网www.liubonan.info)

;This is main function.
(defun matcher(pattern fact)
 (if (and (atom pattern) (atom fact))
  (cond ((and (not (eq (atom-first-eq pattern) NIL)) (atom-eq-match pattern fact)) (atom-eq-match pattern fact))
           ((atom-first-not pattern) (atom-not-match pattern fact))
           ((atom-first-large pattern) (atom-large-match pattern fact))
           ((atom-first-small pattern) (atom-small-match pattern fact))
           ((eq pattern fact) T)
           (T NIL)
  )
  (if (or (atom pattern) (atom fact))
   (if (and (atom fact) (eq (car pattern) '&amp;))
    (match-and (cdr pattern) fact)
    (if (atom pattern)
     (if (atom-first-eq pattern)
      (list-match-eq pattern fact)
      (if (atom-first-not pattern)
       (list-match-not pattern fact)
       NIL
      )
     )
    )
   )
   (cond ((not (matcher (car pattern) (car fact))) NIL)
	 ((not (matcher (cdr pattern) (cdr fact))) NIL)
	 (T T)
   )
  )
 )
)
&lt;/pre&gt;

&lt;pre lang=&quot;lisp&quot; line=&quot;1&quot;&gt;
(setq bindings '()) ;This is a global variable. It is to save bindings' list.

(defun atom-first-cut (varatom) ; Get the first char of the atom.
 (setq temp (read-from-string (subseq (prin1-to-string varatom) 1)))
 temp
)

(defun test-binds (value pair) ; Compare the value and the first part of one item in the bindings list.
 (if (eq (atom-first-cut (car pair)) value)
 (car (cdr pair))
  NIL
 )
) 

(defun search-bindings (value queue) ; Search bindings list with &quot;value&quot; as the index.
 (if (null queue)
  NIL
  (if (eq (test-binds value (car queue)) NIL)
   (search-bindings value (cdr queue))
   (test-binds value (car queue))
  )
 )
)

;This is &quot;=&quot; code.
(defun atom-first-eq (varatom)
 (if (equal (subseq (prin1-to-string varatom) 0 1) &quot;=&quot;)
  T
  NIL
 )
)

(defun atom-eq-match (atom-pattern atom-fact)
 (if (not (search-bindings (atom-first-cut atom-pattern) bindings))
  (setq bindings (append bindings (list (list atom-pattern atom-fact))))
  (if (equal atom-fact (search-bindings (atom-first-cut atom-pattern) bindings))
   T
   NIL
  )
)
)

Java中栈的实现——菜鸟学数据结构（二）

Fri, 10 Feb 2012 04:09:56 +0000

栈（stack）和队列（queue）是一种最基本、最常用的数据结构。今天我们用Java来实现栈的最基本的功能。栈（stack）的基本操作包括压栈（push）、出栈（pop）和查看栈顶元素（peek）。还经常用到的操作包括获取栈的大小（元素个数）、判断是否为空等此文当中略去，可以通过检测peek（）获取的元素是否为空进行实现。（楠哥计算机学习网www.liubonan.com ）

栈的特点是后进先出，因此我们只用一个元素top记录栈顶元素的引用即可。push（）操作通过将栈顶的标示移往新填入的元素实现，peek（）通过返回top的数据实现，pop（）通过将栈顶标示向反方向移动并返回原来的top元素实现。请注意，因为栈当中的标示操作存在向反方向移动，所以Node的定义当中，使用了previous来记录前一个结点的引用，这与linklist稍有不同。本文采用int型作为数据，源码如下。（楠哥计算机学习网www.liubonan.com ）

package ds;

public class Node {
	private int data;
	private Node previous;
	
	public Node(){}
	
	public int getData() {
		return data;
	}
	public void setData(int data) {
		this.data = data;
	}
	public Node getPrevious() {
		return previous;
	}
	public void setPrevious(Node previous) {
		this.previous = previous;
	}
	
}

package ds;

public class Stack {
	private Node top;
	
	public Stack(int data)
	{
		top = new Node();
		top.setData(data);
		top.setPrevious(null);
	}
	
	public void push(int data)
	{
		Node temp = new Node();
		temp.setData(data);
		temp.setPrevious(top);
		top = temp;
	}
	
	public boolean empty()
	{
		if(top == null)
			return true;
		else
			return false;
	}
	
	public int pop()
	{
		int temp = top.getData();
		top = top.getPrevious();
		
		return temp;
	}
	
	public int peek(){
		return top.getData();
	}
	
}

package ds;

public class Tester {
	
	static public void main(String[] args)
	{
		Stack s = new Stack(0);
		
		for(int i=1;i&lt;=10;i++)
			s.push(i);
		
		while(!s.empty())
			System.out.print(s.pop()+&quot; &quot;);
	}

}

Java链表——菜鸟学数据结构（一）

Wed, 08 Feb 2012 06:42:40 +0000

数据结构一方面是专业程序员必须熟练掌握的基础知识，另一方面也是非专业人员比较头痛的内容。从本篇文章开始，楠哥将开始连载数据结构的入门知识。本篇为大家介绍Java实现链表。

因为在Java当中，所有的元素都是对象，而且Java抛弃了指针和地址，而使用了引用的方法，所以使用Java构成链表相对简单。链表的好处在于，你可以事先不知道一个数组的大小，而是动态的加载数据，分配空间，从而确保程序的健壮性和效率。Java已经实现了标准的List、ArrayList等，为了更好的阐述链表的结构，下面我们动手写一下自己的链表类。

Java链表的实现首先需要自定义节点类Node，其中包括数据成员和下一个数据成员的引用。在楠哥的代码中，为了方便，就把数据成员定义成了int类型。链表类的成员属性事实上只需要一个头结点header即可，但是为了增加在成员较多情况下的程序的链表的效率，加入tail节点可以更方便的进行操作。如下是链表的样例代码。

package ds;

public class Node {
	
	private Node next=null;
	private int data=0;
	
	public Node(){}

	public int getData() {
		return data;
	}

	public void setData(int data) {
		this.data = data;
	}

	public Node getNext() {
		return next;
	}

	public void setNext(Node next) {
		this.next = next;
	}

	

}

package ds;

public class Linklist {
	
	private Node header=null;
	private Node tail=null;
	
	public Linklist(){}
	
	public void add(int data)
	{
		if(header==null)
		{
			Node newnode = new Node();
			newnode.setData(data);
			newnode.setNext(null);
			header=newnode;
			tail = newnode;
		}
		else
		{
			Node newnode = new Node();
			newnode.setData(data);
			newnode.setNext(null);
			tail.setNext(newnode);
			tail = tail.getNext();
		}		
		
	}
	
	public int getdata(int index)
	{
		Node temp=header;
		for(int i=0;i&lt;index;i++)
		{
			temp= temp.getNext();
		}
		return temp.getData();
	}
	
	public void deletehead()
	{
		header = header.getNext();
	}
	
	public void deletetail()
	{
		Node temp = header;
		while(temp.getNext() != tail)
			temp=temp.getNext();
		tail=temp;
		tail.setNext(null);		
	}
	
	public void delete(int data)
	{
		Node temp=header;
		while(temp.getNext().getData() != data)
			temp=temp.getNext();
		temp.setNext(temp.getNext().getNext());
	}

}

package ds;

public class Tester {

	
	public static void main(String[] args) {
		
		Linklist l = new Linklist();
		for(int i=0;i&lt;10;i++)
			l.add(i);
		
		for(int i=0;i&lt;10;i++)
			System.out.print(l.getdata(i)+&quot; &quot;);
		
		System.out.println();
		System.out.println(l.getdata(5));
		
		l.deletehead();
		for(int i=0;i&lt;9;i++)
			System.out.print(l.getdata(i)+&quot; &quot;);
		System.out.println();
		
		l.deletetail();
		for(int i=0;i&lt;8;i++)
			System.out.print(l.getdata(i)+&quot; &quot;);
		System.out.println();
		
		l.delete(3);
		for(int i=0;i&lt;7;i++)
			System.out.print(l.getdata(i)+&quot; &quot;);
	}

}

哥大在校生所了解到的哥大的CS【楠哥原创】

Tue, 17 Jan 2012 23:01:11 +0000