Java数据结构--链表

public interface Predecessor<E> {//定义接口 用于实现多态
    public ListNode<E> getNext();  
    public void setNext(ListNode next);
}

/**
 * Created by root on 16-2-24.
 */
public class ListNode<E> implements Predecessor<E>{
    private E item;  //泛型元素
    private ListNode<E> next; //定义节点（指针）

    public ListNode(E item) {
        this.item = item;  //初始化ListNode节点 具有一个item 和一个指向null的指针
        next = null;
    }

    public ListNode(E item, ListNode<E> next) {//重载的构造方法
        this.item = item;   //可以把在把前一个ListNode的指针指向新构造的节点
        this.next = next;    
    }

    public E getItem() {
        return item;   //获得节点的item字段
    }

    public void setItem(E item) {
        this.item = item;  //设置节点的item字段
    }

    public ListNode<E> getNext() {
        return next;  //获得下一个节点
    }

    public void setNext(ListNode next) {
        this.next = next;  //设置下一个节点
    }
}

/**
 * Created by root on 16-2-25.
 */
public class LinkedList<E> implements Predecessor<E> {
    private ListNode front;//头节点

    public boolean isEmpty() {//判断链表是否为空
        return front == null;  //如果链表头节点的next指针指向null对象 返回true
    }

    public ListNode getNext() {
        return front;   //用于实现多态 LinkedList类型的链表也可以有getNext()方法 并且可以返回链表头指针
    }

    public void setNext(ListNode next){
        front=next;   //用于实现多态 LinkedList类型的链表也可以有setNext()方法 链表头指向输入的节点
    }

    public boolean contains(E target) {//判断链表是否包含某个item
        for (ListNode node = front; node != null; node = node.getNext()) {//遍历链表用node!=null
            if (node.getItem() == target) {
                return true;
            }
        }
        return false;
    }

    public LinkedList() { //构造方法 constructor 头指针指向空对象
        front = null;
    }

    public int size() {  //返回链表长度
        int i = 0;
        ListNode node = front;  //把front指针 赋给node指针
        while (node != null) {
            i++;
            node = node.getNext(); //指针在链表中移动
        }
        return i;
    }

    public String toString() { //实现打印链表
        String result = "( ";
        for (ListNode node = front; node != null; node = node.getNext()) {
            result += node.getItem() + " ";
        }
        return result;
    }

    public E get(int index) {  //获得链表索引对应的item
        ListNode node = front;
        for (int i = 0; i < index; i++) {
            node = node.getNext();
        }
        return (E) node.getItem();
    }

    public void set(int index, E target) {  //设置链表某一节点的item
        ListNode node = front;
        for (int i = 0; i < index; i++) {
            node = node.getNext();
        }
        node.setItem(target);
    }

    public void add(E target) {  //在尾部增加一个节点
        Predecessor<E> last = this;  //实现多态 因为ListNode和LinkedList实现了同一个接口 所以可以这么做
        while (last.getNext() != null) {//当last为 LinkedList类型时 返回front 
            last = last.getNext(); //这里不会报错 是因为ListNode和LinkedList实现了同一个接口
        }
        last.setNext(new ListNode(target));  //如果last是LinkedList类型setNext方法 会把front指针指向新的节点 而不会报错
    }
    public E remove(int index){
        Predecessor pre=this;  //同样利用了多态性
        ListNode node =front;  //两只算法  类似两个手指在链表上移动 一个在前一个在后
        for(int i=0;i<index;i++){
            pre=node;
            node=node.getNext();
        }
        pre.setNext(node.getNext());  //把pre节点和 node节点的下一个节点相连 完成删除节点
        return (E) node.getItem();
    }
    public boolean remove(E target){
        Predecessor prev=this;
        ListNode node=front;
        while(node!=null){
            if(node.getItem().equals(target)){
                prev.setNext(node.getNext());
                return true;
            }
            prev=node;
            node=node.getNext();
        }
        return false;
    }
}