数据结构与算法（3）链表

原创

mb5ffd6fed5661e 2021-01-15 13:16:04 ©著作权

©著作权归作者所有：来自51CTO博客作者mb5ffd6fed5661e的原创作品，请联系作者获取转载授权，否则将追究法律责任

为什么要讲链表呢？这是因为java中有很多集合类底层都是通过链表来实现的。而且面试的时候，链表的实现是经常考的一个知识点。所以这篇文章的重点在于，如何使用代码去实现这些数据结构。但是这篇文章我不打算直接上来就讲链表，而是先从线性表开始。按照惯例先给出这篇文章的大致脉络吧。

首先，是对数据结构中线性表，做一个回顾。还讲了其两大存储结构，顺序存储结构和链式存储结构。
接下来，重点讲各种链表的介绍，以及常用方法和特点
最后，对java中使用链表的集合类，进行一个介绍。
当然，还有一些常见的面试题。

OK，开始。

一、线性表

为了很好的描述这个概念，先从一个例子开始吧，比如幼儿园的小朋友放学之后，都是手拉手排着队走出校园，这些小朋友从外表来看就像是一条链子，而线性表就和这个链子一样，这些小朋友就像是线性表里面的数据元素，从外面看一个接一个。比较正式的定义那就是：线性表：0个或者多个数据元素的有限序列。

刚刚我提到的都是从表面来看都是一样的，说明在内部的实现方式是不一样的，下面就是线性表的两种存储结构：顺序存储结构和链式存储结构。

顺序存储结构：用一段地址连续的存储单元依次存储线性表的数据元素。
链式存储结构：地址可以连续也可以不连续的存储单元存储数据元素

今天主要讲的就是基于链式存储结构的链表。你可以这样理解，比如说你要找一个人，名字叫张三，你首先跑到A，发现没有，A告诉你B可能知道，你跑到了B。B说C可能知道，你跑到了C，张三果然在C那里，如果没有就这样一直不停的去找。一张图看一下

数据结构与算法（3）链表_java

但是这只是基础，对线性表的描述，不想花费太多时间在这。下面用一张图表述吧。

数据结构与算法（3）链表_java_02

有了上面这张图，相信对分类等都有了了解和认识了。下面开始今天的主题单链表。

下面在对这两种存储结构进行一个对比。

	顺序存储结构	链式存储结构
存储密度	=1	<1
容量分配	提前分配好	动态分配
查找	O（n/2）	O（n/2）
插入	O(n/2)最好0，最坏n	O（1）更好
删除	O[(n-1)/2]	O（1）更好

二、链表

1、单链表

对于链表，里面主要有几个重要的信息，对于每一个节点（比如上一节讲到的A,B,C三处）都有下一个节点的地址和当前节点的数据。下面代码实现一下：

首先是节点的定义：

public class Node<T> {
    private T data; //节点的数据
    public Node next; //指向的下一个节点
    public Node(T data, Node next) {
        this.data = data;
        this.next=next;
    }

    public Node() { }
    public T getData() {
        return data;
    }
    private void setData(T data) {
        this.data = data;
    }
}

接下来无非是对节点的增删改查罢了，先看基本的操作。

public class LinkList<T> {
  private Node head; //头结点
  private Node tail; //尾结点
  private int size; //链表长度
  public LinkList() {
     head=null;
     tail=null;
  }
//获取链表长度
  public int getLength(){
     return size;
  }
//是否含有元素
  public boolean isEmpty(){
     return size==0;
  }
//清空链表
  public void clear(){
     head=null;
     tail=null;
     size=0;
  }
//通过索引获取节点
      public Node getNodeByIndex(int index){
         if(index<0||index>size-1){
            throw new IndexOutOfBoundsException("索引越界");
        }
         Node node=head;
         for(int i=0;i<size;i++,node=node.next){
             if(i==index){
               return node;
            }
        }
         return null;
      }
}

下面就是正删改查了，但是有一个思路需要我们要牢记，这样在使用其他语言实现的时候，就能快速的掌握，这是我自己的方法。

上面已经描述了通过索引查找元素，所以下面只考虑，插入删除操作就好了。

首先，我们要判断当前的空间是否满足增删该查的条件
接下来，判断增删改查的位置是否正确
最后，增删改查之后没有副作用产生。

第一个操作：插入（三种方式：头插入、尾插入、中间插入）

对于插入操作，使用一张图简单表述一下

数据结构与算法（3）链表_java_03

//头插入
    public void addAtHead(T element){
         head=new Node<T>(element, head);
//如果是空链表就变让尾指针指向头指针
         if(tail==null){
              tail=head;
        }
         size++;
    }

//尾插入
     public void addAtTail(T element){
//如果表为空
         if(head==null){
              head=new Node<T>(element, null);
              tail=head;
        }else{
              Node node=new Node<T>(element, null);
              tail.next=node;
              tail=node; //尾节点后移
        }
         size++;
    }

//在指定位置插入元素
    public void insert(T element,int index){
         if(index<0||index>size){
              throw new IndexOutOfBoundsException("索引越界");
        }
         if(index==0){
              addAtHead(element);
        }else if(index>0&&index<size-1){
//中间插入
              Node nexNode=null;
              Node insNode=new Node<T>(element, nexNode);
              nexNode=getNodeByIndex(index);
              Node preNode=getNodeByIndex(index-1);
              preNode.next=insNode;
              insNode.next=nexNode;
              size++;
        }else {
              addAtTail(element);
        }
    }

第二种操作：删除

对删除操作同样一张图

数据结构与算法（3）链表_java_04

  public void delete(int index){
         if(index<0||index>size-1){
              throw new IndexOutOfBoundsException("索引越界");
        }
         int flag=index-1;
         Node node=getNodeByIndex(index);
         if(flag < 0){
//flag<0说明删除的是第一个元素，将头结点指向下一个就行
              head=head.next;
              node=null;
        }else{
//在这里才是真正的删除操作，
              Node preNode=getNodeByIndex(index-1);
              preNode.next=node.next;
//如果删除的是最后一个元素，尾节点前移一位
              if(index==size-1){
                 tail=preNode;
              }
        }
              size--;
    }

//删除最后一个元素
    public void remove(){
       delete(size-1);
    }