leetcode刷题 (5.8)链表

1. 设计链表

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 个节点。

MyLinkedList linkedList = new MyLinkedList();
linkedList.addAtHead(1);
linkedList.addAtTail(3);
linkedList.addAtIndex(1,2);   //链表变为1-> 2-> 3
linkedList.get(1);            //返回2
linkedList.deleteAtIndex(1);  //现在链表是1-> 3
linkedList.get(1);            //返回3

思路：哑结点，while(index- -)

笔记：
注意：对于双链表而言，在链表后插入节点不是在tail后插入节点，tail也是一种（头结点），相当于插在tail前。
C++:
注意index取值的判断（index是从0开始计），对于查询和删除，index[0, size-1]，对于添加，index[0,size]。

Python:
注意双链表next的初始化

self.head.next = self.tail
self.tail.prev = self.head

C++：

class MyLinkedList {
public:
    // 定义链表结构体
    struct LinkedNode{
        int val;
        LinkedNode* next;
        LinkedNode(int val) : val(val), next(nullptr) {}
    };

    // 初始化链表
    MyLinkedList() {
        dummy = new LinkedNode(0);
        size = 0;
    }

    // 获取第index个节点的val值
    int get(int index) {
        // 若index超出链表长度或index小于0
        if(index > (size - 1) || index < 0) {
            return -1;
        }
        LinkedNode* p = dummy->next;
        while(index--){
            p = p->next;
        }
        return p->val;
    }

    // 将一个结点插入链表头部作为头结点
    void addAtHead(int val) {
        LinkedNode* newNode = new LinkedNode(val);
        newNode->next = dummy->next;
        dummy->next = newNode;
        size++;
    }

    // 在链表尾部插入一个结点
    void addAtTail(int val) {
        LinkedNode* newNode = new LinkedNode(val);
        LinkedNode* p = dummy;
        while(p->next != nullptr){
            p = p->next;
        }
        p->next = newNode;
        size++;
    }

    //在第index个节点前插入一个新结点
    void addAtIndex(int index, int val) {
        // 题目中考虑了index等于链表长度的情况：插入尾部
        if (index > size) {
            return;
        }
        LinkedNode* newNode = new LinkedNode(val);
        LinkedNode* p = dummy;
        while(index--){
            p = p->next;
        }
        newNode->next = p->next;
        p->next = newNode;
        size++;
    }

    // 删除第index个节点,只考虑index[0,size-1],链表不为空
    void deleteAtIndex(int index) {
        if(index >= size || index < 0){
            return;
        }
        LinkedNode* p = dummy;
        while(index--){
            p = p->next;
        }
        LinkedNode* tmp = p->next;
        p->next = p->next->next;
        delete tmp;
        size--;
    }

    // 打印链表
    void printLinkedList(){
        LinkedNode* p = dummy;
        while(p->next != nullptr){
            cout << p->next->val << " ";
            p = p->next;
        }
        cout << endl;
    }
    
private:
    int size;
    LinkedNode* dummy;
};

Python：

# 单链表
class ListNode:

    #初始化结点
    def __init__(self, x):
        self.val = x
        self.next = None


class MyLinkedList:

    #初始化链表结构
    def __init__(self):
        self.dummy = ListNode(0)   # 虚拟头部结点
        self.size = 0         # 链表长度

    def get(self, index: int) -> int:
        """
        Get the value of the index-th node in the linked list.
        """
        if index < 0 or index >= self.size:
            return -1

        p = self.dummy
        for _ in range(index + 1):
            p = p.next
        return p.val

    def addAtHead(self, val: int) -> None:
        """
        Add a node of value val before the first element of the linked list.
        """
        self.addAtIndex(0, val)

    def addAtTail(self, val: int) -> None:
        """
        Append a node of value val to the last element of the linked list.
        """
        self.addAtIndex(self.size, val)

    def addAtIndex(self, index: int, val: int) -> None:
        """
        Add a node of value val before the index-th node in the linked list. 
        """
        if index > self.size:
            return

        # if the index is negative, insert the node at the head of the list.
        if index < 0:
            index = 0

        p = self.dummy
        for _ in range(index):
            p = p.next

        new_node = ListNode(val)
        new_node.next = p.next
        p.next = new_node
        self.size += 1

    def deleteAtIndex(self, index: int) -> None:
        """
        Delete the index-th node in the linked list.
        """
        if index < 0 or index >= self.size:
            return

        p = self.dummy
        for _ in range(index):
            p = p.next

        p.next = p.next.next

        self.size -= 1

# 双链表
class ListNode:
    def __init__(self, x):
        self.val = x
        self.next = None
        self.prev = None

class MyLinkedList:
    def __init__(self):
        self.size = 0
        self.head, self.tail = ListNode(0), ListNode(0) 
        self.head.next = self.tail
        self.tail.prev = self.head
        

    def get(self, index: int) -> int:
        """
        Get the value of the index-th node in the linked list. 
        """
        # if index is invalid
        if index < 0 or index >= self.size:
            return -1
        
        # choose the fastest way
        # index在前半段，从前往后找
        if index + 1 < self.size - index:
            p = self.head
            for _ in range(index + 1):
                p = p.next
        else:
            p = self.tail
            for _ in range(self.size - index):
                p = p.prev
                
        return p.val
            

    def addAtHead(self, val: int) -> None:
        """
        Add a node of value val before the first element of the linked list. 
        """
        pred, succ = self.head, self.head.next
        
        new_node = ListNode(val)
        new_node.prev = pred
        new_node.next = succ
        pred.next = new_node
        succ.prev = new_node
        self.size += 1
        

    def addAtTail(self, val: int) -> None:
        """
        Append a node of value val to the last element of the linked list.
        """
        succ, pred = self.tail, self.tail.prev
        
        new_node = ListNode(val)
        new_node.prev = pred
        new_node.next = succ
        pred.next = new_node
        succ.prev = new_node
        self.size += 1
        

    def addAtIndex(self, index: int, val: int) -> None:
        """
        Add a node of value val before the index-th node in the linked list. 
        """
        if index > self.size:
            return
        if index < 0:
            index = 0
        
        # find predecessor and successor of the node to be added
        if index < self.size - index:
            pred = self.head
            for _ in range(index):
                pred = pred.next
            succ = pred.next
        else:
            succ = self.tail
            for _ in range(self.size - index):
                succ = succ.prev
            pred = succ.prev
        
        # insertion itself
        self.size += 1
        new_node = ListNode(val)
        new_node.prev = pred
        new_node.next = succ
        pred.next = new_node
        succ.prev = new_node
        

    def deleteAtIndex(self, index: int) -> None:
        """
        Delete the index-th node in the linked list, if the index is valid.
        """
        # if the index is invalid, do nothing
        if index < 0 or index >= self.size:
            return
        
        # find predecessor and successor of the node to be deleted
        if index < self.size - index:
            pred = self.head
            for _ in range(index):
                pred = pred.next
            succ = pred.next.next
        else:
            succ = self.tail
            for _ in range(self.size - index - 1):
                succ = succ.prev
            pred = succ.prev.prev
            
        # delete pred.next 
        pred.next = succ
        succ.prev = pred
        self.size -= 1