阿里巴巴集团2015年秋季校招在线笔试附加题分析

   刚做完，选择题做吐血，好多智力题。。。。附加题有两道编程题。题面是回忆的内容。

1、在text中查找子串quary，返回符合匹配的quary中连续的最大的子串长度，例如 quary = "acbac"，text = "acaccbabb"，quary 中 "cba"是最大的连续子串，返回3。

【分析】 两重循环获得quary的所有连续子串，使用KMP算法在text 查找匹配，如果匹配，则记录子串长度，最后返回最大的子串长度。

代码如下，编译通过

/**
 * 创建时间：2014年8月29日 下午9:31:02 项目名称：Test
 * 
 * @author 曹艳丰  北京大学
 * @since JDK 1.6.0_21 类说明： 编译通过
 */

public class FindMaxMathch {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		String quary = "acbac";
		String text = "acaccbabb";
		int maxQuary = findMaxMatch(quary, text);
		System.out.println(maxQuary);
	}

	/* 寻找最大的连续匹配字符串的匹配算法 */
	public static int findMaxMatch(String quary, String text) {
		int diff = -1;
		int maxDiff = Integer.MIN_VALUE;
		char[] quaryChar = quary.toCharArray();
		char[] textChar = text.toCharArray();
		for (int i = 0; i < quaryChar.length; i++) {
			for (int j = quaryChar.length - 1; j >= i; j--) {
				diff = j - i + 1;
				/* 获取quary连续的子字符串，并初始化 */
				char[] subQuaryChar = new char[diff];
				for (int k = 0; k < subQuaryChar.length; k++) {
					subQuaryChar[k] = quaryChar[i + k];
				}
				int position = getKMPMatchPosition(textChar, subQuaryChar);
				if (position != -1 && diff > maxDiff) {
					maxDiff = diff;
				}

			}
		}
		return maxDiff;

	}
	/* KMP字符匹配算法 */
	public static int getKMPMatchPosition(char[] array, char[] subArray) {
		if (array.length < subArray.length) {
			return -1;
		}

		int i = 0, j = 0;
		int[] next = getNextArray(subArray);
		while (i < array.length) {
			if (j == -1 || array[i] == subArray[j]) {
				i++;
				j++;
			} else {
				j = next[j];

			}
			if (j == subArray.length) {
				return i - subArray.length;
			}
		}
		return -1;

	}

	/* 求int[] next数组 */
	public static int[] getNextArray(char[] array) {
		int j = 0;
		int k = -1;
		int[] next = new int[array.length];
		next[0] = -1;
		while (j < array.length - 1) {
			if (k == -1 || array[j] == array[k]) {
				next[++j] = ++k;
			} else {
				k = next[k];

			}
		}
		return next;
	}

}

2、二叉树每个节点存储有int类型数据，节点与节点之间的数据差的绝对值为maxAbs，高效得到求出整棵数中的最大的maxAbs。

【分析】前序遍历（或者后续、中序、层次遍历，whatever）二叉树，获得最大值和最小值，返回差值即可。这里遍历没有用递归的方式，而是用了辅助stack的方式。

代码如下，编译通过。

节点类：

/**
 * @author 曹艳丰  北京大学 
 *
 */
public class BinaryTreeNode<T> {
	private BinaryTreeNode<T> leftChild,rightChild;
	private T data;
	public BinaryTreeNode() {
		// TODO 自动生成的构造函数存根
		leftChild=rightChild=null;
	}
	public BinaryTreeNode(T data) {
		// TODO 自动生成的构造函数存根
		leftChild=rightChild=null;
		this.data=data;
	}
	
	public T getData() {
		return data;
	}
	public BinaryTreeNode<T> getLeftChild() {
		return leftChild;
	}
	public BinaryTreeNode<T> getRightChild() {
		return rightChild;
	}
	public void setLeftChild(BinaryTreeNode<T> leftChild) {
		this.leftChild = leftChild;
	}
	public void setRightChild(BinaryTreeNode<T> rightChild) {
		this.rightChild = rightChild;
	}
}

方法主体如下：

/**
 * 创建时间：2014年8月29日 下午7:46:07 项目名称：Test
 * 
 * @author 曹艳丰  北京大学
 * @since JDK 1.6.0_21 类说明： 找到二叉树中最大的绝对值。
 */

public class Test {
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		BinaryTreeNode<Integer> root = new BinaryTreeNode<Integer>(1);
		BinaryTreeNode<Integer> a = new BinaryTreeNode<Integer>(2);
		BinaryTreeNode<Integer> b = new BinaryTreeNode<Integer>(20);
		root.setLeftChild(a);
		root.setRightChild(b);
		int maxAbs = preOrderUsingStack(root);
		System.out.println(maxAbs);

	}

	/* 较简单——使用1个辅助stack方式进行前序遍历，记录最大值和最小值 */
	private static int preOrderUsingStack(BinaryTreeNode<Integer> root) {
		int maxValue = Integer.MIN_VALUE;
		int minValue = Integer.MAX_VALUE;
		BinaryTreeNode<Integer> temp = root;
		Stack<BinaryTreeNode<Integer>> stack = new Stack<>();
		while (!stack.isEmpty() || temp != null) {
			if (temp != null) {
				if (temp.getData() < minValue) {
					minValue = temp.getData();
				} else if (temp.getData() > maxValue) {
					maxValue = temp.getData();
				}
				stack.push(temp);
				temp = temp.getLeftChild();
			} else {
				temp = stack.pop();
				temp = temp.getRightChild();
			}
		}
		return maxValue - minValue;
	}

}