Java 数据结构之链表

前言

链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。

由于链表不必按照顺序存储，故在插入数据时可以达到O(1)的复杂度，但是查找的时候就需要遍历，时间复杂度为O(n)。

分类

链表根据实现方式一般有三种分类：单向链表、循环链表、双向链表。

单向链表

单向链表指的是链表中的元素的指向只能指向链表中的下一个元素或者为空，元素之间不能相互指向。也就是一种线性链表。

图示：

普通单向链表

用Java代码实现一普通的单向链表。

public class SingleLinkList {
   

        private int size;//链表节点的个数
        private Node head;//头节点

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

        //链表的每个节点类
        private class Node{
   
            private Object data;//每个节点的数据
            private Node next;//每个节点指向下一个节点的连接

            public Node(Object data){
                this.data = data;
            }
        }

        //在链表头添加元素
        public Object addHead(Object obj){
            Node newHead = new Node(obj);
            if(size == 0){
                head = newHead;
            }else{
                newHead.next = head;
                head = newHead;
            }
            size++;
            return obj;
        }

        //在链表头删除元素
        public Object deleteHead(){
            Object obj = head.data;
            head = head.next;
            size--;
            return obj;
        }

        //查找指定元素，找到了返回节点Node，找不到返回null
        public Node find(Object obj){
            Node current = head;
            int tempSize = size;
            while(tempSize > 0){
                if(obj.equals(current.data)){
                    return current;
                }else{
                    current = current.next;
                }
                tempSize--;
            }
            return null;
        }

        //删除指定的元素，删除成功返回true
        public boolean delete(Object value){
            if(size == 0){
                return false;
            }
            Node current = head;
            Node previous = head;
            while(current.data != value){
                if(current.next == null){
                    return false;
                }else{
                    previous = current;
                    current = current.next;
                }
            }
            //如果删除的节点是第一个节点
            if(current == head){
                head = current.next;
                size--;
            }else{
  //删除的节点不是第一个节点
                previous.next = current.next;
                size--;
            }
            return true;
        }

        //判断链表是否为空
        public boolean isEmpty(){
            return (size == 0);
        }

        //显示节点信息
        public String display(){

            StringBuilder sb=new StringBuilder();
            if(size >0){
                Node node = head;
                int tempSize = size;
                if(tempSize == 1){
  //当前链表只有一个节点
                    sb.append("["+node.data+"]");
                    return sb.toString();
                }
                while(tempSize>0){
                    if(node.equals(head)){
                        sb.append("["+node.data+"->");