算法通关村第一关——链表青铜挑战笔记

什么是链表？

链表是一种最基本的结构，普通的单链表就是只给你一个指向链表头的指针head，如果想访问其他元素，就只能从head开始一个个向后找，遍历链表最终会在访问尾结点之后如果继续访问，就会返回null。

怎么理解链表的构建

首先要先理解JVM是怎么构建出链表的，我们知道JVM里有栈区和堆区，栈区主要存引用，也就是一个指向实际对象的地址，而堆区存的才是创建的对象，例如我们定义这样一个类：

/**
 * 在算法中最常用的链表定义方式
 */
public class Teacher {
    public int age;
    public Teacher val;

    public Teacher(int age) {
        this.age = age;
        this.val = null;
    }

    public static void main(String[] args) {
        Teachere teacher1=new Teacher(11);
        Teachere teacher2=new Teacher(12);//这个其实就是在teacher1建立了连接teacher2的关系
    }
}

等同于的关系：

/**
 * 在算法中最常用的链表定义方式
 */
public class ListNode {
    public int val;
    public ListNode next;

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

    public static void main(String[] args) {
        ListNode listnode=new ListNode(1);
    }
}

jvm中的关系图如下：

这就是一个简单的线性访问了，所以链表就是从head开始，逐个开始向后访问，而每次所访问对象的类型都是一样的。根据面向对象的理论，在Java里规范的链表应该这么定义：

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

增删改查

算法的基础是数据结构，任何数据结构的基础都是创建+增删改查，由这几个操作可以构造很多算法题，所以我们也从这五项开始学习链表。

链表的遍历

对于单链表，不管进行什么操作，一定是从头开始逐个向后访问，所以操作之后是否还能找到表头非常重要。

 实现代码如下：

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

添加节点

如图所示：

​

/**
     * 链表插入
     * @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 = getLength(head);
        if (position > size+1  || position < 1) {
            System.out.println("位置参数越界");
            return head;
        }

        //表头插入
        if (position == 1) {
            nodeInsert.next = head;
            // 这里可以直接 return nodeInsert;还可以这么写：
            head = nodeInsert;
            return head;
        }

        Node pNode = head;
        int count = 1;
        //这里position被上面的size被限制住了，不用考虑pNode=null
        while (count < position - 1) {
            pNode = pNode.next;
            count++;
        } 
        nodeInsert.next = pNode.next;
        pNode.next = nodeInsert;

        return head;
    }

 删除节点

​

代码如下：

/**
     * 删除节点
     * @param head     链表头节点
     * @param position 删除节点位置，取值从1开始
     * @return 删除后的链表头节点
     */
    public static Node deleteNode(Node head, int position) {
        if (head == null) {
            return null;
        }
        int size = getListLength(head);
        //思考一下，这里为什么是size，而不是size+1
        if (position > size || position <1) {
            System.out.println("输入的参数有误");
            return head;
        }
        if (position == 1) {
            //curNode就是链表的新head
            return head.next;
        } else {
            Node preNode = head;
            int count = 1;
            while (count < position - 1) {
                preNode = preNode.next;
                count++;
            }
            Node curNode = preNode.next;
            preNode.next = curNode.next;
        }
        return head;
    }