Interview questions encountered algorithm

1, singly linked list in reverse order

　　Defined list node 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 Builder

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);
    }
}

Reverse list node algorithm

public class ReverseLinkedlist {

    /**
     * Reverse single linked 1-> 2-> 3-> 4-> null transformed into 4-> 3-> 2-> 1-> null
     *
     * @param node
     * @Return 
     * / 
    static the Node Reverse (the Node Node) {
         // before a current node 
        the Node pre = null ;
         // store the remaining list 
        the Node Next = null ;
         the while (! Node = null ) {
            next = node.next;
            node.next = pre; // first time 1-> null, then 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, binary tree traversal

public class TreeTraversal {
    /**
     * Preorder traversal, the root of the left and right
     */
    public static void preTraversalTree(TreeNode node) {
        if (node == null) {
            return;
        }
        System.out.println(node.data);
        preTraversalTree (node.leftChild); // left child continue to push until there are no left child, then one by one output
        preTraversalTree(node.rightChild);
    }

    /**
     * In order traversal, the root of the left and right
     * @param node
     */
    public static void midTraversalTree(TreeNode node) {
        if (node == null) {
            return;
        }
        midTraversalTree (node.leftChild);
        System.out.println(node.data);
        midTraversalTree(node.rightChild);
    }

    /**
     * Postorder about root
     * @param node
     */
    public static void finTraversalTree(TreeNode node) {
        if (node == null) {
            return;
        }
        finTraversalTree(node.leftChild);
        finTraversalTree(node.rightChild);
        System.out.println(node.data);
    }

    /**
     * Tree Node
     */
    static class TreeNode {
        int data;
        TreeNode leftChild;
        TreeNode rightChild;
    }
}

 In fact, double recursive call is waiting for an entire stack before and after each time the stack, and then after a call stack.