面试遇到的算法题

1、单链表倒序

　　定义链表节点Node

public class Node {
    private int index;
    public Node next;

    public Node(NodeBuilder builder) {
        this.index = builder.getIndex();
        this.next = builder.getNext();
    }

    public static NodeBuilder newBuilder() {
        return new NodeBuilder();
    }

}

　　Node建造器

public class NodeBuilder {

    private int index;
    private Node next;

    public int getIndex() {
        return index;
    }

    public NodeBuilder setIndex(int index) {
        this.index = index;
        return this;
    }

    public Node getNext() {
        return next;
    }

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

    public Node builder(){
        return new Node(this);
    }
}

反转链表节点算法

public class ReverseLinkedlist {

    /**
     * 反转单链表 1->2->3->4->null 转成  4->3->2->1->null
     *
     * @param node
     * @return
     */
    static Node reverse(Node node) {
        // 当前节点的前一个节点
        Node pre = null;
        // 保存剩下的链表
        Node next = null;
        while (node != null) {
            next = node.next;
            node.next = pre; // 第一次将1->null,接着2->1->null,3->2->1->null,4->3->2->1->null
            pre = node;
            node = next;
        }
        return pre;
    }


    public static void main(String[] args) {
        Node node4 = Node.newBuilder().setNext(null).setIndex(4).builder();
        Node node3 = Node.newBuilder().setNext(node4).setIndex(3).builder();
        Node node2 = Node.newBuilder().setNext(node3).setIndex(2).builder();
        Node node = Node.newBuilder().setNext(node2).setIndex(1).builder();
        Node newNode = reverse(node);

    }
}

2、二叉树遍历

public class TreeTraversal {
    /**
     * 前序遍历,根左右
     */
    public static void preTraversalTree(TreeNode node) {
        if (node == null) {
            return;
        }
        System.out.println(node.data);
        preTraversalTree(node.leftChild);// 左子节点不断入栈，直到没有左子节点，再挨个输出结果
        preTraversalTree(node.rightChild);
    }

    /**
     * 中序遍历，左根右
     * @param node
     */
    public static void midTraversalTree(TreeNode node) {
        if (node == null) {
            return;
        }
        midTraversalTree(node.leftChild);
        System.out.println(node.data);
        midTraversalTree(node.rightChild);
    }

    /**
     * 后序遍历，左右根
     * @param node
     */
    public static void finTraversalTree(TreeNode node) {
        if (node == null) {
            return;
        }
        finTraversalTree(node.leftChild);
        finTraversalTree(node.rightChild);
        System.out.println(node.data);
    }

    /**
     * 树节点
     */
    static class TreeNode {
        int data;
        TreeNode leftChild;
        TreeNode rightChild;
    }
}

 其实递归的双次调用就是等前一个全部入栈后，每一次出栈，再调用后一个入栈。