public class Main {
    public static void main(String[] args) {
        TreeNode<Character>a=new TreeNode<>('A');
        TreeNode<Character>b=new TreeNode<>('B');
        TreeNode<Character>c=new TreeNode<>('C');
        TreeNode<Character>d=new TreeNode<>('D');
        TreeNode<Character>e=new TreeNode<>('E');
 
        a.left=b;
        a.right=c;
        b.left=d;
        b.right=e;
 
        System.out.println(a.left.left.element);
    }
 
    public static class TreeNode<E>{
        public E element;
        public TreeNode<E> left,right;
 
        public TreeNode(E element){
            this.element=element;
        }
    }
}
 
//輸出D

public class Main {
    public static void main(String[] args) {
        TreeNode<Character>a=new TreeNode<>('A');
        TreeNode<Character>b=new TreeNode<>('B');
        TreeNode<Character>c=new TreeNode<>('C');
        TreeNode<Character>d=new TreeNode<>('D');
        TreeNode<Character>e=new TreeNode<>('E');
        TreeNode<Character>f=new TreeNode<>('F');
        TreeNode<Character>g=new TreeNode<>('G');
        TreeNode<Character>h=new TreeNode<>('H');

        a.left=b;
        a.right=c;
        b.left=d;
        b.right=e;
        e.left=h;
        c.left=f;
        c.right=g;

        preOrder(a);
    }

    public static void preOrder(TreeNode<Character> root){
        if(root==null)return;
        System.out.print(root.element+" ");
        preOrder(root.left);
        preOrder(root.right);
    }

    public static class TreeNode<E>{
        public E element;
        public TreeNode<E> left,right;

        public TreeNode(E element){
            this.element=element;
        }
    }
}
//輸出A B D E H C F G

public static void inOrder(TreeNode<Character>root){
        if(root==null)return;
        inOrder(root.left);
        System.out.print(root.element+" ");
        inOrder(root.right);
    }
//輸出D B H E A F C G 

    public static void postOrder(TreeNode<Character>root){
        if(root==null)return;
        postOrder(root.left);
        postOrder(root.right);
        System.out.print(root.element+" ");
    }
//輸出D H E B F G C A 

    public static void levelOrder(TreeNode<Character>root){
        LinkedQueue<TreeNode<Character>> queue=new LinkedQueue<>(); //創(chuàng)建一個(gè)隊(duì)列
        queue.offer(root); //將根結(jié)點(diǎn)丟進(jìn)隊(duì)列
        while (!queue.isEmpty()){ //如果隊(duì)列不為空，就一直不斷的取出來
            TreeNode<Character>node=queue.poll();  //取一個(gè)出來
            System.out.print(node.element+" ");  //打印
            if (node.left!=null)queue.offer(node.left);  //如果左右孩子不為空，直接將左右孩子丟進(jìn)隊(duì)列
            if (node.right!=null)queue.offer(node.right);
        }
    }
//輸出A B C D E F G H 

public class HashTable<E> {
    private final int TABLE_SIZE=10;
    private final Object[]TABLE=new Object[TABLE_SIZE];

    //插入
    public void insert(E obj){
        int index=hash(obj);
        TABLE[index]=obj;
    }

    //判斷是否包含
    public boolean contains(E obj){
        int index=hash(obj);
        return TABLE[index]==obj;
    }

    private int hash(E obj){ //哈希函數(shù)，計(jì)算出存放的位置
        int hashCode=obj.hashCode();
        //每一個(gè)對象都有一個(gè)獨(dú)一無二的哈希值，可以通過hashCode方法得到（極小概率出現(xiàn)相同情況）
        return hashCode%TABLE_SIZE;
    }
}

import com.test.collection.HashTable;

    public static void main(String[] args) {
        HashTable<String>table=new HashTable<>();
        String str="AAA";
        System.out.println(table.contains(str));
        table.insert(str);
        System.out.println(table.contains(str));
    }

//輸出false
//true

package com.test.collection;

public class HashTable<E> {
    private final int TABLE_SIZE=10;
    private final Node[]TABLE=new Node[TABLE_SIZE];

    //放入頭結(jié)點(diǎn)
    public HashTable(){
        for (int i = 0; i < TABLE_SIZE; i++)
            TABLE[i]=new Node<>(null);
    }

    //插入
    public void insert(E obj){
        int index=hash(obj);
        Node<E>head=TABLE[index];
        Node<E>node=new Node<>(obj);
        node.next=head.next;
        head.next=node;
    }

    //判斷是否包含
    public boolean contains(E element){
        int index=hash(element);
        Node<E>node=TABLE[index].next;
        while (node!=null){
            if(node.element==element)
                return true;
            node=node.next;
        }
        return false;
    }

    private int hash(E obj){ //哈希函數(shù)，計(jì)算出存放的位置
        int hashCode=obj.hashCode();
        //每一個(gè)對象都有一個(gè)獨(dú)一無二的哈希值，可以通過hashCode方法得到（極小概率出現(xiàn)相同情況）
        return hashCode%TABLE_SIZE;
    }

    public String toString(){
        StringBuilder builder=new StringBuilder();
        for (int i = 0; i < TABLE_SIZE; i++) {
            Node<E>head=TABLE[i].next;
            while (head!=null){
                builder.append(head.element+"->");
                head=head.next;
            }
            builder.append("\n");
        }
        return builder.toString();
    }


    private static class Node<E>{
        private final E element;
        private Node<E> next;

        private Node(E element){
            this.element=element;
        }
    }
}

    public static void main(String[] args) {

        HashTable<Integer>table1=new HashTable<>();
        for (int i = 0; i < 100; i++)
            table1.insert(i);

        System.out.println(table1);
    }

/*輸出
90->80->70->60->50->40->30->20->10->0->
91->81->71->61->51->41->31->21->11->1->
92->82->72->62->52->42->32->22->12->2->
93->83->73->63->53->43->33->23->13->3->
94->84->74->64->54->44->34->24->14->4->
95->85->75->65->55->45->35->25->15->5->
96->86->76->66->56->46->36->26->16->6->
97->87->77->67->57->47->37->27->17->7->
98->88->78->68->58->48->38->28->18->8->
99->89->79->69->59->49->39->29->19->9->

*/