1、链表

链表的数据结构

class Node<T>{
    private T data;
    private Node next;
}

1.1 单向链表反转

class Node{
	public Node next;
}

/**
 head是指向链表的指针。 head.next 为链表第一个节点
 */
public static void reverse(Node head){
    //头指针为空 或 头指针指向空 或 头指针指向一个node，该node指向空
    if(head == null){
        return;
    }
    Node node = head.next;
    //没有节点，或者只有一个节点。直接返回
    if(node == null || head.next == null){
        return;
    }

    Node pre = node, cur = node.next, next;
    pre.next = null;

    while(true){
        next = cur.next;
        cur.next = pre;
        if(next == null){
            break;
        }
        pre = cur;
        cur = next;
    }
    head.next = cur;

}

1.2 判断是否单向链表是否有环

public static boolean checkRing(Node node){

    //快指针，一次走两格
    Node fast = new Node();
    fast.next = node;

    //慢指针，一次走一格
    Node slow = new Node();
    slow.next = node;

    while (true){

        if(fast.next == null || fast.next.next == null){
            //单向链表最终指向null，说明没有环
            return false;
        }

        slow = slow.next;
        fast = fast.next.next;

        if(fast.value == slow.value){
            //快慢指针 在同一个格子，说明有环形
            return true;

        }
    }

}

1.3 计算环形单向链表的入口点

移步到此 判断单向链表是否有环及求环入口的算法数学证明

2、二叉树

class Tree<T>{
	T data;
    Tree leftChild;
    Tree rightChild;
}

      1
     /\
    2  3
   / \
  4   5

2.1 先序遍历

根左右的顺序: 1 2 4 5 3

public static void preTravel(Tree tree){

    if(tree == null){
        return;
    }

    //根
    System.out.println(tree.value);
    //左
    preTravel(tree.left);
    //右
    preTravel(tree.right);

}

2.2 中序遍历

左根右的顺序：4 2 5 1 3

public static void inTravel(Tree tree){

    if(tree == null){
        return;
    }

    //左
    inTravel(tree.left);
    //根
    System.out.println(tree.value);
    //右
    inTravel(tree.right);

}

2.3 后续遍历

左右根的顺序：4 5 2 3 1

public static void afterTravel(Tree tree){

    if(tree == null){
        return;
    }

    //左
    afterTravel(tree.left);
    //右
    afterTravel(tree.right);
    //根
    System.out.println(tree.value);

}