[leetcode]指针

707. Design Linked List

Design your implementation of the linked list. You can choose to use a singly or doubly linked list.
A node in a singly linked list should have two attributes: val and next. val is the value of the current node, and next is a pointer/reference to the next node.
If you want to use the doubly linked list, you will need one more attribute prev to indicate the previous node in the linked list. Assume all nodes in the linked list are 0-indexed.

Implement the MyLinkedList class:

• MyLinkedList() Initializes the MyLinkedList object.
• int get(int index) Get the value of the indexth node in the linked list. If the index is invalid, return -1.
• void addAtHead(int 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.
• void addAtTail(int val) Append a node of value val as the last element of the linked list.
• void addAtIndex(int index, int val) Add a node of value val before the indexth node in the linked list. If index equals the length of the linked list, the node will be appended to the end of the linked list. If index is greater than the length, the node will not be inserted.
• void deleteAtIndex(int index) Delete the indexth node in the linked list, if the index is valid.

Example 1:

Input
["MyLinkedList", "addAtHead", "addAtTail", "addAtIndex", "get", "deleteAtIndex", "get"]
[[], [1], [3], [1, 2], [1], [1], [1]]
Output
[null, null, null, null, 2, null, 3]

Explanation
MyLinkedList myLinkedList = new MyLinkedList();
myLinkedList.addAtHead(1);
myLinkedList.addAtTail(3);
myLinkedList.addAtIndex(1, 2);    // linked list becomes 1->2->3
myLinkedList.get(1);              // return 2
myLinkedList.deleteAtIndex(1);    // now the linked list is 1->3
myLinkedList.get(1);              // return 3

Constraints:

• 0 <= index, val <= 1000
• Please do not use the built-in LinkedList library.
• At most 2000 calls will be made to get, addAtHead, addAtTail, addAtIndex and deleteAtIndex.

考察指针的基本操作。

1.首先结构体定义指针，注意构造函数的写法，并且写一个初始化的。

2.注意index开始是0. 先设置一个虚拟头节点，这样在0插入的时候就是直接在头节点下一位插入

3.注意delete时要手动删除该节点

4.定义一个size来防止越界

5.注意空指针的写法是nullptr.

class MyLinkedList {
public:
    struct LinkedNode{
        int val;
        LinkedNode* next;
        LinkedNode(int val):val(val),next(nullptr){}
    };
    MyLinkedList() {
        dummyHead=new LinkedNode(0);
        size=0;
    }
    
    int get(int index) {
        if(index<0||index>size-1)
            return -1;
        LinkedNode* cur = dummyHead->next;  
        while(index--){
           cur=cur->next;
        }
        return cur->val;
    }
    
    void addAtHead(int val) {
        LinkedNode* cur = new LinkedNode(val);
        cur->next=dummyHead->next;
        dummyHead->next=cur;
        size++;
    }
    
    void addAtTail(int val) {
        LinkedNode* cur = dummyHead;
        while(cur->next!=nullptr){
            cur=cur->next;
        }
        LinkedNode* add = new LinkedNode(val);
        cur->next=add;
        size++;
    }
    
    void addAtIndex(int index, int val) {
        //注意这里可以等于size， 等于size说明是想在链表末端插入。
        if(index<0||index>size)
            return;
        LinkedNode* cur = dummyHead;
        LinkedNode* add = new LinkedNode(val);
        while(index--){
            cur=cur->next;
        }
        add->next=cur->next;
        cur->next=add;
        size++;
    }
    
    void deleteAtIndex(int index) {
        if(index<0||index>size-1)
            return;
        LinkedNode* cur = dummyHead;
        while(index--){
            cur=cur->next;
        }
        LinkedNode* tmp = cur->next;
        cur->next = tmp->next;
        //注意这里要手动删除
        delete tmp;
        size--;
    }
private:
    int size;
    LinkedNode* dummyHead;
};

/**
 * 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);
 */

206. Reverse Linked List

Given the head of a singly linked list, reverse the list, and return the reversed list.

Example 1:

Input: head = [1,2,3,4,5]
Output: [5,4,3,2,1]

Example 2:

Input: head = [1,2]
Output: [2,1]

Example 3:

Input: head = []
Output: []

Constraints:

• The number of nodes in the list is the range [0, 5000].
• -5000 <= Node.val <= 5000

Follow up: A linked list can be reversed either iteratively or recursively. Could you implement both?

Accepted

1,911,120

Submissions

2,753,434

翻转链表。 可以设置两个指针，一个cur指向当前node, 一个pre指向前一个node。

逻辑是先用个tmp保存当前的下一个，

然后把当前的下一个改为前一个。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        ListNode* temp; // 保存cur的下一个节点
        ListNode* cur = head;
        ListNode* pre = NULL;
        while(cur) {
            temp = cur->next;  // 保存一下 cur的下一个节点，因为接下来要改变cur->next
            cur->next = pre; // 翻转操作
            // 更新pre 和 cur指针
            pre = cur;
            cur = temp;
        }
        return pre;
    }
};

138. Copy List with Random Pointer

Medium

95771052Add to ListShare

A linked list of length n is given such that each node contains an additional random pointer, which could point to any node in the list, or null.

Construct a deep copy of the list. The deep copy should consist of exactly n brand new nodes, where each new node has its value set to the value of its corresponding original node. Both the next and random pointer of the new nodes should point to new nodes in the copied list such that the pointers in the original list and copied list represent the same list state. None of the pointers in the new list should point to nodes in the original list.

For example, if there are two nodes X and Y in the original list, where X.random --> Y, then for the corresponding two nodes x and y in the copied list, x.random --> y.

Return the head of the copied linked list.

The linked list is represented in the input/output as a list of n nodes. Each node is represented as a pair of [val, random_index] where:

• val: an integer representing Node.val
• random_index: the index of the node (range from 0 to n-1) that the random pointer points to, or null if it does not point to any node.

Your code will only be given the head of the original linked list.

Example 1:

Input: head = [[7,null],[13,0],[11,4],[10,2],[1,0]]
Output: [[7,null],[13,0],[11,4],[10,2],[1,0]]

Example 2:

Input: head = [[1,1],[2,1]]
Output: [[1,1],[2,1]]

Example 3:

Input: head = [[3,null],[3,0],[3,null]]
Output: [[3,null],[3,0],[3,null]]

Constraints:

• 0 <= n <= 1000
• -104 <= Node.val <= 104
• Node.random is null or is pointing to some node in the linked list.

  class Solution:
      def copyRandomList(self, head: 'Optional[Node]') -> 'Optional[Node]':
          #create new node and make hashmap
          cur = head
          #pay attention to the way of initializing the map:when the pointer is None
          hm = {None:None}
          
          while cur:
              node = Node(cur.val)
              hm[cur] = node
              cur = cur.next
          #copy the pointers in the new list
          
          cur = head
          while cur:
              newNode = hm[cur]
              newNode.next = hm[cur.next]
              newNode.random = hm[cur.random]
              cur = cur.next
          return hm[head]