链式结构

1、链式结构
链式结构的特点就是除了记录数据之外，需要记录与其他结点的关系，即需要“结点”来表示。
（1）单链表：除了记录元素的数据以外，记录下一个结点的地址
（2）双链表：除了记录元素的数据以外，记录上一个和下一个结点的地址
（3）二叉树：除了记录元素的数据以外，记录左子结点和右子结点的地址，甚至记录“父”结点的地址

单链表的结点：

class Node{
    Object data;
    Node next;//记录下一个结点地址
}

双链表的结点：

class Node{
    Node prev;//记录上一个结点地址
    Object data;
    Node next;//记录下一个结点地址
}

二叉树的结点：

class Node{
    Node left;//记录左结点地址
    Object data;
    Node right;//记录右结点地址
    Node parent;//记录父结点地址
}

2、例如：在JRE核心类库中，就有LinkdedList（双链表）的实现
LinkedList中有一个内部类Node结点类型：
    private static class Node<E> {
        E item;
        Node<E> next;
        Node<E> prev;

        Node(Node<E> prev, E element, Node<E> next) {
            this.item = element;
            this.next = next;
            this.prev = prev;
        }
    }

LinkedList有两个成员变量，一个是first，一个是last，分别代表双向链表的第一个结点和最后一个结点。

3、跟踪双向链表LinkedList的源码
（1）看它的结点类型
    private static class Node<E> {
        E item;
        Node<E> next;
        Node<E> prev;

        Node(Node<E> prev, E element, Node<E> next) {
            this.item = element;
            this.next = next;
            this.prev = prev;
        }
    }
(2)LinkedList中是如何表示第一个结点和最后一个结点的呢？
分别用
Node first;
Node last;

(3)add方法
(4)remove方法

OneWayLinked单链表：
第一步：设计单链表的结点类型
    private class Node{
        T data;
        Node next;

        Node(T data, Node next) {
            this.data = data;
            this.next = next;
        }
    }

第二步：设计单链表如何表示？
单链表需要记录“头结点”，只有根据头结点才能找到后面的其他结点。
在里面声明一个Node类型成员变量，叫做head

第三步：设计一个方法，可以往单链表中添加元素
第四步：设计一个方法，可以删除单链表中的元素
第五步：设计一个方法，可以遍历单链表的元素

public class OneWayLinked<T> implements Iterable<T> {
    private Node head;//单链表的头结点 ，默认值是null，如果它是null的话，这个单链表是空的
    private int size;//记录结点的个数，也就是单链表的元素个数

    //添加元素
    public void add(T element){
        /*
        如果单链表是空的，创建第一个结点给head赋值
        如果单链表不是空的，从head开始找到最后一个结点，把新创建的结点，放到最后一个结点的next中
         */
        //创建一个新结点
        Node newNode = new Node(element , null);//新结点没有下一个结点，所以next是null

        //判断单链表现在是否为空
        if(head == null){
            head = newNode;
        }else{
            //找到最后一个结点
            Node node = head;
            while(node.next != null){
                node = node.next;//循环一次就往后面移动一个结点
            }
            //结束while时，node代表最后一个结点
            //把新创建的结点，放到最后一个结点的next中
            node.next = newNode;
        }
        size++;
    }

    public void remove(Object element){
        if(head==null){
            return ;
        }
        //(1)找到element对应的结点，例如叫做node，用一个lastNode来记录node的上一个结点
        Node node = head;
        Node lastNode = null;//当node指向第一个结点时，lastNode是没有指向任何结点，所以是null
        if(element == null){
            while(node != null){
                if(node.data == element){
                    break;
                }
                lastNode = node;
                node = node.next;
            }
        }else{
            while(node != null){
                if(element.equals(node.data)){
                    break;
                }
                lastNode = node;
                node = node.next;
            }
        }

        //(2)让lastNode.next = node.next
        /*
        上面的循环while是用来找被删除结点，如果从if中break出来，node一定是非null，如果没有满足if,说明没找到，
        while(node!=null)条件不成立结束的循环，说明node是null
         */
        if(node != null){//找到被删除结点
            if(lastNode == null) {//删除的是第一个结点
                head = node.next;
            }else{
                lastNode.next = node.next;
            }

            //为了彻底回收node对应内存
            node.data = null;
            node.next = null;

            //元素个数减少
            size --;
        }
    }

    public int size(){
        return size;
    }

    public Object[] toArray(){
        //创建一个新数组，长度为size
        Object[] result = new Object[size];
        if(head != null){
            Node node = head;
            for(int i = 0; node!=null; i++){
                result[i] = node.data;
                node = node.next;
            }
            /*
            假设单链表里面有5个结点
            head!=null
            (1)第1次循环，node = head，i=0  result[0] = node.data = head.data;
            (2)第2次循环，i=1, node=第2个结点，result[1] = 第2个结点.data
            (3)第3次循环，i=2, node=第3个结点，result[2] = 第3个结点.data
            (4)第4次循环，i=3, node=第4个结点，result[3] = 第4个结点.data
            (5)第5次循环，i=4, node=第5个结点，result[4] = 第5个结点.data
            (6)准备第6次循环，i=5, node=第5个结点的next，它是null， node!=null不成立，for结束
             */
        }
        return result;
    }

    @Override
    public Iterator<T> iterator() {
        return new Itr();
    }

    private class Itr implements Iterator<T>{
        Node node  = head;

        @Override
        public boolean hasNext() {
            return node != null;
        }

        @Override
        public T next() {
            T data = node.data;
            node = node.next;
            return data;
        }
    }


    //单链表的结点类型
    private class Node{
        T data;
        Node next;

        Node(T data, Node next) {
            this.data = data;
            this.next = next;
        }
    }
}

/*
模拟单链表的实现
 */
public class TestOneWayLinked {
    public static void main(String[] args) {
        OneWayLinked<String> list = new OneWayLinked<>();
        list.add("hello");
        list.add("world");
        list.add("java");
        list.add("h5");
        list.add("ui");

        list.remove("hello");
        list.remove("ui");
        list.remove("java");

        Object[] objects = list.toArray();
        for (int i = 0; i < objects.length; i++) {
            System.out.println(objects[i]);
        }

        System.out.println("--------------------");
        for (String s : list) {
            System.out.println(s);
        }

    }
}