java实现_数据结构_单向链表代码实例

单向链表自定义实现

代码实例：

接口代码：

package list;

/**
 * 基于链表结构存储元素方法API定义
 * @param <E>
 */

public interface MyList <E>{


    int size();
    void add(E element);
    E get(int index);
    E remove(int index);
}

容器类代码：

package list;

/**
 * 基于单项链表实现元素存取的容器
 * @param <E>
 */
public class MySinglyLinkedList <E> implements MyList<E>{
    /**
     * 定义单向链表中的节点对象
     */
    static class Node <E>{
        private E item;         //储存元素
        private Node<E> next;      //储存下一个节点

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

    private Node<E> head;      //存放链表的头节点
    private int size;       //记录链表的元素个数

    /**
     * 返回链表的大小
     * @return
     */

    @Override
    public int size() {
        return this.size;
    }

    /**
     * 完成向链表中添加元素
     * @return
     */
    @Override
    public void add(E element) {
        //创建新节点
        Node <E> node = new Node(element, null);
        //找到链表尾节点
        Node tail = getTail();

        //节点挂接在链表上
        if (tail == null)
            this.head = node;
        else
            tail.next = node;
        //记录链表的大小
        this.size++;

    }
    /**
     * 找尾节点
     */
    private Node<E> getTail(){
        //头节点是否存在的
         if(this.head ==null ){
             return null;
         }
        //寻找尾节点
         Node node = this.head;
         while (true){
             if (node.next == null) break;
             node = node.next;
         }
         return node;
    }

    /**
     * 按照所索引值获取元素
     * @param index
     * @return
     */
    @Override
    public E get(int index) {
        //检验index的合法性
        this.checkIndex(index);
        //根据位置获取指定节点
        Node<E> node = this.getNode(index);
        //返回节点中的元素
        return node.item;
    }
    /**
     * 对index进校验
     */
    private void checkIndex(int index){
        if(! (index >= 0 && index<size )){
            throw new IndexOutOfBoundsException("Index:"+index+"Size"+this.size);
        }

    }
    /**
     * 根据位置获取节点
     */
    private Node<E> getNode(int index){
         Node<E> node = this.head;
         for(int i = 0;i<index;i++){
              node = node.next;
         }
         return node;
    }

    /**
     * 按照索引值删除元素，，并返回删除的元素
     * @param index
     * @return
     */
    @Override
    public E remove(int index) {
        //检验索引值的合法性
        this.checkIndex(index);
        //获取要删除元素的上一个元素
        if (index == 0){        //删除的是头节点
            Node<E> node = this.head;
            this.head = (this.head).next;
            size--;
            node.next = null;//释放删除的节点
            return node.item;
        }else{
            Node<E> nodepre = this.getNode(index-1);
            Node<E> nodenext = nodepre.next;
            nodepre.next = nodenext.next;
            nodenext.next = null;//释放删除的节点
            size--;
            return (E) nodenext.item;
        }


    }


    public static void main(String[] args) {
        MySinglyLinkedList<String> mySinglyLinkedList = new MySinglyLinkedList<>();
        mySinglyLinkedList.add("a");
        mySinglyLinkedList.add("b");
        mySinglyLinkedList.add("c");
        mySinglyLinkedList.remove(0);
        String s = mySinglyLinkedList.get(1);
        System.out.println(mySinglyLinkedList.size);
        System.out.println(s);

    }
}

运行结果：

2
c