小白也能学会的链表(java)——第一关青铜挑战

文公子WGZ

已于 2023-12-21 15:51:51 修改

阅读量270

点赞数 7

分类专栏：算法文章标签：链表 java 数据结构

于 2023-11-28 08:00:00 首次发布

本文链接：https://blog.csdn.net/zywmac/article/details/134656931

版权

算法专栏收录该内容

14 篇文章 0 订阅

订阅专栏

3.1 概念：首要要先理解JVM是怎么构建出链表的

1.单链表的概念

算法的基础是数据结构，任何数据结构的基础都是创建+增删改查，所有的链表算法题分解到最后，都是这几个操作，所以下面也从这五项开始学习链表。

1.1链表的概念

什么是链表？

答：单向链表就像一个铁链一样，元素之间相互连接，包含多个节点，每个节点有一个指向后继元素的next指针。表中最后一个元素的next指向null。如下图

注意：单链表中（核心的一个节点只能有一个后继，但是不代表一个节点只能有一个被指向。也就是好比法律规定一夫一妻，你只能和一个人结婚，不能同时跟两个人结婚，但是可以很多个人去爱你），就比如图二，图三就不符合

2.链表的相关概念

2.1节点和头节点

在链表中，每个点都由值和指向下一个结点的地址组成的独立单元，称为一个结点，有时也称为节点，含义都是一样的。

对于单链表，如果知道了第一个元素，就可以通过遍历访问整个链表，因此第一个结点最重要，一般称为“头结点”

2.2虚拟节点

在做题以及在工程里经常会看到虚拟结点的概念，其实就是一个结点dummyNode，其next指针指向head，也就是dummyNode.next=head。

因此，如果我们在算法里使用了虚拟结点，则要注意如果要获得head结点，或者从方法（函数）里返回的时候，就应该使用dummyNode.next。

注意：dummyNode的val不会被使用，初始化为0或者-1等都是可以的，既然值不会使用，那虚拟结点有啥用？

答：为了方便我们在处理首部结点，否则我们需要在代码里单独处理首部结点的问题。

3.创建链表

3.1 概念：首要要先理解JVM是怎么构建出链表的

我们知道JVM里有栈区和堆区，栈区主要存引用，也就是一个指向实际对象的地址，而堆区存的才是创建的对象。

public class Course{
    Teacher teacher;
    Student student;
}

这里的teacher和student就是指向堆的引用，比如我们再定义一个：

public class Course{
    int val;
    Course next;
}

这个时候 next就指向了下一个同为Course类型的对象了，例如：

这里通过栈中的引用（也就是地址）就可以找到val(1)。然后val(1)结点又存了指向cal(2)的地址，而val(3)又存了指向 val(4)的地址，所以就构造出来了一个链条访问结构。

根据面向对象的理论，在JAVA里规范的链表应该这么定义：

public class ListNode1 {
    private int data;
    private ListNode1 next;
    public ListNode1(int data) {
        this.data = data;
    }
    public int getData() {
        return data;
    }
    public void setData() {
         this.data = data;
    }
    public ListNode1 getNext(){
        return next;
    }
    public void setNext(){
        this.next=next;
    }
}

但是在LeetCode中算法题经常这样的方式来创建链表：

 public class ListNode() {
        public int val;
        public ListNode next;

        ListNode(int x) {
            val = x;
            next = null;
        }
    }

    ListNode listNode = new ListNode(1);

这里的val就是当前结点的值，next指向下一个结点。

因为两个变量都是public的，创建对象后能直接使用listnode.val和listnode.next来操作，虽然违背了面向对象的设计要求，但是上面的代码更为精简，所以在算法题目中应用广泛。

4.链表的增删改查

4.1遍历链表

对于单链表，不管进行什么操作，一定是从头开始逐个向后访问的，所以操作之后是否还能找到表头是非常重要的，“千万注意”->“不能只顾当前位置而将标记表头的指针弄丢了”。

