链表 二叉树

链表

class Node {
    object value; // 数据域
    Node next; // 指针域
​
    public Node (Object value,Node next) {
        this.value = value;
        this.next = next;
    }
}
​
class Link {
​
    private Node head; // 指向头结点对象
    private Node tail; // 指向尾结点对象
    private int size;
​
    public void add(object val) {
        Node newNode = new Node(val,null);
        newNode.value = val; // 让结点对象携带数据
        if (head == null) { // 链表为空
            head = newNode;// 第一个结点当仁不让, 既作头,又作尾
            tail = newNode;// 第一个结点当仁不让, 既作头,又作尾
        } else {
            tail.next = newNode; // 让老尾结点指向最新结点对象
            tail = newNode; // 刷新尾引用, 让它再次指向最新的结点.
        }
        size++;
    }
​
    public void travel() {
        Node tmp = head;
        while (tmp != null) {
            System.out.println(tmp.value);
            tmp = tmp.next; // 刷新tmp,让它又指向了原来的下一个结点
        }
    }
    
    /**
     *递归方法，遍历链表，分解成只打印头的数据和把头的下一个又作为新头的子链表递归处理，
     *直到链表为空为止
     *@paramtmpHead,以它为头的链表
     */
    private void view (Node tmpHead) {
        if (tmpHead == null) {
            return;
        }
        System.out.println(tmpHead.value);
        view(tmpHead.next);
    }
    
    public void Travel2 () {
        view(head);
    }
​
    /**
     * 删除某个元素
     * @param val
     * @return 成功或失败
     */
    public boolean remove(object val) {
        if (head == null) {
            return false;
        }
        if (head.value.eaquals(val)) {//单独判断头的情况
            head = head.next;
            size--;
            return true;
        }
        Node prev = head;
        while (prev.next != null) {
            if (prev.next.value.equals(val) { // prev.next的数值==参数, 目标是prev.next
                // 删除目标是prev.next
                if (prev.next = tail) {//如果删除的目标是尾
                    tail = prev;//刷新尾引用
                }
                prev.next = prev.next.next;//把目标的下一个地址赋值给上一个的next
                size--;//调整计数器
                return true;
            }
            prev = prev.next;//让prev向后移动
        }
        return false;
    }
​
    /**
     * 返回 元素个数
     * @return
     */
    public int size() {
        /*
        Note tmp = head;
        int size = 0;
        while (tmp != null) {
            size++;
            tmp = tmp.next;
        }
        */
        return size;
    }
​
}
​
public class FunnyTest {
​
    public static void main(String[] args) {
        Link link = new Link();
        link.add(9);
        link.add(2);
        link.add(1);
        link.add(30);
        link.add(20);
        link.add(15);
        link.add(8);
        link.add(2);
​
        link.travel();
​
        link.remove(20);
        
        while (link.remove("zz"));//把所有相同的值的元素删除了
    }
}
​

 

 

 

二叉树

class TreeNode {
    int value;
    // 2个指针, 一个是左子(比我小), 另一个是右子(比我大)
    TreeNode left;
    TreeNode right;
}
​
class Tree {
​
    private TreeNode root;
​
    /**
     * 向目标结点tmpRoot插入新结点
     * @param tmpRoot, 目标子树
     * @param newNode 新结点
     */
    private void insert(TreeNode tmpRoot, TreeNode newNode) {
        if (tmpRoot == null) {
            return;
        }
        if (newNode.value < tmpRoot.value) { // 向左走
            if (tmpRoot.left == null) { // 目标左子是空, 这是最好的情况
                tmpRoot.left = newNode;
            } else { // 左子非空, 把左子作为临时根再递归插入
                insert(tmpRoot.left, newNode);
            }
        } else { // 向右走
            if (tmpRoot.right == null) { // 目标右子是空, 也是最好的情况
                tmpRoot.right = newNode;
            } else { // 右子非空, 递归插入
                insert(tmpRoot.right, newNode);
            }
        }
    }
​
    public void add(int val) {
        TreeNode newNode = new TreeNode();
        newNode.value = val; // 携带数据
        if (root == null) { // 树为空
            root = newNode; // 第一个新结点直接作为根
        } else { // 树是非空的.
            insert(root, newNode);
        }
​
    }
​
    private void view(TreeNode tmpRoot) {
        // 左中右
        if (tmpRoot.left != null) {
            view(tmpRoot.left);
        }
        System.out.println(tmpRoot.value);
        if (tmpRoot.right != null) {
            view(tmpRoot.right);
        }
    }
​
    public void travel() {
        view(root);
    }
}
​
public class TreeTest {
​
    public static void main(String[] args) {
        Tree tree = new Tree();
        tree.add(10);
        tree.add(5);
        tree.add(30);
        tree.add(20);
        tree.add(7);
        tree.add(9);
        tree.add(1);
        tree.add(8);
        tree.add(40);
        tree.add(25);
​
        tree.travel();
​
    }
}