Java基础--单链表的实现

Java内部也有自己的链表--LinkedList，但是我们今天不是讨论LinkedList，而是自己来实现一个单链表，包括简单的增删查改：

单链表的结构
单链表的基本操作
虚拟头结点的使用
整个类的设计如下：

public class Linked <T>{
    
    private class Node{
        private T t;
        private Node next;
        public Node(T t,Node next){
            this.t = t;
            this.next = next;
        }
        public Node(T t){
            this(t,null);
        }
    }
    private Node head;            //头结点
    private int size;            //链表元素个数
    //构造函数
    public Linked(){
        this.head = null;
        this.size = 0;
    }
}

单链表的结构
一种链式存取的数据结构，单链表中的数据是以结点的形式存在，每一个结点是由数据元素和下一个结点的存储的位置组成。单链表与数组相比的最大差别是：单链表的数据元素存放在内存空间的地址是不连续的，而数组的数据元素存放的地址在内存空间中是连续的，这也是为什么根据索引无法像数组那样直接就能查询到数据元素。

[单链表结构图] 
链表存储的结点

private class Node{
        private T t;
        private Node next;
        public Node(T t,Node next){
            this.t = t;
            this.next = next;
        }
        public Node(T t){
            this(t,null);
        }
}

链表的基本操作
包括链表的增删查改，以及判别某结点是否存在链表中
链表结点的增加
进行结点的添加的时候，是根据索引来进行操作的，由于成员变量size记录了当前链表的元素个数，进行某个索引位置的结点插入就会很方便了。先找到该目标索引的前一个结点，记录为pre，把要插入的结点node的下一个结点node.next指向pre的下一个结点pre.next；再把pre.next指向node结点。如果先进行pre.next指向要插入的结点，再进行node.next指向pre.next的话，无疑是要插入的结点自己指向了自己，无法连接上整个链表，在链表的操作中，有时候顺序的执行会带来不一样的结果。

//链表头部添加元素
    public void addFirst(T t){
        Node node = new Node(t);    //节点对象
        node.next = this.head;
        this.head = node;
        //this.head = new Node(e,head);等价上述代码
        this.size++;
    }
    //向链表尾部插入元素
    public void addLast(T t){
        this.add(t, this.size);
    }
    //向链表中间插入元素
    public void add(T t,int index){
        if (index <0 || index >size){
            throw new IllegalArgumentException("index is error");
        }
        if (index == 0){
            this.addFirst(t);
            return;
        }
        Node preNode = this.head;
        //找到要插入节点的前一个节点
        for(int i = 0; i < index-1; i++){
            preNode = preNode.next;
        }
        Node node = new Node(t);
        //要插入的节点的下一个节点指向preNode节点的下一个节点
        node.next = preNode.next;
        //preNode的下一个节点指向要插入节点node
        preNode.next = node;
        this.size++;
    }

链表结点的删除

//删除链表元素
    public void remove(T t){
        if(head == null){
            System.out.println("无元素可删除");
            return;
        }
        //要删除的元素与头结点的元素相同
        while(head != null && head.t.equals(t)){
            head = head.next;
            this.size--;
        }
        /**
         * 上面已经对头节点判别是否要进行删除
         * 所以要对头结点的下一个结点进行判别
         */
        Node cur = this.head;
        while(cur != null && cur.next != null){
            if(cur.next.t.equals(t)){
                this.size--;
                cur.next = cur.next.next;
            }
            else cur = cur.next;
        }
        
    }

在进行链表的结点删除时候，要分情况讨论：

当要删除的结点位于头结点的时候： 如下图要删除的元素1的结点位于头结点，先进行while判断头结点是否为null且判断该结点的元素是否为要删除的元素，如果是把head指向head.next即可，直接跳过头结点，直到头结点不是要删除的元素就结束循环。
[要删除的元素1位于头结点]

当要删除的结点不在头结点的时候：如下图删除元素为3的结点，由于上面已经判断了头结点不是要删除的元素，所以我们从头结点的下一个结点开始循环，即cur.next，当cur.next是要被删除的元素时，直接cur.next = curr.next.next就能直接跳过cur.next，断开。
[要删除结点的元素为3的结点]

删除链表的头结点的元素和删除链表的尾结点的元素

//删除链表第一个元素
    public T removeFirst(){
        if(this.head == null){
            System.out.println("无元素可删除");
            return null;
        }
        Node delNode = this.head;
        this.head = this.head.next;
        delNode.next =null;
        this.size--;
        return delNode.t;
    }
    //删除链表的最后一个元素
    public T removeLast(){
        if(this.head == null){
            System.out.println("无元素可删除");
            return null;
        }
        //只有一个元素
        if(this.getSize() == 1){
            return this.removeFirst();
        }
        Node cur = this.head;    //记录当前结点
        Node pre = this.head;    //记录要删除结点的前一个结点
        while(cur.next != null){
            pre = cur;
            cur = cur.next;
        }
        pre.next = cur.next;
        this.size--;
        return cur.t;
    }

经过上面在进行链表的结点删除的时候，会发现在删除的过程中很麻烦，还得考虑头结点（因为我们在删除结点的时候，都是先找到待删除结点del的前一个结点pre，然后直接进行跳过操作，即pre.next = pre.next.next，但是删除结点头结点的时候就无法操作），给我们添加了麻烦，为此我们可以给链表添加一个虚拟的头结点，说白了就是重新new一个结点对象，该结点对象的下一个结点指向了我们之前的头结点，让我们在删除结点的时候，无须再考虑之前的头结点了！

虚拟头结点删除链表元素的实现

