代码随想录训练营第三天|LeetCode203移除链表元素、LeetCode707设计链表、LeetCode206反转链表

一、移除链表元素

        题目：

                题意：删除链表中等于给定值 val 的所有节点。

                示例 1：
                        输入：head = [1,2,6,3,4,5,6], val = 6
                        输出：[1,2,3,4,5]

                示例 2：
                        输入：head = [], val = 1
                        输出：[]

                示例 3：
                        输入：head = [7,7,7,7], val = 7
                        输出：[]

                   题目链接：移除链表元素

        思路：

                1.直接在原链表中删除

                        一开始的想法就是先进行一下对链表头的操作，当head的值=val时，head=head.next,直到head.val!=val，结束对头的操作；

                        设置temp=head，当temp！=null时，

                        进行下一层循环，当temp.next!=null并且temp.next.val==val时，temp.next=temp.next.next

                        结束这层循环，temp=temp.next，继续一开始的循环直到temp==null

                        代码如下：

 public ListNode removeElements(ListNode head, int val) {
        while(head!=null&&head.val==val){
            head=head.next;
        }
        ListNode temp=head;
        while(temp!=null){
            while(temp.next!=null&&temp.next.val==val){
                temp.next=temp.next.next;
            }
            temp=temp.next;
        }
        return head;

    }

                2.设立一个虚拟的头

                        这个思路就是设置一个新的头，值为-1，直接进行正常思路下面循环的判断（只要判断下一个的val是否等于val即可）

                        代码如下：

    public ListNode removeElements(ListNode head, int val) {
            if(head==null)
                return null;
            ListNode curNode=new ListNode(-1,head);
            ListNode pre=curNode;
            ListNode cur=head;

            while(cur!=null){
                if(cur.val==val){
                    pre.next=cur.next;
                }else{
                    pre=cur;
                }
                cur=cur.next;
            }
            return curNode.next;


    }

二、设计链表

        题目：

      在链表类中实现这些功能：

• get(index)：获取链表中第 index 个节点的值。如果索引无效，则返回-1。
• addAtHead(val)：在链表的第一个元素之前添加一个值为 val 的节点。插入后，新节点将成为链表的第一个节点。
• addAtTail(val)：将值为 val 的节点追加到链表的最后一个元素。
• addAtIndex(index,val)：在链表中的第 index 个节点之前添加值为 val  的节点。如果 index 等于链表的长度，则该节点将附加到链表的末尾。如果 index 大于链表长度，则不会插入节点。如果index小于0，则在头部插入节点。
• deleteAtIndex(index)：如果索引 index 有效，则删除链表中的第 index 个节点。

        没有思路，直接看代码

       代码如下：

                

class MyLinkedList {
  
    int size;
   
    ListNode head;
   
    public MyLinkedList() {
        size = 0;
        head = new ListNode(0);
    }


    public int get(int index) {
        if (index < 0 || index >= size) {
            return -1;
        }
        ListNode currentNode = head;
        for (int i = 0; i <= index; i++) {
            currentNode = currentNode.next;
        }
        return currentNode.val;
    }

    public void addAtHead(int val) {
        addAtIndex(0, val);
    }

    public void addAtTail(int val) {
        addAtIndex(size, val);
    }
    public void addAtIndex(int index, int val) {
        if (index > size) {
            return;
        }
        if (index < 0) {
            index = 0;
        }
        size++;
        ListNode pred = head;
        for (int i = 0; i < index; i++) {
            pred = pred.next;
        }
        ListNode toAdd = new ListNode(val);
        toAdd.next = pred.next;
        pred.next = toAdd;
    }


    public void deleteAtIndex(int index) {
        if (index < 0 || index >= size) {
            return;
        }
        size--;
        if (index == 0) {
            head = head.next;
	    return;
        }
        ListNode pred = head;
        for (int i = 0; i < index ; i++) {
            pred = pred.next;
        }
        pred.next = pred.next.next;
    }
}

三、翻转列表

        题目：反转链表

                题意：反转一个单链表。

                示例: 输入: 1->2->3->4->5->NULL 输出: 5->4->3->2->1->NULL

        思路：

                1.双指针

                        创建一个新的指针头pre=null，temp为临时指针，cur为剩余链表的头（开始等于head）

                        当cur!=null，temp=cur.next

                        cur.next=pre（头变尾指向null）

                        pre=cur（将新链表的头给pre)

                        cur=temp(cur变为剩余链表的头)

        

                        循环结束，返回pre

                        代码如下：

 public ListNode reverseList(ListNode head) {
        ListNode temp=null;
        ListNode cur=head;
        ListNode pre=null;
        while(cur!=null){
            temp=cur.next;
            cur.next=pre;
            pre=cur;
            cur=temp;
        }
        return pre;
    }

                2.递归求解

                        思路和双指针类似，具体小变化写在代码中

                        代码如下：

  public ListNode reverseList(ListNode head) {
        return reverse(null, head);
    }

    private ListNode reverse(ListNode pre, ListNode cur) {
        if(cur==null)
            return null;
        ListNode temp=null;
        temp=cur.next;//临时指针为剩余链表的头
        cur.next=pre;//头遍尾指向pre

        return reverse(cur,temp);//cur为新链表的头，temp是剩余链表的头，继续递归
    }

总结

                第三天，没想到第三天就差点坚持不下来，但还是不要轻易放弃，中间创建链表的双指针没有写，思路很简单，但是时间太长就没写，明天拿来练手，继续加油(ง •_•)ง