leetcode算法练习——203.移除链表元素/707.设计链表/206.反转链表

leetcode算法练习

203.移除链表元素

思路：
普通方法：对与头结点和非头结点的删除进行不同的操作
构造虚拟头结点：上述普通方法较繁琐 可以构造虚拟头结点来使得删除头结点和非头结点的操作一致

**注意点：
1. 普通方法：移除头结点和非头结点的操作是不一样的
非头结点：找到这个结点的前一个结点 指向这个结点的下一个结点
头结点：把头结点往后移一个

方法一：普通方法（伪代码）

// 删除头结点
while(head != null && head.val == target){
    // 要用while 而不是if 因为删除头结点是一个连续的过程 例如：1 1 1 1 删除1
    head = head.next;
}
// 删除非头结点
// 因为是单向链表 所以不能往回 那么cur应该指向head 而不是head.next 通过.next.val来判断
cur = head;
while(cur != null && cur.next != null){
    if(cur.next.val == target){
        cur.next = cur.next.next;
    }else{
        cur = cur.next;
    }
}
// 定义了一个临时的指针cur 用它来遍历 head还是指向原来的链表
return head;

方法二：构造虚拟头结点

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val; //节点上存储的元素
 *     ListNode next; //指向下一个节点的指针
 *     ListNode() {} //节点的构造函数(无参)
 *     ListNode(int val) { this.val = val; } //节点的构造函数(有一个参数)
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; } //节点的构造函数(有两个参数)
 * }
 */
class Solution {
    public ListNode removeElements(ListNode head, int val) {
        if(head == null) {
            return null;
        }
        // 创建虚拟头结点
        ListNode newHead = new ListNode();
        newHead.next = head;
        ListNode p = head;
        ListNode q = newHead;
        while(p != null) {
            if(p.val == val) {
                q.next = p.next;
            }else {
                q = p;
            }
            p = p.next;
        }
        return newHead.next;
    }
}

707.设计链表

题目链接

注意点：
首先要把握链表的创建代码：
1. 数值
3. 指针域
4. 无参构造方法
5. 有参构造方法
其次要注意index是从0开始的
再者 每次插入删除的指针移动顺序要搞清楚

//单链表
class ListNode {
    int val;
    ListNode next;
    ListNode(){}
    ListNode(int val) {
        this.val=val;
    }
}
class MyLinkedList {
    int size;// 链表元素个数
    ListNode dummyHead; // 虚拟头结点

    // 初始化链表
    public MyLinkedList() {
        size = 0;
        dummyHead = new ListNode(0); // 初始化一个空节点 初始赋值为0 指针指向为dummyHead
    }

    // 获取链表中第index个节点的值(index从0开始) 如果索引无效 则返回-1
    public int get(int index) {
        //如果index非法，返回-1
        if (index >= size || index < 0) {
            return -1;
        }
        ListNode currentNode = dummyHead;
        ListNode p = dummyHead;
        for (int i = 0; i <= index; i++) {
            p = p.next;
        }
        return p.val;
    }

    //在链表最前面插入一个节点
    public void addAtHead(int val) {
        addAtIndex(0, val);
        /**
        ListNode q = dummyHead;
        q.next = dummyHead.next;
        dummyHead.next = q;
        size++;
         */
    }

    //在链表的最后插入一个节点
    public void addAtTail(int val) {
        addAtIndex(size, val);
        /**
        ListNode newNode = new ListNode(val);
        ListNode q = new ListNode();
        q = dummyHead.next;
        while (q.next != null) {
            q = q.next;
        }
        q.next = newNode;
        size++;
         */
    }

    /**
        在链表中的第index个节点之前添加值为val的节点
        index == 链表的长度 则该节点将附加到链表的末尾
        index > 链表长度 则不会插入节点
        index < 0 则在头部插入节点
     */
    public void addAtIndex(int index, int val) {
        if (index > size) {
            return;
        }
        if (index < 0) {
            index = 0;
        }
        // 找到要插入节点的前驱
        ListNode q = dummyHead;
        for (int i = 0; i < index; i++) {
            q = q.next;
        }
        ListNode newNode = new ListNode(val);
        newNode.next = q.next;
        q.next = newNode;
        size++;
    }

    // 如果索引index有效 则删除链表中的第index个节点
    public void deleteAtIndex(int index) {
        if (index < 0 || index >= size) {
            return;
        }
        ListNode q = new ListNode();
        q = dummyHead;
        while (index-- != 0) {
            q = q.next;
        }
        q.next = q.next.next;
        size--;
    }
}

206.反转链表

题目链接

思路：
双指针解法：定义一个指针cur 再定义一个指针pre pre在cur的前面 改变cur.next指向pre 而后将pre和cur往后移动
双指针解法——》递归解法
递归解法：
递归的逻辑和双指针的逻辑一样 可以根据双指针改写

注意点：
1. cur和pre的初始化
cur指向head 那么pre在其前面 那就应该初始化为null 为了head翻转后变成尾结点 要指向空
2. while遍历 什么时候遍历结束
终止条件：cur指向空 此时pre指向尾结点 此时不需要将null指向尾结点 即无需翻转了

方法一：双指针

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode reverseList(ListNode head) {
        ListNode cur = head;
        ListNode pre = null;
        ListNode temp = null;
        while(cur != null){
            // 创建一个临时结点temp
            temp = cur.next;
            cur.next = pre;
            // 往后移动
            pre = cur;
            cur = temp; 
        }
        // 返回新链表的头结点
        return pre;
    }
}

方法二：递归

// 递归 
class Solution {
	// 主函数调用 使链表翻转
    public ListNode reverseList(ListNode head) {
    	// 和双指针一样的思路 双指针中cur赋值head pre赋值null 此处同理
        return reverse(null, head);
    }

    private ListNode reverse(ListNode prev, ListNode cur) {
    	// 和双指针的遍历结束条件一样 结束的时候头结点是pre 故返回pre 直接返回给主函数
        if (cur == null) {
            return prev;
        }
        ListNode temp = null;
        temp = cur.next;// 先保存下一个节点
        cur.next = prev;// 反转
        // 双指针是往后移一位 是一遍循环 那在此处就是进入下一层递归
    	// 即赋值 pre = cur; cur = temp; 
        return reverse(cur, temp);
    }
}