From ce5c5d010a778e9aadcacf903192b1da445206ff Mon Sep 17 00:00:00 2001
From: Tcotyledons <53686585+Tcotyledons@users.noreply.github.com>
Date: Tue, 13 Sep 2022 13:30:31 +0800
Subject: [PATCH 1/3] =?UTF-8?q?Create=20707=E8=AE=BE=E8=AE=A1=E9=93=BE?=
 =?UTF-8?q?=E8=A1=A8java=E4=BB=A3=E7=A0=81=E7=9A=84=E4=BF=AE=E6=94=B9?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

代码随想录网址上链表中的力扣707设计链表中的java代码：1，对于单链表的操作，删除元素的for循环跳出条件有误，进行了修改；2，对于双向链表，进行了插入头，尾元素和插入元素的统一操作。自己在原作者基础上写了一份设计链表的java代码。
---
 707设计链表java代码的修改 | 187 +++++++++++++++++++++++++++++
 1 file changed, 187 insertions(+)
 create mode 100644 707设计链表java代码的修改

diff --git a/707设计链表java代码的修改 b/707设计链表java代码的修改
new file mode 100644
index 00000000..bf27e266
--- /dev/null
+++ b/707设计链表java代码的修改
@@ -0,0 +1,187 @@
+//原来的代码随想录707设计链表的java代码中单链表的设计中有错误，修正后并对双链表进行了简化和更正，下面是我的java代码
+
+//单链表
+class ListNode{
+    int val;
+    ListNode next;
+    ListNode() {};
+    ListNode(int val){
+        this.val = val;
+    }
+}
+
+
+class MyLinkedList {  
+
+    //记录链表中元素的数量
+    int size;
+    //记录链表的虚拟头结点
+    ListNode head;
+    
+    public MyLinkedList() {
+        //初始化操作
+        this.size = 0;
+        this.head = new ListNode(0);
+        this.head.next = null;
+    }
+    
+    public int get(int index) {
+        //判断index是否有效
+        if(index<0 || index>=size){
+            return -1;
+        }
+        ListNode cur = this.head;
+        //index 是可以取到的，因为有虚拟头结点
+        for(int i=0; i<= index; i++){
+            cur = cur.next; 
+        }
+        return cur.val;
+    }
+    
+    public void addAtHead(int val) {
+        //等价于在第0个元素前添加
+        addAtIndex(0,val);
+    }
+    
+    public void addAtTail(int val) {
+        //等价于在最后一个元素(null)前添加
+        addAtIndex(size,val);
+    }
+    
+    public void addAtIndex(int index, int val) {
+        //index大于链表长度
+        if(index>size){
+            return;
+        }
+        //index小于0
+        if(index<0){
+            index = 0;
+        }
+        size++;
+        //找到前驱
+        ListNode pre = this.head;
+        for(int i=0; i<index; i++){
+            pre = pre.next;
+        }
+        //新建结点
+        ListNode newNode = new ListNode(val);
+        newNode.next = pre.next;
+        pre.next = newNode; 
+    }
+    
+    public void deleteAtIndex(int index) {
+        //判断索引是否有效
+        if(index<0 || index>=size){
+            return;
+        }
+        //删除操作
+        size--;
+        ListNode pre = this.head;
+        for(int i=0; i<index; i++){
+            pre = pre.next;
+        }
+        pre.next = pre.next.next;
+
+    }
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------
+//双向链表
+class ListNode{
+    int val;
+    ListNode next,prev;
+    ListNode() {};
+    ListNode(int val){
+        this.val = val;
+    }
+}
+
+
+class MyLinkedList {  
+
+    //记录链表中元素的数量
+    int size;
+    //记录链表的虚拟头结点和尾结点
+    ListNode head,tail;
+    
+    public MyLinkedList() {
+        //初始化操作
+        this.size = 0;
+        this.head = new ListNode(0);
+        this.tail = new ListNode(0);
+        //这一步非常关键，否则在加入头结点的操作中会出现null.next的错误！！！
+        head.next=tail;
+        tail.prev=head;
+    }
+    
+    public int get(int index) {
+        //判断index是否有效
+        if(index<0 || index>=size){
+            return -1;
+        }
+        ListNode cur = this.head;
+        //判断是哪一边遍历时间更短
+        if(index >= size / 2){
+            //tail开始
+            cur = tail;
+            for(int i=0; i< size-index; i++){
+                cur = cur.prev;
+            }
+        }else{
+            for(int i=0; i<= index; i++){
+                cur = cur.next; 
+            }
+        }
+        return cur.val;
+    }
+    
+    public void addAtHead(int val) {
+        //等价于在第0个元素前添加
+        addAtIndex(0,val);
+    }
+    
+    public void addAtTail(int val) {
+        //等价于在最后一个元素(null)前添加
+        addAtIndex(size,val);
+    }
+    
+    public void addAtIndex(int index, int val) {
+        //index大于链表长度
+        if(index>size){
+            return;
+        }
+        //index小于0
+        if(index<0){
+            index = 0;
+        }
+        size++;
+        //找到前驱
+        ListNode pre = this.head;
+        for(int i=0; i<index; i++){
+            pre = pre.next;
+        }
+        //新建结点
+        ListNode newNode = new ListNode(val);
+        newNode.next = pre.next;
+        pre.next.prev = newNode;
+        newNode.prev = pre;
+        pre.next = newNode;
+        
+    }
+    
+    public void deleteAtIndex(int index) {
+        //判断索引是否有效
+        if(index<0 || index>=size){
+            return;
+        }
+        //删除操作
+        size--;
+        ListNode pre = this.head;
+        for(int i=0; i<index; i++){
+            pre = pre.next;
+        }
+        pre.next.next.prev = pre;
+        pre.next = pre.next.next;
+    }
+}
+

From 4e32c931a304f3c7344bafb13dcba14f77ee3456 Mon Sep 17 00:00:00 2001
From: Tcotyledons <53686585+Tcotyledons@users.noreply.github.com>
Date: Tue, 13 Sep 2022 13:37:28 +0800
Subject: [PATCH 2/3] =?UTF-8?q?Delete=20707=E8=AE=BE=E8=AE=A1=E9=93=BE?=
 =?UTF-8?q?=E8=A1=A8java=E4=BB=A3=E7=A0=81=E7=9A=84=E4=BF=AE=E6=94=B9?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 707设计链表java代码的修改 | 187 -----------------------------
 1 file changed, 187 deletions(-)
 delete mode 100644 707设计链表java代码的修改

diff --git a/707设计链表java代码的修改 b/707设计链表java代码的修改
deleted file mode 100644
index bf27e266..00000000
--- a/707设计链表java代码的修改
+++ /dev/null
@@ -1,187 +0,0 @@
-//原来的代码随想录707设计链表的java代码中单链表的设计中有错误，修正后并对双链表进行了简化和更正，下面是我的java代码
-
-//单链表
-class ListNode{
-    int val;
-    ListNode next;
-    ListNode() {};
-    ListNode(int val){
-        this.val = val;
-    }
-}
-
-
-class MyLinkedList {  
-
-    //记录链表中元素的数量
-    int size;
-    //记录链表的虚拟头结点
-    ListNode head;
-    
-    public MyLinkedList() {
-        //初始化操作
-        this.size = 0;
-        this.head = new ListNode(0);
-        this.head.next = null;
-    }
-    
-    public int get(int index) {
-        //判断index是否有效
-        if(index<0 || index>=size){
-            return -1;
-        }
-        ListNode cur = this.head;
-        //index 是可以取到的，因为有虚拟头结点
-        for(int i=0; i<= index; i++){
-            cur = cur.next; 
-        }
-        return cur.val;
-    }
-    
-    public void addAtHead(int val) {
-        //等价于在第0个元素前添加
-        addAtIndex(0,val);
-    }
-    
-    public void addAtTail(int val) {
-        //等价于在最后一个元素(null)前添加
-        addAtIndex(size,val);
-    }
-    
-    public void addAtIndex(int index, int val) {
-        //index大于链表长度
-        if(index>size){
-            return;
-        }
-        //index小于0
-        if(index<0){
-            index = 0;
-        }
-        size++;
-        //找到前驱
-        ListNode pre = this.head;
-        for(int i=0; i<index; i++){
-            pre = pre.next;
-        }
-        //新建结点
-        ListNode newNode = new ListNode(val);
-        newNode.next = pre.next;
-        pre.next = newNode; 
-    }
-    
-    public void deleteAtIndex(int index) {
-        //判断索引是否有效
-        if(index<0 || index>=size){
-            return;
-        }
-        //删除操作
-        size--;
-        ListNode pre = this.head;
-        for(int i=0; i<index; i++){
-            pre = pre.next;
-        }
-        pre.next = pre.next.next;
-
-    }
-}
-
-//-------------------------------------------------------------------------------------------------------------------------------
-//双向链表
-class ListNode{
-    int val;
-    ListNode next,prev;
-    ListNode() {};
-    ListNode(int val){
-        this.val = val;
-    }
-}
-
-
-class MyLinkedList {  
-
-    //记录链表中元素的数量
-    int size;
-    //记录链表的虚拟头结点和尾结点
-    ListNode head,tail;
-    
-    public MyLinkedList() {
-        //初始化操作
-        this.size = 0;
-        this.head = new ListNode(0);
-        this.tail = new ListNode(0);
-        //这一步非常关键，否则在加入头结点的操作中会出现null.next的错误！！！
-        head.next=tail;
-        tail.prev=head;
-    }
-    
-    public int get(int index) {
-        //判断index是否有效
-        if(index<0 || index>=size){
-            return -1;
-        }
-        ListNode cur = this.head;
-        //判断是哪一边遍历时间更短
-        if(index >= size / 2){
-            //tail开始
-            cur = tail;
-            for(int i=0; i< size-index; i++){
-                cur = cur.prev;
-            }
-        }else{
-            for(int i=0; i<= index; i++){
-                cur = cur.next; 
-            }
-        }
-        return cur.val;
-    }
-    
-    public void addAtHead(int val) {
-        //等价于在第0个元素前添加
-        addAtIndex(0,val);
-    }
-    
-    public void addAtTail(int val) {
-        //等价于在最后一个元素(null)前添加
-        addAtIndex(size,val);
-    }
-    
-    public void addAtIndex(int index, int val) {
-        //index大于链表长度
-        if(index>size){
-            return;
-        }
-        //index小于0
-        if(index<0){
-            index = 0;
-        }
-        size++;
-        //找到前驱
-        ListNode pre = this.head;
-        for(int i=0; i<index; i++){
-            pre = pre.next;
-        }
-        //新建结点
-        ListNode newNode = new ListNode(val);
-        newNode.next = pre.next;
-        pre.next.prev = newNode;
-        newNode.prev = pre;
-        pre.next = newNode;
-        
-    }
-    
-    public void deleteAtIndex(int index) {
-        //判断索引是否有效
-        if(index<0 || index>=size){
-            return;
-        }
-        //删除操作
-        size--;
-        ListNode pre = this.head;
-        for(int i=0; i<index; i++){
-            pre = pre.next;
-        }
-        pre.next.next.prev = pre;
-        pre.next = pre.next.next;
-    }
-}
-

From 235c02eb9d7b4cf9803c04cb5654d4ecb5baa1ad Mon Sep 17 00:00:00 2001
From: Tcotyledons <53686585+Tcotyledons@users.noreply.github.com>
Date: Tue, 13 Sep 2022 13:41:00 +0800
Subject: [PATCH 3/3] =?UTF-8?q?Update=200707.=E8=AE=BE=E8=AE=A1=E9=93=BE?=
 =?UTF-8?q?=E8=A1=A8.md?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

修改了java版本的：1，单链表中的删除元素的循环跳出条件，2，自己优化了实现了双链表中插入元素的统一，无需单独实现头部插入和尾部插入
---
 problems/0707.设计链表.md | 127 ++++++++++++++++++----------------
 1 file changed, 68 insertions(+), 59 deletions(-)

diff --git a/problems/0707.设计链表.md b/problems/0707.设计链表.md
index 42912eda..83e57fec 100644
--- a/problems/0707.设计链表.md
+++ b/problems/0707.设计链表.md
@@ -358,7 +358,7 @@ class MyLinkedList {
 	    return;
         }
         ListNode pred = head;
-        for (int i = 0; i < index - 1; i++) {
+        for (int i = 0; i < index ; i++) {
             pred = pred.next;
         }
         pred.next = pred.next.next;
@@ -366,92 +366,101 @@ class MyLinkedList {
 }
 
 //双链表
-class MyLinkedList {
-    class ListNode {
-        int val;
-        ListNode next,prev;
-        ListNode(int x) {val = x;}
+class ListNode{
+    int val;
+    ListNode next,prev;
+    ListNode() {};
+    ListNode(int val){
+        this.val = val;
     }
+}
 
+
+class MyLinkedList {  
+
+    //记录链表中元素的数量
     int size;
-    ListNode head,tail;//Sentinel node
-
-    /** Initialize your data structure here. */
+    //记录链表的虚拟头结点和尾结点
+    ListNode head,tail;
+    
     public MyLinkedList() {
-        size = 0;
-        head = new ListNode(0);
-        tail = new ListNode(0);
-        head.next = tail;
-        tail.prev = head;
+        //初始化操作
+        this.size = 0;
+        this.head = new ListNode(0);
+        this.tail = new ListNode(0);
+        //这一步非常关键，否则在加入头结点的操作中会出现null.next的错误！！！
+        head.next=tail;
+        tail.prev=head;
     }
     
-    /** Get the value of the index-th node in the linked list. If the index is invalid, return -1. */
     public int get(int index) {
-        if(index < 0 || index >= size){return -1;}
-        ListNode cur = head;
-
-        // 通过判断 index < (size - 1) / 2 来决定是从头结点还是尾节点遍历，提高效率
-        if(index < (size - 1) / 2){
-            for(int i = 0; i <= index; i++){
-                cur = cur.next;
-            }            
-        }else{
+        //判断index是否有效
+        if(index<0 || index>=size){
+            return -1;
+        }
+        ListNode cur = this.head;
+        //判断是哪一边遍历时间更短
+        if(index >= size / 2){
+            //tail开始
             cur = tail;
-            for(int i = 0; i <= size - index - 1; i++){
+            for(int i=0; i< size-index; i++){
                 cur = cur.prev;
             }
+        }else{
+            for(int i=0; i<= index; i++){
+                cur = cur.next; 
+            }
         }
         return cur.val;
     }
     
-    /** Add a node of value val before the first element of the linked list. After the insertion, the new node will be the first node of the linked list. */
     public void addAtHead(int val) {
-        ListNode cur = head;
-        ListNode newNode = new ListNode(val);
-        newNode.next = cur.next;
-        cur.next.prev = newNode;
-        cur.next = newNode;
-        newNode.prev = cur;
-        size++;
+        //等价于在第0个元素前添加
+        addAtIndex(0,val);
     }
     
-    /** Append a node of value val to the last element of the linked list. */
     public void addAtTail(int val) {
-        ListNode cur = tail;
-        ListNode newNode = new ListNode(val);
-        newNode.next = tail;
-        newNode.prev = cur.prev;
-        cur.prev.next = newNode;
-        cur.prev = newNode;
-        size++;
+        //等价于在最后一个元素(null)前添加
+        addAtIndex(size,val);
     }
     
-    /** Add a node of value val before the index-th node in the linked list. If index equals to the length of linked list, the node will be appended to the end of linked list. If index is greater than the length, the node will not be inserted. */
     public void addAtIndex(int index, int val) {
-        if(index > size){return;}
-        if(index < 0){index = 0;}
-        ListNode cur = head;
-        for(int i = 0; i < index; i++){
-            cur = cur.next;
+        //index大于链表长度
+        if(index>size){
+            return;
+        }
+        //index小于0
+        if(index<0){
+            index = 0;
         }
-        ListNode newNode = new ListNode(val);
-        newNode.next = cur.next;
-        cur.next.prev = newNode;
-        newNode.prev = cur;
-        cur.next = newNode;
         size++;
+        //找到前驱
+        ListNode pre = this.head;
+        for(int i=0; i<index; i++){
+            pre = pre.next;
+        }
+        //新建结点
+        ListNode newNode = new ListNode(val);
+        newNode.next = pre.next;
+        pre.next.prev = newNode;
+        newNode.prev = pre;
+        pre.next = newNode;
+        
     }
     
-    /** Delete the index-th node in the linked list, if the index is valid. */
     public void deleteAtIndex(int index) {
-        if(index >= size || index < 0){return;}
-        ListNode cur = head;
-        for(int i = 0; i < index; i++){
-            cur = cur.next;
+        //判断索引是否有效
+        if(index<0 || index>=size){
+            return;
         }
-        cur.next.next.prev = cur;
-        cur.next = cur.next.next;
+        //删除操作
         size--;
+        ListNode pre = this.head;
+        for(int i=0; i<index; i++){
+            pre = pre.next;
+        }
+        pre.next.next.prev = pre;
+        pre.next = pre.next.next;
     }
 }