//加入虚拟头结点的链表进行删除
    public void removeElt(T t){
        //构造虚拟头结点，并且下一个结点指向head
        Node dummy = new Node(t,this.head);
        //声明结点指向虚拟头结点
        Node cur = dummy;
        //从虚拟头结点的下一个结点开始遍历
        while(cur.next != null){
            if(cur.next.t.equals(t)){ 
                cur.next = cur.next.next;
                this.size--;
            }
            else cur = cur.next;
        }
        //去除虚拟头结点
        this.head = dummy.next;
    }

使用虚拟头结点进行链表的插入
刚开始那部分的结点添加是基于索引的情况实现，当我们无法知道一个结点的位于链表的哪个位置时候，只知道要插入在某个元素的前面，下面的代码基于上述情况实现。

    

/**
     * 
     * @param t:插入在t元素的位置
     * @param des：要插入的元素
     */
    public void insert(T t,T des){
        //构造虚拟头结点，并且下一个结点指向head
        Node dummy = new Node(null,this.head);
        //构造要插入的结点
        Node dNode = new Node(des);
        //声明变量cur指向虚拟头结点
        Node cur = dummy;
        while(cur.next != null){
            if(cur.next.t.equals(t)){ 
                dNode.next = cur.next;
                cur.next = dNode;
                this.size++;
                break;
            }
            else cur = cur.next;
        }
        this.head = dummy.next;
    }

查找某个元素是否在链表的结点上
//链表中是否包含某个元素

    public boolean contains(T t){
        Node cur = this.head;
        while(cur != null){
            if(cur.t.equals(t)){
                return true;
            }
            else cur = cur.next;
        }
        return false;
    }

完整的代码实现：

package LinkedList;

public class Linked <T>{
    
    private class Node{
        private T t;
        private Node next;
        public Node(T t,Node next){
            this.t = t;
            this.next = next;
        }
        public Node(T t){
            this(t,null);
        }
    }
    private Node head;            //头结点
    private int size;            //链表元素个数
    //构造函数
    public Linked(){
        this.head = null;
        this.size = 0;
    }
    
    //获取链表元素的个数
    public int getSize(){
        return this.size;
    }
    //判断链表是否为空
    public boolean isEmpty(){
        return this.size == 0;
    }
    //链表头部添加元素
    public void addFirst(T t){
        Node node = new Node(t);    //节点对象
        node.next = this.head;
        this.head = node;
        // this.head = new Node(e,head);等价上述代码
        this.size++;
    }
    //向链表尾部插入元素
    public void addLast(T t){
        this.add(t, this.size);
    }
    //向链表中间插入元素
    public void add(T t,int index){
        if (index <0 || index >size){
            throw new IllegalArgumentException("index is error");
        }
        if (index == 0){
            this.addFirst(t);
            return;
        }
        Node preNode = this.head;
        //找到要插入节点的前一个节点
        for(int i = 0; i < index-1; i++){
            preNode = preNode.next;
        }
        Node node = new Node(t);
        //要插入的节点的下一个节点指向preNode节点的下一个节点
        node.next = preNode.next;
        //preNode的下一个节点指向要插入节点node
        preNode.next = node;
        this.size++;
    }
    //删除链表元素
    public void remove(T t){
        if(head == null){
            System.out.println("无元素可删除");
            return;
        }
        //要删除的元素与头结点的元素相同
        while(head != null && head.t.equals(t)){
            head = head.next;
            this.size--;
        }
        /**
         * 上面已经对头节点判别是否要进行删除
         * 所以要对头结点的下一个结点进行判别
         */
        Node cur = this.head;
        while(cur != null && cur.next != null){
            if(cur.next.t.equals(t)){
                this.size--;
                cur.next = cur.next.next;
            }
            else cur = cur.next;
        }
        
    }
    //删除链表第一个元素
    public T removeFirst(){
        if(this.head == null){
            System.out.println("无元素可删除");
            return null;
        }
        Node delNode = this.head;
        this.head = this.head.next;
        delNode.next =null;
        this.size--;
        return delNode.t;
    }
    //删除链表的最后一个元素
    public T removeLast(){
        if(this.head == null){
            System.out.println("无元素可删除");
            return null;
        }
        //只有一个元素
        if(this.getSize() == 1){
            return this.removeFirst();
        }
        Node cur = this.head;    //记录当前结点
        Node pre = this.head;    //记录要删除结点的前一个结点
        while(cur.next != null){
            pre = cur;
            cur = cur.next;
        }
        pre.next = cur.next;
        this.size--;
        return cur.t;
    }
    //链表中是否包含某个元素
    public boolean contains(T t){
        Node cur = this.head;
        while(cur != null){
            if(cur.t.equals(t)){
                return true;
            }
            else cur = cur.next;
        }
        return false;
    }
    @Override
    public String toString() {
        StringBuffer sb = new StringBuffer();
        Node cur = this.head;
        while(cur != null){
            sb.append(cur.t+"->");
            cur = cur.next;
        }
        sb.append("NULL");
        return sb.toString();
    }
    
    public static void main(String[] args) {
        Linked<Integer> linked = new Linked();
        for(int i = 0; i < 10; i++){
            linked.addFirst(i);
            System.out.println(linked);
        }
        linked.addLast(33);
        linked.addFirst(33);
        linked.add(33, 5);
        System.out.println(linked);
        linked.remove(33);
        System.out.println(linked);
        System.out.println("删除第一个元素："+linked.removeFirst());
        System.out.println(linked);
        System.out.println("删除最后一个元素："+linked.removeLast());
        System.out.println(linked);
    }
}

总结：学链表是一种痛苦，但是痛苦并快乐着，希望能够坚持下去，把链表的全家桶都学习了，而不是这么简单的增加和删除。上述如有说的不对的地方欢迎指正！下篇文章将进行用链表实现栈和队列。
————————————————