代码随想录03|203 移除链表元素|707 设计链表|206 反转链表

203 移除链表元素

题目

给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。

思路

总体确实是简单题

空链表或头结点被删空 头结点改变指向

代码

 /**
  * 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 head;
         while (head.val == val){
             if(head.next == null){
                 head = null;
                 return head;
             }
             head = head.next;
         }
         ListNode p = head;
         while(p.next != null){
             if(p.next.val == val){ 
                 if(p.next.next == null){
                     p.next = null;
                     break;
                 }
                 p.next = p.next.next;
             }
             else{
                 p = p.next;
             }
         }
         return head;
     }
 }

过程

emmm，最大的问题是，不会java的链表，还在用 ->next 。。。。

执行错误

1. [] 空集还是没区分到

2. 除了 ->之外，还有 while（！p->next） 语法错误

3. [7,7,7,7] 7 还是没写好重复集

4. 一般，对于要break return 的代码块，要考虑代码的执行顺序一般，对于要break return 的代码块，要考虑代码的执行顺序

5. [1221] 2 报错 错误：若找到，执行了p.next = p.next.next; 还 p = p.next;
   导致原p.next.next跳过比较
   改正：只有没找到才p = p.next;

改良

1. p改为 tmp

2. 虚拟头节点（哨兵）

题解参考

我超，递归！

 public ListNode removeElements(ListNode head, int val) {
         if(head == null) return head;
         head.next=removeElements(head.next,val);
         return head.val == val ? head.next : head;
     }

迭代（哨兵）

 public ListNode removeElements(ListNode head, int val) {
         ListNode dummyHead = new ListNode(0);
         dummyHead.next = head;
         ListNode temp = dummyHead;
         while (temp.next != null) {
             if (temp.next.val == val) {
                 temp.next = temp.next.next;
             } else {
                 temp = temp.next;
             }
         }
         return dummyHead.next;
     }

总结

1. 递归可以自我递归，即用题目本身的方法递归

2. 链表自带递归性，考虑递归

3. 链表解题 考虑虚拟头节点（哨兵）

707 设计链表

题目

设计链表的实现。您可以选择使用单链表或双链表。单链表中的节点应该具有两个属性：val 和 next。val 是当前节点的值，next 是指向下一个节点的指针/引用。如果要使用双向链表，则还需要一个属性 prev 以指示链表中的上一个节点。假设链表中的所有节点都是 0-index 的。

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

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

力扣

思路

emm不太会构造，看题解了；

代码

 class MyLinkedList {
     class Node{
         int val;
         Node prev,next;
         Node(int nval){
             this.val = nval;
         }
     }
     Node head = new Node(-1);
     Node tail = new Node(-1);
     int size = 0;
 ​
     public MyLinkedList() {
         
         head.next = tail;
         tail.prev = head;
     }
     
     public int get(int index) {
         if (index < 0  || index >size)return -1;
         Node tmp = head.next;
         for(int i = 0;i < index ;i++){
             tmp = tmp.next;
         }
         return tmp.val;
     }
     
     public void addAtHead(int val) {
         Node tmp = new Node(val);
         tmp.next = head.next;
         tmp.prev = head;
         head.next.prev = tmp;
         head.next = tmp;
         ++size;
     }
     
     public void addAtTail(int val) {
         Node tmp = new Node(val);
         tmp.next = tail;
         tmp.prev = tail.prev;
         tail.prev.next = tmp;
         tail.prev = tmp;
         ++size;
     }
     
     public void addAtIndex(int index, int val) {
         if(index <= 0)addAtHead(val);
         else if(index > size) return;
         else if(index == size)addAtTail(val);
         else{
             Node tmp = head.next;
             Node cur = new Node(val);
             for(int i = 0;i < index ;i++){
                 tmp = tmp.next;
             }
             cur.prev = tmp.prev;
             cur.next = tmp;
             tmp.prev.next =cur;
             tmp.prev = cur;
         }
         ++size;
     }
 ​
     public void deleteAtIndex(int index) {
         if (index < 0 || index >= size)return;
         Node tmp = head.next;
         if(tmp.val == -1)return;
         for(int i = 0;i < index ;i++){
             tmp = tmp.next;
         }
         if(tmp.val == -1)return;
         tmp.prev.next = tmp.next;
         tmp.next.prev = tmp.prev;
         --size;
     }
 }
 ​
 /**
  * Your MyLinkedList object will be instantiated and called as such:
  * MyLinkedList obj = new MyLinkedList();
  * int param_1 = obj.get(index);
  * obj.addAtHead(val);
  * obj.addAtTail(val);
  * obj.addAtIndex(index,val);
  * obj.deleteAtIndex(index);
  */

过程

执行错误

1. java没有struct只有class

2. 构造器 Node{}{}错了 ，应该是Node （）{}

3. 又忘了更改size了

4. head、tail、size 要声明在外边

5. void方法 不用return

6. 捏麻的为啥index从0开始，太bt了

7. delect 要考虑空集，要考虑最后一个 所以用 tmp.val == -1 判断（tail和head的val=-1）

题解笔记

总结

麻了，明天再说

206 反转链表

题目

给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。

力扣

思路

还行吧，有个问题就是形参，比如p=head，那修改p会修改head吗

代码

 class Solution {
     public ListNode reverseList(ListNode head) {
         if (head == null)return head;
         ListNode ans = new ListNode(head.val);
         while (head.next != null){
             head = head.next;
             ans = new ListNode(head.val,ans);
         }
         return ans;
     }
 }

题解笔记

1.三指针 ，涉及到有个问题就是行参的问题

 tmp = cur.next;//记录当前节点的下一个节点       
 cur.next = pre;//然后将当前节点指向pre       
 pre = cur;//pre和cur节点都前进一位
 cur = tmp;

2.递归

 public ListNode reverseList(ListNode head) {
         //递归终止条件是当前为空，或者下一个节点为空
         if(head==null || head.next==null) return head;
         ListNode cur = reverseList(head.next);//这里的cur就是最后一个节点
         head.next.next = head;
         head.next = null;//防止链表循环，需要将head.next设置为空
         return cur;//每层递归函数都返回cur，也就是最后一个节点
     }

总结

日记

链表基本构造好恼火。今天又摆烂了

明天一定