打卡第三天

打卡第三天 203.移除链表元素、707.设计链表、206.反转链表

链表理论基础

// 链表定义
// 单链表
struct ListNode {
    int val;  // 节点上存储的元素
    ListNode *next;  // 指向下一个节点的指针
    ListNode(int x) : val(x), next(NULL) {}  // 节点的构造函数
};

203.移除链表元素

通过学习，知道了需要一个虚拟的头节点来对头节点进行统一操作，心得写到注释里了，代码如下。

/**
 * 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* removeElements(ListNode* head, int val) {
        // 设置一个虚拟头结点，头结点的next指向head
        // C++中，指针不加星号是引用，加星号是解引用，获取地址的值，所以这里不加星号即可
        ListNode* dummyHead = new ListNode(0,head); 
        // 设置一个临时变量，作为虚拟头结点，指向当前结点
        ListNode* current = dummyHead;
        while(current->next!=NULL){
            // 不能current->val，因为没法处理当前节点，只能处理下一个
            if(current->next->val==val){
                ListNode* temp = current->next;
                current->next = temp->next;
                delete temp;
            }else{
                current=current->next;
            }
        }
        return dummyHead->next;
    }
};

不太清楚while(current->next!=NULL)为什么不能写成while(current->val!=NULL)

还想用java写一遍，毕竟想学java。

/**
 * 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) {
        ListNode dummyHead = new ListNode(0,head);
        ListNode current = dummyHead;
        while(current.next!=null){
            if(current.next.val==val){
                ListNode temp = current.next;
                current.next = current.next.next;
            }else{
                current=current.next;
            }
        }
        return dummyHead.next;
    }
}

707.设计链表

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 > (_size - 1) || index < 0) {
            return -1;
        }
        LinkedNode* current = _dummyHead->next;
        while(index--){
            current=current->next;
        }
        return current->val;
    }
    
    void addAtHead(int val) {
        LinkedNode* newNode = new LinkedNode(val);
        newNode->next = _dummyHead->next;
        _dummyHead->next = newNode;
        _size++;
    }
    
    void addAtTail(int val) {
        LinkedNode* newNode = new LinkedNode(val);
        LinkedNode* current = _dummyHead;
        while(current->next != NULL){
            current = current->next;
        }
        current->next = newNode;
        _size++;
    }
    
    void addAtIndex(int index, int val) {
        if (index > _size || index < 0) {
            return;
        }
        LinkedNode *newNode = new LinkedNode(val);
        LinkedNode *current = _dummyHead;
        while(index--){
            current=current->next;
        }
        newNode->next = current->next;
        current->next = newNode;
        _size++; 
    }
    
    void deleteAtIndex(int index) {
        if (index >= _size || index < 0) {
            return;
        }
        LinkedNode* current = _dummyHead;
        while(index--) {
            current = current ->next;
        }
        LinkedNode* tmp = current->next;
        current->next = current->next->next;
        delete tmp;
        _size--;
    }

private:
    int _size;
    LinkedNode* _dummyHead;
};

206.反转链表

用一个temp指针存储current下一个节点的位置，因为current是执行反转操作的。

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        ListNode* temp;
        ListNode* pre = NULL;
        ListNode* current = head;
        while(current){
            temp = current->next;
            current->next=pre;
            pre = current;
            current = temp;
        }
        return pre;
    }
};