java基础——树 双向链表 简单的java实现

双向链表是LinkedList的基础数据结构，树是准备为接下来的HashMap打下基础。就用链表的形式简单的实现了一哈 双向链表和简单的二叉树 树方面肯定是要做深度的研究，这里只是简单的标识一下

public interface Acctor<T> {
    void acctpor(T t);
}
public class LinkedArray<T> {
    private Node<T> first;
    private Node<T> last;

    private static class Node<T> {
        T t;
        Node<T> next;
        Node<T> prev;
    }
    //这里的判断 是将最后一个节点作为最新的节点 树也是这样实现的
    public void add(T t){
        Node<T> node = new Node<>();
        node.t = t;
        if(last==null){
            first=node;
        }else{
            last.next=node;
            node.prev = node;
        }
        last = node;
    }
    //这里的遍历也可以使用递归，LinkedList的遍历是先判断了index是否在长度的中位 如果在比较靠前的位置就从first节点开始位置遍历 否则就从last开始遍历
    public void foreahce(Acctor<T> tAcctor){
        for(Node<T> n = first;n!=null;n = n.next){
            tAcctor.acctpor(n.t);
        }
    }

}

这个树 应该是一颗比较假的树，但是有这个意思 就先记录一下

public class Tree<T> {
    private Node<T> root;
    private Node<T> last;
    private  static class Node<T> {
        T t;
        Integer key;
        Node<T> left;
        Node<T> right;
    }
    //这里 只能添加 我下面二叉树的那种结构 这种结构的二叉树没有什么实际上的意义 只是 这里做一个初步的二叉树
    public void add(T t){
        Node<T> node = new Node<>();
        node.t = t;
        if(last==null){
            root = node;
            last = node;
        }else{
            if(last.left==null){
                last.left=node;
            }else{
                last.right = node;
                last = node;
            }
        }
    }
    public void foreache(Acctor<T> tAcctor){
        getNode(root,tAcctor);
    }
    public void foreacheMiedle(Acctor<T> tAcctor){
        getNodeMidele(root,tAcctor);
    }
    public  void foreacheLast(Acctor<T> tAcctor){
        getNodeLast(root,tAcctor);
    }

    //先序遍历
    private  void getNode(Node<T> firstNode, Acctor<T> tAcctor){
        if(firstNode==null){
            return;
        }else{
            tAcctor.acctpor(firstNode.t);
            getNode(firstNode.left,tAcctor);
            getNode(firstNode.right,tAcctor);
        }
    }
    //中序遍历
    private  void getNodeMidele(Node<T> firstNode, Acctor<T> tAcctor){
        if(firstNode==null){
            return;
        }else{
            getNodeMidele(firstNode.left,tAcctor);
            tAcctor.acctpor(firstNode.t);
            getNodeMidele(firstNode.right,tAcctor);
        }
    }
    // 后序遍历
    private  void getNodeLast(Node<T> firstNode, Acctor<T> tAcctor){
        if(firstNode==null){
            return;
        }else{
            getNodeLast(firstNode.left,tAcctor);
            getNodeLast(firstNode.right,tAcctor);
            tAcctor.acctpor(firstNode.t);
        }
    }

}
/*
                1
            2       3
                4       5
                    6       7
                        8
    这里生成的二叉树结构就是这样的
 */
 @Test
    public void testTree(){
        Tree<String> tree = new Tree<>();
        tree.add("Test1");// root
        tree.add("Test2");//left
        tree.add("Test3");//right
        tree.add("Test4");//left
        tree.add("Test5");//right
        tree.add("Test6");//left
        tree.add("Test7");//right
        tree.add("Test8");//left
        tree.foreache(System.out::println);
        System.out.println("----------后序----------");
        tree.foreacheLast(System.out::println);
        System.out.println("----------中序----------");
        tree.foreacheMiedle(System.out::println);
    }
    
    
/*
输出的结果
Test1
Test2
Test3
Test4
Test5
Test6
Test7
Test8
----------后序----------
Test2
Test4
Test6
Test8
Test7
Test5
Test3
Test1
----------中序----------
Test2
Test1
Test4
Test3
Test6
Test5
Test8
Test7



*/