5、链表的实现

一、链表的简单介绍

链表的实现，在我看来它的实现，是有两种不同的实现方式。

第一种实现方式是带头指针的实现方式。

第二种实现方式是不带头指针的实现方式。

当我们考虑使用不带头指针的会比较复杂些。因为你要考虑插在链表头部插入和其他位置的插入式有区别的。

每次的链表的插入要考虑是不是头部插入和头部删除。进行分情况处理。

二、链表的基本实现。

1、不带头指针的链表实现。

定义的抽象接口

package com.ipp.list;

public interface LinkList<T> {
    /**
     * 获取元素的大小和尺寸
     * @return
     */
    public int getSize();

    /**
     * 制定位置添加元素
     * @param index
     * @param e
     */
    public   void  add(int  index ,T e);

    /**
     * 添加元素到头部
     * @param e
     */
    public  void  addFirst(T e);

    /**
     * 添加元素到尾部
     * @param e
     */
    public void   addLast(T  e);

    /**
     *判断是否是空
     * @return
     */
    public boolean isEmpty();

    /**
     * 获得链表的第index(0-based)个位置的元素
     * @param index
     * @return
     */
    public T get(int index);


    /**
     * 获得链表的第一个元素
     */
    public T getFirst();


    /**
     *     获得链表的最后一个元素
     */
    public T getLast();

    /**
     *  修改链表的第index(0-based)个位置的元素为e
     *   在链表中不是一个常用的操作，练习用：
     * @param index
     * @param e
     */
    public void set(int index, T e);

    /**
     *  查找链表中是否有元素e
     * @param e
     * @return
     */
    public boolean contains(T e);



    /**
     * 从链表中删除index(0-based)位置的元素, 返回删除的元素
     * 在链表中不是一个常用的操作，练习用：）
     * @param index
     * @return
     */
    public T remove(int index);

    /**
     * 从链表中删除第一个元素, 返回删除的元素
     */
    public T removeFirst();

    /**
     *  从链表中删除最后一个元素, 返回删除的元素
      */
    public T removeLast();

    /**
     *  从链表中删除元素e
     * @param e
     * @return
     */
    public void removeElement(T e);
}

实现代码

package com.ipp.list.impl;

import com.ipp.list.LinkList;

public class LinklistImpl2<E> implements LinkList<E> {

    private class Node {
        public E e;
        public Node next;

        public Node(E e, Node next) {
            this.e = e;
            this.next = next;
        }

        public Node(E e) {
            this(e, null);
        }

        public Node() {
            this(null, null);
        }

        @Override
        public String toString() {
            return e.toString();
        }
    }

    //头结点
    private Node head;
    //大小
    private int size;

    public LinklistImpl2() {
        head = null;
        size = 0;
    }

    @Override
    public int getSize() {
        return size;
    }

    @Override
    public void add(int index, E e) {  //如果是头部元素
        if (index < 0 || index > size)
            throw new IllegalArgumentException("Add failed. Illegal index.");
        if (index == 0) {
            addFirst(e);
            return;
        }
        Node pre = head;
        for (int i = 1; i < index; i++) {
            pre = pre.next;
        }
        pre.next = new Node(e, pre.next);
        //1、相当于下面的三步操作
       /*   Node   node=new Node(e);
          node.next=pre.next;
          pre.next=node;*/
    }

    @Override
    public void addFirst(E e) {
        //相当于两种情况
        //1、如果没有元素
        head = new Node(e);
        //2、如果有元素。
       /*   Node  node=new Node(e);
            node.next=head;
            head=node;*/
        head = new Node(e, head);
        size++;
    }

    @Override
    public void addLast(E e) {
        add(size, e);
    }

    @Override
    public boolean isEmpty() {
        return size == 0;
    }

    @Override
    public E get(int index) {
        if (index < 0 || index >= size) {
            throw new IllegalArgumentException("index is out");
        }
        Node cur = head;
        for (int i = 0; i < index; i++) {
            cur = cur.next;
        }
        return cur.e;
    }

    @Override
    public E getFirst() {
        return get(0);
    }

    @Override
    public E getLast() {
        return get(size - 1);
    }

    @Override
    public void set(int index, E e) {
        if (index < 0 || index >= size) {
            throw new IllegalArgumentException("index is out");
        }
        Node cur = head;
        for (int i = 0; i < index; i++) {
            cur = cur.next;
        }
        cur.e = e;
    }

    @Override
    public boolean contains(E e) {
        Node cur = head;
        while (cur != null) {
            if (e.equals(cur.e)) {
                return true;
            }
            cur = cur.next;
        }
        return false;
    }


