数据结构2 链表（Linked List）

1. 链表：非连续空间，包含当前数据和下一节点的地址。
2. 每个节点包含data域和next域，next域指向下一个节点
3. 单端链表：只能从前一个元素指向后一个元素。
4. 双端链表：可以向下移动，也可以向前移动。
5. 复杂度：

• 访问（access） O（N）
• 搜索 （Search）O（N）
• 插入（Insert） O(1)
• 删除 （Delete）O（1）

6. 特点：写很快，读很慢（读少写多）
7. head节点：

• 不存放具体的数据
• 作用就是表示单链表头（next指向下一个节点）

8. Python链表常用操作：

• 创建链表

linkedlist = deque() 

• 添加元素

linkedlist.append(1)
linkedlist.append(2)
linkedlist.append(3)
print(linkedlist)   #[1,2,3]

linkedlist.insert(2,99)
print(linkedlist)   #[1,2,99,3]

• 访问元素

element = linkedlist[2]
print(element)   #99

• 查找元素

index = linklist.index(99)
print(index)   #2

• 更新元素

linkedlist[2] = 88
print(linkedlist)   #[1,2,88,3]

• 删除元素

lunkedlist.remove(88)
print(linkedlist)   #[1,2,3]

• 链表的长度

length = len(linkedlist)
print(length)

8. java链表常用操作：

• 创建链表

LinkedList<Integer> list = new LinkedList<>();

• 添加元素

list.add(1);
list.add(2);
list.add(3);
System.out.println(list.toString());

list.add(2,99);
System.out.println(list.toString());

• 访问元素

int element = list.get(2);
System.out.println(element);

• 查找元素

int index = list.indexOf(99);
System.out.println(index);

• 更新元素

list.set(2,88);
System.out.println(list.toString());

• 删除元素
  被删除的节点，将不会有其他引用指向，会被垃圾回收机制回收

list.remove(2);
System.out.println(list.toString());

• 链表的长度

int length = list.size();
System.out.println(length);

7. 例题：
   

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def reverseList(self, head: ListNode) -> ListNode:
        dummy = ListNode(0)
        dummy.next = head
        while(head != None and head.next!= None):
            dnext = dummy.next
            hnext = head.next
            dummy.next = hnext
            head.next = hnext.next
            hnext.next = dnext
        return dummy.next

class Solution {
    public ListNode reverseList(ListNode head) {
        ListNode dummy = new ListNode(0);
        dummy.next = head;
        while(head != null && head.next != null){
            ListNode dnext = dummy.next;
            ListNode hnext = head.next;
            dummy.next = head.next;
            head.next = hnext.next;
            hnext.next = dnext;
        }
        return dummy.next; 
    }
}

class Solution:
    def removeElements(self, head: ListNode, val: int) -> ListNode:
        dummy = ListNode(0)
        dummy.next = head
        prev = dummy
        while(head!=None and prev.next!=None):
            if head.val == val:
                prev.next = head.next
                head = prev.next
            else:
                prev = head
                head = head.next
        return dummy.next

class Solution {
    public ListNode removeElements(ListNode head, int val) {
        ListNode dummy =new ListNode(0);
        dummy.next = head;
        ListNode prev = dummy;
        while(head != null && prev.next != null){
            if(head.val == val){
                prev.next = head.next;
                head = head.next;
            }
            else{
                prev = head;
                head = head.next;
            }
        }
        return dummy.next;
    }
}