几个笔试题目总结

1、阿里某个笔试题，两个字符串text，query，找到text中包含的最长的query的字串：

public static String subStr(String text, String query) {
        if (text != null && query != null) {
            int length = query.length();
            for (int i = 0; i < length; i++) {
                for (int j = 0; j <= i; j++) {
                    String sub = query.substring(j, length - i + j);
                    if (text.contains(sub)) {
                        return sub;
                    }
                }
            }
        }
        return null;
    }

2、阿里某笔试题：找到一个二叉树中最大最小值对应节点的差值的绝对值，也就是节点所在层的差值，并不是本身数值的差值：

package mystudy;

import java.io.UnsupportedEncodingException;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Stack;

public class Tree {

    private TreeNode root;

    public Tree() {

    };

    public Tree(TreeNode root) {
        this.root = root;
    }

    public void initTree() {
        root = new TreeNode(8);
        root.setLeft(new TreeNode(5));
        root.getLeft().setLeft(new TreeNode(7));
        root.getLeft().setRight(new TreeNode(4));
        root.setRight(new TreeNode(9));
        root.getRight().setRight(new TreeNode(6));
        root.getRight().setLeft(new TreeNode(10));
    }

    public void preOrderTraverse() {
        preOrderTraverse(root);
    }

    public void preOrderTraverse(TreeNode node) {
        if (node != null) {
            System.out.println(node.getValue());
            preOrderTraverse(node.getLeft());
            preOrderTraverse(node.getRight());
        }
    }

    public void nPreOrderTraverse() {
        Stack<TreeNode> stack = new Stack<TreeNode>();
        TreeNode node = root;
        while (node != null || !stack.isEmpty()) {
            while (node != null) {
                System.out.println(node.getValue());
                stack.push(node);
                node = node.getLeft();
            }
            if (!stack.isEmpty()) {
                node = stack.pop();
                node = node.getRight();
            }
        }
    }

    public void inOrderTraverse() {
        inOrderTraverse(root);
    }

    public void inOrderTraverse(TreeNode node) {
        if (node != null) {
            inOrderTraverse(node.getLeft());
            System.out.println(node.getValue());
            inOrderTraverse(node.getRight());
        }
    }

    public void nInOrderTraverse() {
        Stack<TreeNode> stack = new Stack<TreeNode>();
        TreeNode node = root;
        while (node != null || !stack.isEmpty()) {
            while (node != null) {
                stack.push(node);
                node = node.getLeft();
            }
            if (!stack.isEmpty()) {
                node = stack.pop();
                System.out.println(node.getValue());
                node = node.getRight();
            }
        }
    }

    public void postOrderTraverse() {
        postOrderTraverse(root);
    }

    public void postOrderTraverse(TreeNode node) {
        if (node != null) {
            postOrderTraverse(node.getLeft());
            postOrderTraverse(node.getRight());
            System.out.println(node.getValue());
        }
    }

    public void nPostOrderTraverse() {
        Stack<TreeNode> stack = new Stack<TreeNode>();
        TreeNode node = root;
        TreeNode preNode = null;
        while (node != null || !stack.isEmpty()) {
            while (node != null) {
                stack.push(node);
                node = node.getLeft();
            }
            if (!stack.isEmpty()) {
                node = stack.peek();
                if (node.getRight() == null || node.getRight() == preNode) {
                    node = stack.pop();
                    System.out.println(node.getValue());
                    preNode = node;
                    node = null;
                } else {
                    node = node.getRight();
                }
            }
        }

    }

    public void levelTraverse() {
        levelTraverse(root);
    }

    public void levelTraverse(TreeNode node) {
        if (node != null) {
            Queue<TreeNode> queue = new LinkedList<TreeNode>();
            queue.offer(node);
            while (!queue.isEmpty()) {
                TreeNode mNode = queue.poll();
                if (mNode != null) {
                    System.out.println(mNode.getValue());
                    if (mNode.getLeft() != null) {
                        queue.offer(mNode.getLeft());
                    }
                    if (mNode.getRight() != null) {
                        queue.offer(mNode.getRight());
                    }
                }
            }
        }
    }

    public int treeDepth() {
        return treeDepth(root);
    }

    public int treeDepth(TreeNode node) {
        if (node == null) {
            return 0;
        }
        int leftDepth = treeDepth(node.getLeft());
        int rightDepth = treeDepth(node.getRight());
        return leftDepth > rightDepth ? leftDepth + 1 : rightDepth + 1;
    }

    public int minMaxSpan() {
        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        if (root != null) {
            int visitedNum = 0, addedNum = 1, levelNum = 1, min, max, depth = 0, minLevel = 0, maxLevel = 0;
            min = max = root.getValue();
            queue.offer(root);
            while (!queue.isEmpty()) {
                TreeNode mNode = queue.poll();
                if (min > mNode.getValue()) {
                    min = mNode.getValue();
                    minLevel = depth;
                } else if (max < mNode.getValue()) {
                    max = mNode.getValue();
                    maxLevel = depth;
                }
                visitedNum++;
                if (mNode.getLeft() != null) {
                    queue.offer(mNode.getLeft());
                    addedNum++;
                }
                if (mNode.getRight() != null) {
                    queue.offer(mNode.getRight());
                    addedNum++;
                }
                if (visitedNum == levelNum) {
                    depth++;
                    levelNum = addedNum;
                }
            }
            System.out.println("min:" + min + "max:" + max + "minLevel:"
                    + minLevel + "maxLevel:" + maxLevel + "树的高度：" + depth);
            return Math.abs(minLevel - maxLevel);
        }
        return -1;
    }

    public class TreeNode {
        private TreeNode left;
        private TreeNode right;
        private int value;

        public TreeNode(TreeNode left, TreeNode right, int value) {
            this.left = left;
            this.right = right;
            this.value = value;
        }

        public TreeNode(int value) {
            this(null, null, value);
        }

        public TreeNode getLeft() {
            return left;
        }

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

        public TreeNode getRight() {
            return right;
        }

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

        public int getValue() {
            return value;
        }

        public void setValue(int value) {
            this.value = value;
        }

    }

    /**
     * @param args
     * @throws UnsupportedEncodingException
     */
    public static void main(String[] args) throws UnsupportedEncodingException {
        // TODO Auto-generated method stub
        Tree tree = new Tree();
        tree.initTree();
        System.out.println("树中最大值最小值层数之差：" + tree.minMaxSpan());
        System.out.println("前序递归：");
        tree.preOrderTraverse();
        System.out.println("前序非递归：");
        tree.nPreOrderTraverse();
        System.out.println("中序递归：");
        tree.inOrderTraverse();
        System.out.println("中序非递归：");
        tree.nInOrderTraverse();
        System.out.println("后序递归：");
        tree.postOrderTraverse();
        System.out.println("后序非递归：");
        tree.nPostOrderTraverse();
        System.out.println("按层次遍历：");
        tree.levelTraverse();
        System.out.println("树的高度：" + tree.treeDepth());
    }

}

以后不断补充。。。