代码如下

public static int getListLength(Node head) {
        int length = 0;
        Node node = head;
        while (node != null) {
            length++;
            node = node.next;
        }
        return length;
    }

4.2链表插入

单链表的插入，和数组插入是一样的，过程不复杂，但是很多坑。

首先单链表插入要考虑三种情况：首部、中部、尾部

4.2.1在链表的表头插入

在链表的表头插入新的结点非常简单，容易出粗的是经常会忘记head需要重新指向表头，当我们创建一个新结点为newNode时，怎么连接到原来的链表上呢？

执行newNode.next=head即可。

但是之后我们还是要遍历新链表就要从newNode开始一路nex向下了，对吧？

但是我们的习惯是让head来表示，所以更改为head=newNode就好。

4.2.2在链表中间插入

step1:先遍历找到要插入的位置，之后将当前位置接入到前驱结点和后继结点之间。

注意：到这里我们发现，既不能获得前驱结点，也无法将结点接入进来。

step2:我们要在目标结点前的一个位置停下来，也就是使用cur.next的值而不是使用cur的值来判断（这是链表最常用的策略）

如下列图，如果要在7的前面插入，当cur.next=node(7)了就应该停下来，此时cur.val=15。然后需要给newNode前后接两根线，此时只能先让new.next=node(15).next（图中虚线），然后node(15).next=new，“顺序不能错”。

为什么顺序不能错呢？

由于每个结点只有一个next，因此执行了node(15).next=new，之后，结点15和7之间的连线就自动断开了，如下图所示：

4.2.3在单链表的结尾插入结点

表尾插入就比较容易，我们只需要将尾结点指向新结点就可以了

综上，我们写出的链表插入的方法如下所示：

/**
     * 
     * @param head 链表头结点
     * @param nodeInsert 带插入结点
     * @param position 带插入位置，从1开始
     * @return 插入后得到的链表头结点
     */
    public static Node insertNode(Node head, Node nodeInsert, int position) {
        if (head == null) {
            return nodeInsert;
        }
        //已经存放的元素个数
        int size = getListlength(head);
        if (position < 1 || position > size + 1) {
            System.out.println("位置参数越界");
            return head;
        }
        if (position == 1) {
            nodeInsert.next = head;
            head = nodeInsert;
            return head;
        }
        Node pNode = head;
        int count = 1;
        while (count < position - 1) {//找要插入的前一个元素
            pNode = pNode.next;
            count++;
        }
        nodeInsert.next = pNode.next;
        pNode.next = nodeInsert;
        return head;
    }

4.3链表的删除

删除同样分为：删除头部元素、中间元素、尾部元素

4.3.1删除表头结点

执行：head=head.next即可。将head向前移动一次之后，原来的结点不可达，就会被JVM回收掉。

4.3.2删除最后一个结点

同样也是要找到“要删除的结点的”前驱结点，这里同样在提前一个位置判断，例如下图中删除40 ，前驱结点是7。遍历的时候需要判断cur.next时候为40，如果是，则执行cur.next=null即可，原来的40结点不可达，就会被JVM回收，

4.3.3删除中间结点

删除中间结点时，也会用cur.next来比较，找到位置后，将cur.next指针的值更新为cur.next.next就可以解决，如下图所示：

完整代码实现：

/**
     * 
     * @param head 链表头结点
     * @param position 删除节点位置，取值从1开始
     * @return 删除后的链表头结点
     */
    public static Node deleteNode(Node head,int position){
        if (head==null){
            return null;
        }
        int size=getListLength(head);
        if (position<1||position>size){
            System.out.println("输入的参数有误");
            return head;
        }
        if (position==1){
            return head.next;
        }else {
            Node cur=head;
            int count=1;
            while (count<position-1){
                cur=cur.next;
                count++;
            }
            Node curNode=cur.next;
            cur.next=curNode.next;
            //上面两行可以直接简化成:cur.next=cur.next.next
        }
        return head;
    }