算法刷题笔记04 | 第二章 链表P1 | 203. 移除链表元素、707.设计链表、206.反转链表

链表理论基础

通过指针连接，存储在内存中不同位置

链表的定义

链表节点的定义，很多同学在面试的时候都写不好。 这是因为平时在刷leetcode的时候，链表的节点都默认定义好了，直接用就行了，所以同学们都没有注意到链表的节点是如何定义的。 而在面试的时候，一旦要自己手写链表，就写的错漏百出。 Java定义链表节点方式：

public class ListNode {
    // 成员变量：
    // 结点的值
    int val;
    // 下一个结点
    ListNode next;

    // 成员方法
    // 节点的构造函数(无参)
    public ListNode() {
    }

    // 节点的构造函数(有一个参数)
    public ListNode(int val) {
        this.val = val;
    }

    // 节点的构造函数(有两个参数)
    public ListNode(int val, ListNode next) {
        this.val = val;
        this.next = next;
    }
}

链表在学校数据结构中学习效果不错，三题大体上都知道总体思路，时间消耗在如何实现思路，可以画图理解。 需要非常清晰整个思路中各个变量应该怎么走后再把思路转化成代码

203.移除链表元素

创建了头节点（由于当时学习数据结构教材中“虚拟头节点”称为“头节点”，因此后面都用头节点表示这意思。题目中的“头节点”表达成第一个元素）

思路：cur走在前面，pre在后面，当cur发现特定值时pre就在cur前面，cur.next = cur.next。否则继续往前搜索。 代码：

public ListNode removeElements(ListNode head, int val) {
    ListNode h = new ListNode(-1, head);// 头节点 - 不可变
    h.next = head;
    ListNode pre = new ListNode();
    pre = h;
    ListNode cur = new ListNode();
    cur = head;

    while (cur != null){
        if(cur.val == val){
            // 扫描到特定值
            pre.next = cur.next;
        }

            // 继续扫描
        else {
            pre = cur;
        }
        cur = cur.next;
    }

    return h.next;
}

707 设计链表

此题为实现链表的增删改查

• MyLinkedList() 初始化 MyLinkedList 对象。
• int get(int index) 获取链表中下标为 index 的节点的值。如果下标无效，则返回 -1 。
• void addAtHead(int val) 将一个值为 val 的节点插入到链表中第一个元素之前。在插入完成后，新节点会成为链表的第一个节点。
• void addAtTail(int val) 将一个值为 val 的节点追加到链表中作为链表的最后一个元素。
• void addAtIndex(int index, int val) 将一个值为 val 的节点插入到链表中下标为 index 的节点之前。如果 index 等于链表的长度，那么该节点会被追加到链表的末尾。如果 index 比长度更大，该节点将 不会插入 到链表中。
• void deleteAtIndex(int index) 如果下标有效，则删除链表中下标为 index 的节点。

代码：

class MyLinkedList {
    int size;
    ListNode h;

    public MyLinkedList() {
        // 定义成员变量
        this.size = 0;
        this.h = new ListNode(0);
    }

    // 获取元素
    /*
	* 获取链表中下标为 index 的节点的值。如果下标无效，则返回 -1
	* */
    public int get(int index) {
        if (index < 0 || index >= size) {
            return -1;
        }
        // 移动指针
        ListNode cur = h.next;
        // 计数 - 一般已知下标找元素用for循环比较好 不知下标遍历则用while
        /* int count = 0;
		   while (count != index){
				if (cur.next == null){
					return -1;
				}
			cur = cur.next;
			count++;
			}*/

        for(int i = 0; i < index; i++){
            cur = cur.next;
        }
        return cur.val;

    }

    // 插入元素
    // 第一个元素
    public void addAtHead(int val) {
        addAtIndex(0,val);
    }

    // 最后元素
    public void addAtTail(int val) {
        addAtIndex(size,val);
    }

    // 指定位置之前
    public void addAtIndex(int index, int val) {
        // 判断 - 当添加到最后元素时,index == size
        if (index > this.size){
            return;
        }

        // 移动指针
        ListNode cur = h;
        // 计数 - 定位到index前一个元素
        for(int i = 0; i < index; i++){
            cur = cur.next;
        }

        ListNode newNode = new ListNode(val);
        newNode.next = cur.next;
        cur.next = newNode;

        this.size++;
    }

    //删除元素
    public void deleteAtIndex(int index) {
        // 判断
        if (index >=  this.size || index < 0){
            return;
        }

        // 移动指针
        ListNode cur = h;
        // 移动到元素之前
        for(int i = 0; i < index; i++){
            cur = cur.next;
        }
        cur.next = cur.next.next;

        this.size--;
    }
}

206 反转链表

采用了双指针写法： 难点：

• 如何实现反转 - 在新链表中前插每一元素
• 前插每一元素如何保存下一元素 - 交换前修改头指针的next并且用一个指针指向待交换元素

代码：

public ListNode reverseList(ListNode head) {
ListNode h = new ListNode(0);
h.next = head;
ListNode cur = head;
// 1.创建一个新链表
ListNode node = new ListNode(0);

// 2.遍历旧链表
while (cur != null) {
    // 在新数组中使用在最前插入法
    h.next = cur.next;// 保存下一个节点
    cur.next = node.next;
    node.next = cur;

    cur = h.next;
}

return node.next;
}