    @Override
    public E remove(int index) {
        if (index < 0 || index >= size) {
            throw new IllegalArgumentException("index  is  Ill");
        }

        //如果是删除第一个元素
        if (index == 0) {
            return removeFirst();
        } else {
            //2、找到要删除的前一个元素
            Node pre = head;
            for (int i = 1; i < index; i++) {
                pre = pre.next;
            }
            //3、找到要删除的元素
            Node cur = pre.next;
            E res = cur.e;
            //3、进行删除操作
            pre.next = cur.next;
            cur = null;
            size--;
            return res;
        }

    }

    @Override
    public E removeFirst() {
        if (size == 0) throw new IllegalArgumentException(" element  size is  zero");
        Node node = head;
        head = head.next;
        size--;
        E res = node.e;
        node = null;
        return res;
    }

    @Override
    public E removeLast() {
        return remove(size - 1);
    }

    @Override
    public void removeElement(E e) {
        if (!contains(e)){
            throw new IllegalArgumentException("你要删除的元素不存在");
        }
        if (size == 0) {
            throw new IllegalArgumentException(" element  size is  zero");
        }
        if (head.e.equals(e)) { //如果要删除的是第一个元素。
            removeFirst();
            return ;
        }
        Node pre = head;
        Node cur = head.next;
        while (cur != null) {
              if(cur.e.equals(e)){
                  pre.next=cur.next; //删除该元素
                  size--;
              }
              pre=pre.next;
              cur=cur.next;
        }
        return;
    }
}

2、带头指针的基本实现

package com.ipp.list.impl;

import com.ipp.list.LinkList;

public class LinkListImpl<E> implements LinkList<E> {

    private class Node {
        public E e;
        public Node next;

        public Node(E e, Node next) {
            this.e = e;
            this.next = next;
        }

        public Node(E e) {
            this(e, null);
        }

        public Node() {
            this(null, null);
        }

        @Override
        public String toString() {
            return e.toString();
        }
    }

    //头结点
    private Node head;
    //大小
    private int size;

    /**
     * 构造函数
     */
    public LinkListImpl() {
        head = new Node();
        size = 0;
    }

    @Override
    public E get(int index) {
        //1、判断是否越界
        if (index < 0 || index >= size) {
            throw new IllegalArgumentException("index is out");
        }
        Node cur = head.next;

        for (int i = 0; i < index; i++) {
            cur = cur.next;
        }
        return cur.e;
    }

    @Override
    public E getFirst() {
        return get(0);
    }

    @Override
    public E getLast() {
        return get(size - 1);
    }

    @Override
    public void set(int index, E e) {
        //1、判断是否越界
        if (index < 0 || index >= size) {
            throw new IllegalArgumentException("index is out");
        }
        Node cur = head.next;
        for (int i = 0; i < index; i++) {
            cur = cur.next;
        }
        cur.e = e;
    }

    @Override
    public boolean contains(E e) {
        Node cur = head.next;
        while (cur != null) {
            if (cur.e .equals(e) ) return true;
            cur = cur.next;
        }
        return false;
    }

    @Override
    public int getSize() {
        return size;
    }

    @Override
    public void add(int index, E e) {
        //1、判断插入的位置是否合法。
        if (index > size||index<0) {
            throw new IllegalArgumentException("越界了");
        }
        Node pre = head;
        //2、找到对应的插入对方.
        for (int i = 0; i < index; i++) {
            pre = pre.next;
        }
        //3、进行插入操作。
        pre.next = new Node(e, pre.next);
        //相当于下面三个操作
        /*Node  node=new  Node(e);
        node.next=pre.next;
        pre.next=node;*/
        //4、size更新
        size++;
    }

    @Override
    public void addFirst(E e) {
        add(0, e);
    }

    @Override
    public void addLast(E e) {
        add(size, e);
    }

    @Override
    public boolean isEmpty() {
        return size == 0;
    }

    @Override
    public E remove(int index) {
        if(index<0||index>=size){
             throw   new IllegalArgumentException("ill is out");
        }
        Node  pre=head;
        for(int i=0;i<index;i++){
            pre=pre.next;
        }
        Node  cur=pre.next;
        pre.next=cur.next;
        E res=cur.e;
        cur.next=null;
        size--;
        return res;
    }

    @Override
    public E removeFirst() {
        return remove(0);
    }

    @Override
    public E removeLast() {
        return remove(size-1);
    }

    @Override
    public void removeElement(E e) {
        if(!contains(e)){  throw  new  IllegalArgumentException("您删除的元素不存在");}
        Node  pre=head;
        Node  cur=head.next;
        while(cur!=null){
            if(cur.e.equals(e)){
                pre.next=cur.next;
                cur.next=null;
                size--;
            }
            pre=pre.next;
            cur=pre.next;
        }
    }
}