leetcode探索_数据结构简介_链表

最新推荐文章于 2024-05-01 16:18:57 发布

噔噔噔邓不利多儿

最新推荐文章于 2024-05-01 16:18:57 发布

阅读量246

点赞数

文章标签： leetcode 链表

本文链接：https://blog.csdn.net/qq_43215484/article/details/100699801

版权

在leetcode探索，链表刷题记录

https://leetcode-cn.com/explore/learn/card/linked-list/

单链表

707.设计链表

执行用时 :92 ms, 在所有 C++ 提交中击败了37.28%的用户

内存消耗 :19.1 MB, 在所有 C++ 提交中击败了83.33%的用户

class MyLinkedList {
public:
    struct Node{
        int m_val;
        Node* next;
        Node(int x):m_val(x),next(NULL){}
    };
    int m_length;
    Node *m_head,*m_tail;
    /** Initialize your data structure here. */
    MyLinkedList() {
        m_length = 0;
        Node* t = new Node(0);
        m_head = t;
        m_tail = t;
    }
    
    /** Get the value of the index-th node in the linked list. If the index is invalid, return -1. */
    int get(int index) {
        if(index<0 || index>=m_length)
            return -1;
        if(index == m_length - 1)
            return m_tail->m_val;
        Node *temp = m_head;
        for(int i = 0;i<index;++i)
            temp = temp->next;
        return temp->m_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 addAtHead(int val) {
        if(m_length == 0)
        {
            m_head->m_val = val;
            ++m_length;
            return ;
        }
        Node *h = new Node(val);
        h->next = m_head;
        m_head = h;
        ++m_length;
        return ;
    }
    
    /** Append a node of value val to the last element of the linked list. */
    void addAtTail(int val) {
        if(m_length == 0)
        {
            m_tail->m_val = val;
            ++m_length;
            return ;
        }
        Node *tail = new Node(val);
        m_tail->next = tail;
        m_tail = tail;
        ++m_length;
        return ;
    }
    
    /** 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. */
    void addAtIndex(int index, int val) {
        if(index >m_length)
            return ;
        if(index <= 0)
        {
            addAtHead(val);
            return ;
        }
            
        if(index == m_length)
        {
            addAtTail(val);
            return ;
        }
        if(index == m_length - 1)
        {
            int v = m_tail->m_val;
            m_tail->m_val = val;
            addAtTail(v);
            return ;
        }
        Node *new_node = new Node(val);
        Node *flag = m_head;
        for(int i = 0;i<index - 1;++i)
        {
            flag = flag->next;
        }
        new_node->next = flag->next;
        flag->next = new_node;
        ++m_length;
        return ;
        
    }
    
    /** Delete the index-th node in the linked list, if the index is valid. */
    void deleteAtIndex(int index) {
        if(index<0 || index>=m_length)
            return ;
        if(index == 0 )
        {
            if(m_length == 1)
            {
                m_length = 0;
                return ;
            }
            m_head = m_head->next;
            --m_length;
            return ;
        }
        Node *find = m_head;
        for(int i = 0;i<index - 1;++i)
            find = find->next;
        if(index == m_length - 1)
        {
            find->next = NULL;
            m_tail = find;
        }
        else
            find->next = find->next->next;
        --m_length;
        return ;
    }
};

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

双指针技巧

141.环形链表

执行用时 :28 ms, 在所有 C++ 提交中击败了20.84%的用户

内存消耗 :9.9 MB, 在所有 C++ 提交中击败了14.31%的用户

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    bool hasCycle(ListNode *head) {
        if(head == NULL || head->next == NULL)
            return false;
        ListNode* a;
        ListNode* b;
        a = head;
        b = head->next;
        while(a != b)
        {
            if(a->next!=NULL)
                a = a->next;
            else
                return false;
            for(int i = 0;i<2;++i)
            {
                if(b->next!=NULL)
                    b = b->next;
                else
                    return false;
            }
        }
        return true;
    }
};

快慢指针

执行用时 :8 ms, 在所有 cpp 提交中击败了98.79%的用户

内存消耗 :9.8 MB, 在所有 cpp 提交中击败了24.76%的用户

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    bool hasCycle(ListNode *head) {
        if(head == NULL )
            return false;
        ListNode* low = head;
        ListNode* fast = head;
        while(fast && fast->next)
        {
            fast = fast->next->next;
            low = low->next;
            if(low == fast)
            {
                return true;
            }
        }
        return false;
    }
};

时间复杂度：o（n）

当将fast->next是否为空的判断写在while循环内时，超时.

执行用时 :20 ms, 在所有 cpp 提交中击败了40.79%的用户

内存消耗 :11.8 MB, 在所有 cpp 提交中击败了8.59%的用户

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    bool hasCycle(ListNode *head) {
        unordered_set<ListNode*> all_node;
        ListNode *temp = head;
        while(temp)
        {
            if(all_node.count(temp) <= 0)
                all_node.insert(temp);
            else
                return true;
            temp = temp->next;
        }
        return false;
    }
};

142.环形链表II

执行用时 :24 ms, 在所有 C++ 提交中击败了36.62%的用户

内存消耗 :9.7 MB, 在所有 C++ 提交中击败了63.63%的用户

class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        if(head == NULL || head->next == NULL)
            return NULL;
        ListNode *huan;
        ListNode* a;
        ListNode* b;
        int a_step = 1;
        int b_step = 2;
        a = head;
        b = head;
        bool flag = true;
        while(a != b || flag)
        {
            flag = false;
            for(int i = 0;i<a_step;++i)
            {
                if(a->next!=NULL)
                    a = a->next;
                else
                    return NULL;
            }
            for(int j = 0;j<b_step;++j)
            {
                if(b->next!=NULL)
                    b = b->next;
                else
                    return NULL;
            }
        }
        a = head;
        while(a!=b)
        {
            a = a->next;
            b = b->next;
        }
        huan = a;
        return huan;
    }
};

160.相交链表

执行用时 :68 ms, 在所有 C++ 提交中击败了67.85%的用户

内存消耗 :18 MB, 在所有 C++ 提交中击败了8.80%的用户

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        ListNode *a;
        ListNode *b;
        a = headA;
        b = headB;
        vector<int> num_a;
        vector<int> num_b;
        while(a!=NULL)
        {
            num_a.push_back(a->val);
            a = a->next;
        }
        while(b!=NULL)
        {
            num_b.push_back(b->val);
            b = b->next;
        }
        
        int i = num_a.size() - 1;
        int j = num_b.size() - 1;
        for(;i>=0 && j>=0;)
        {
            if(num_a[i] != num_b[j])
                break;
            --i;
            --j;
        }
        if(i == num_a.size() - 1)
            return NULL;
        a = headA;
        b = headB;
        while(i>=0)
        {
            a = a->next;
            --i;
        }
        while(j>=0)
        {
            b = b->next;
            --j;
        }
        while(a!=b)
        {
            a = a->next;
            b = b->next;
        }
        return a;
    }
};

执行用时 :48 ms, 在所有 C++ 提交中击败了95.35%的用户

内存消耗 :18.2 MB, 在所有 C++ 提交中击败了15.62%的用户

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        if (headA == NULL || headB == NULL)
            return NULL;
        stack<ListNode*> sa;
        stack<ListNode*> sb;
        ListNode* temp = headA;
        while (temp != NULL)
        {
            sa.push(temp);
            temp = temp->next;
        }
        temp = headB;
        while (temp != NULL)
        {
            sb.push(temp);
            temp = temp->next;
        }
        while (!sa.empty() && !sb.empty())
        {
            if (sa.top() == sb.top())
            {
                temp = sa.top();
                sa.pop();
                sb.pop();
            }
            else
            {
                break;
            }
        }
        return temp;
    }
};

19.删除链表的倒数第N个节点

执行用时 :8 ms, 在所有 C++ 提交中击败了79.52%的用户

内存消耗 :8.5 MB, 在所有 C++ 提交中击败了83.54%的用户

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        if(head == NULL)
            return head;
        ListNode *a = head;
        int length = 1;
        while(a->next!=NULL)
        {
            a = a->next;
            ++length;
        }
        if(n == length)
        {
            if(n == 1)
                return NULL;
            return head->next;
        }
        a = head;
        for(int i = 0;i<length - n -1;++i)
        {
            a = a->next;
        }
        a->next = a->next->next;
        return head;
    }
};

执行用时 :8 ms, 在所有 C++ 提交中击败了79.52%的用户

内存消耗 :8.6 MB, 在所有 C++ 提交中击败了78.15%的用户

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        if(head == NULL || head->next == NULL)
            return NULL;
        ListNode *a = head;
        ListNode *b = head;
        int i = n;
        while(i>0)
        {
            if(b->next == NULL)
                return head->next;
            b = b->next;
            --i;
        }
        while(b->next!=NULL)
        {
            a = a->next;
            b = b->next;
        }
        a->next = a->next->next;
        return head;
    }
};

遍历一遍

执行用时 :8 ms, 在所有 cpp 提交中击败了71.78%的用户

内存消耗 :8.6 MB, 在所有 cpp 提交中击败了76.23%的用户

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode* pre = head;
        ListNode* lat = head;
        for(int i = 0;i < n; ++i)
        {
            lat = lat->next;
        }
        if(!lat)
            return head->next;
        while(lat && lat->next)
        {
            lat = lat->next;
            pre = pre->next;
        }
        pre->next = pre->next->next;
        return head;
    }
};

经典问题

206.反转链表

执行用时 :12 ms, 在所有 C++ 提交中击败了85.76%的用户

内存消耗 :9.2 MB, 在所有 C++ 提交中击败了31.42%的用户

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        if(head == NULL)
            return NULL;
        if(head->next == NULL)
            return head;
        ListNode *node_now = head;
        ListNode *node_next = node_now->next;
        ListNode *temp = node_next->next;
        head->next = NULL;
        while(temp != NULL)
        {
            node_next->next = node_now;
            node_now = node_next;
            node_next = temp;
            temp = node_next->next;
        }
        node_next->next = node_now;
        return node_next;
    }
};

遍历一遍

执行用时 :8 ms, 在所有 cpp 提交中击败了97.21%的用户

内存消耗 :9 MB, 在所有 cpp 提交中击败了77.83%的用户

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        ListNode* pre = head;
        ListNode* result = NULL;
        ListNode* loc = head;
        while(pre)
        {
            pre = pre->next;
            loc->next = result;
            result = loc;
            loc = pre;
        }
        return result;
    }
};

执行用时 :12 ms, 在所有 C++ 提交中击败了85.76%的用户

内存消耗 :9.2 MB, 在所有 C++ 提交中击败了30.22%的用户

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

递归

执行用时 :20 ms, 在所有 cpp 提交中击败了22.43%的用户

内存消耗 :9 MB, 在所有 cpp 提交中击败了71.08%的用户

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        ListNode* result = NULL;
        recursion(head, result);
        return result;
    }
    void recursion(ListNode* h, ListNode* &result)
    {
        if(!h)
            return ;
        ListNode* temp = h;
        h = h->next;
        temp->next = result;
        result = temp;
        recursion(h, result);
        return ;
    }
};

203.移除链表元素

执行用时 :32 ms, 在所有 C++ 提交中击败了99.06%的用户

内存消耗 :11.1 MB, 在所有 C++ 提交中击败了74.14%的用户

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        if(head == NULL)
            return NULL;
        while(head->val == val)
        {
            if(head->next == NULL)
                return NULL;
            head = head->next;
        }
        ListNode *temp = head;
        while(temp != NULL && temp->next!=NULL)
        {
            while(temp->next != NULL && temp->next->val == val)
                temp->next = temp->next->next;
            temp = temp->next;
        }
        return head;
    }
};

注意空指针!!!

328.奇偶链表

执行用时 :96 ms, 在所有 C++ 提交中击败了8.69%的用户

内存消耗 :9.6 MB, 在所有 C++ 提交中击败了81.85%的用户

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* oddEvenList(ListNode* head) {
        if(!head)
            return NULL;
        if(!head->next || !head->next->next)
            return head;
        ListNode *begin = head->next;
        ListNode *end;
        ListNode *a = begin;
        ListNode *b = a->next;
        while(a!=NULL && b!=NULL)
        {
            b = a->next;
            int temp = a->val;
            a->val = b->val;
            b->val = temp;
            if(b->next == NULL || b->next->next == NULL)
            {
                end = a;
                break;
            }
            a = b->next;
        }
        ListNode *print = head;
        while(print!=NULL)
        {
            print = print->next;
        }
        if(begin == end)
            return head;
        begin = begin->next;
        a = begin;
        b = a->next;
        while(true)
        {
            while(a && b)
            {
                int temp = a->val;
                a->val = b->val;
                b->val = temp;
                if(b == end)
                {
                    end = a;
                    break;
                }
                a = b->next;
                if(a == end)
                {
                    end = a;
                    break;
                }
                b = a->next;
            }
            if(begin == end)
                break;
            begin = begin->next;
            a = begin;
            b = a->next;
        }
        return head;
    }
};

第一个循环找到begin与end，begin前为奇数组前一部分，end后为偶数组后一部分。

第二个循环，内循环不断地交换begin与end之间数字，外循环则更新begin与end；

234.回文链表

执行用时 :32 ms, 在所有 C++ 提交中击败了58.88%的用户

内存消耗 :13.5 MB, 在所有 C++ 提交中击败了8.97%的用户

class Solution {
public:
    bool isPalindrome(ListNode* head) {
        ListNode *t = head;
        vector<int> shuzu;
        while(t)
        {
            shuzu.push_back(t->val);
            t = t->next;
        }
        int length = shuzu.size();
        for(int i = 0;i<length/2;++i)
        {
            if(shuzu[i]!=shuzu[length - i - 1])
                return false;
        }
        return true;
    }
};

双链表

707.设计链表

执行用时 :52 ms, 在所有 C++ 提交中击败了98.92%的用户

内存消耗 :19.5 MB, 在所有 C++ 提交中击败了30.68%的用户

class MyLinkedList {
public:
    struct Node{
        int m_val;
        Node* next;
        Node* prev;
        Node(int x):m_val(x),next(NULL),prev(NULL){}
    };
    int m_length;
    Node *m_head,*m_tail;
    /** Initialize your data structure here. */
    MyLinkedList() {
        //cout<<"MyLinkedList"<<endl;
        m_length = 0;
        Node* t = new Node(0);
        m_head = t;
        m_tail = t;
    }
    
    /** Get the value of the index-th node in the linked list. If the index is invalid, return -1. */
    int get(int index) {
        //cout<<"get"<<endl;
        if(index<0 || index>=m_length)
            return -1;
        Node *temp;
        if(index <= m_length/2)
        {
            temp = m_head;
            for(int i = 0;i<index;++i)
            {
                temp = temp->next;
            }
            
        }
        else if(index > m_length/2)
        {
            temp = m_tail;
            for(int i = m_length - 1;i>index;--i)
            {
                temp = temp->prev;
            }
        }
        return temp->m_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 addAtHead(int val) {
        //cout<<"addAtHead"<<endl;
        if(m_length == 0)
        {
            m_head->m_val = val;
            ++m_length;
            //cout<<m_length<<endl;
            return ;
        }
        Node *h = new Node(val);
        h->next = m_head;
        m_head->prev = h;
        m_head = h;
        ++m_length;
        //cout<<m_length<<endl;
        return ;
    }
    
    /** Append a node of value val to the last element of the linked list. */
    void addAtTail(int val) {
        //cout<<"addAtTail"<<endl;
        if(m_length == 0)
        {
            m_tail->m_val = val;
            ++m_length;
            //cout<<m_length<<endl;
            return ;
        }
        Node *tail = new Node(val);
        m_tail->next = tail;
        tail->prev = m_tail;
        m_tail = tail;
        ++m_length;
        //cout<<m_length<<endl;
        return ;
    }
    
    /** 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. */
    void addAtIndex(int index, int val) {
        //cout<<"addAtIndex"<<endl;
        if(index >m_length)
            return ;
        if(index <= 0)
        {
            addAtHead(val);
            return ;
        }
        if(index == m_length)
        {
            addAtTail(val);
            return ;
        }
        Node *temp;
        Node *new_node = new Node(val);
        //new_node->m_val = val;
        if(index <= m_length/2)
        {
            temp = m_head;
            for(int i = 0;i<index;++i)
            {
                temp = temp->next;
            }
        }
        else if(index > m_length/2)
        {
            temp = m_tail;
            for(int i = m_length - 1;i>index;--i)
            {
                temp = temp->prev;
            }
        }
        new_node->next = temp;
        new_node->prev = temp->prev;
        temp->prev->next = new_node;
        temp->prev = new_node;
        ++m_length;
        //cout<<m_length<<endl;
        return ;
        
    }
    
    /** Delete the index-th node in the linked list, if the index is valid. */
    void deleteAtIndex(int index) {
        //cout<<"deleteAtIndex"<<endl;
        if(index<0 || index>=m_length)
            return ;
        if(index == 0)
        {
            if(m_length == 1)
            {
                m_length = 0;
                return ;
            }
            m_head = m_head->next;
            --m_length;
            //cout<<m_length<<endl;
            return ;
        }
        if(index == m_length - 1)
        {
            m_tail->prev->next = NULL;
            m_tail = m_tail->prev;
            --m_length;
            //cout<<m_length<<endl;
            return ;
        }
        Node *temp;
        if(index <= m_length/2)
        {
            temp = m_head;
            for(int i = 0;i<index;++i)
            {
                temp = temp->next;
            }
        }
        else if(index > m_length/2)
        {
            temp = m_tail;
            for(int i = m_length - 1;i>index;--i)
            {
                temp = temp->prev;
            }
        }
        temp->prev->next = temp->next;
        temp->next->prev = temp->prev;
        --m_length;
        //cout<<m_length<<endl;
        return ;
    }
};

小结

21.合并两个有序链表

执行用时 :12 ms, 在所有 C++ 提交中击败了84.70%的用户

内存消耗 :8.9 MB, 在所有 C++ 提交中击败了84.09%的用户

class Solution {
public:
    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
        if(l1 == NULL)
            return l2;
        if(l2 == NULL)
            return l1;
        ListNode *l2_ = l2;
        if(l2->val < l1->val)
        {
            l2_ = l2_->next;
            l2->next = l1;
            l1 = l2;
        }
        ListNode *temp_1 = l1;
        ListNode *t;
        while(temp_1!=NULL && l2_!=NULL)
        {
            while(temp_1->next!=NULL &&temp_1->next->val <= l2_->val)
                temp_1 = temp_1->next;
            t = l2_;
            l2_ = l2_->next;
            t->next = temp_1->next;
            temp_1->next = t;
        }
        return l1;
    }
};

执行用时 :12 ms, 在所有 cpp 提交中击败了75.10%的用户

内存消耗 :8.8 MB, 在所有 cpp 提交中击败了93.37%的用户

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
        if(l1 && !l2)
        {
            return l1;
        }
        else if(!l1)
        {
            return l2;
        }
        ListNode* result;
        ListNode* list1;
        ListNode* list2;
        if(l1->val <= l2->val)
        {
            result = l1;
            list1 = l1->next;
            list2 = l2;
        }
        else
        {
            result = l2;
            list1 = l1;
            list2 = l2->next;
        }
        ListNode* temp = result;
        while(list1 && list2)
        {
            if(list1->val <= list2->val)
            {
                temp->next = list1;
                temp = list1;
                list1 = list1->next;
            }
            else
            {
                temp->next = list2;
                temp = list2;
                list2 = list2->next;
            }
        }
        if(list1)
            temp->next = list1;
        else if(list2)
            temp->next = list2;
        return result;
    }
};

o(min(n1,n2))

2.两数相加

执行用时 :28 ms, 在所有 C++ 提交中击败了94.68%的用户

内存消耗 :10.1 MB, 在所有 C++ 提交中击败了96.45%的用户

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
        int a,b;
        int add = l1->val + l2->val;
        int carry = add/10;
        add = add%10;
        ListNode *result = new ListNode(add);
        ListNode *tail = result;
        ListNode *temp;
        l1 = l1->next;
        l2 = l2->next;
        while(carry!=0 || l1||l2)
        {
            if(l1)
                a = l1->val;
            else
                a = 0;
            if(l2)
                b = l2->val;
            else
                b = 0;
            add = a+b+carry;
            carry = add/10;
            add = add%10;
            temp = new ListNode(add);
            tail->next = temp;
            tail = temp;
            if(l1)
                l1 = l1->next?l1->next:NULL;
            if(l2)
                l2 = l2->next?l2->next:NULL;
        }
        
        return result;
    }
};

注意，给指针赋值另一个指针，若另一个指针指向new创建的节点，则被赋值指针指向节点，否则两指针可能同时改变。

430.扁平化多级双向链表

执行用时 :244 ms, 在所有 C++ 提交中击败了9.88%的用户

内存消耗 :30.7 MB, 在所有 C++ 提交中击败了97.79%的用户

/*
// Definition for a Node.
class Node {
public:
    int val;
    Node* prev;
    Node* next;
    Node* child;

    Node() {}

    Node(int _val, Node* _prev, Node* _next, Node* _child) {
        val = _val;
        prev = _prev;
        next = _next;
        child = _child;
    }
};
*/
class Solution {
public:
    Node* flatten(Node* head) {
        if(!head)
            return head;
        Node *temp;
        temp = head;
        Node *n;
        Node *findtail;
        while(temp)
        {
            if(temp->child)
            {
                n = temp->next;
                temp->next = temp->child;
                findtail = temp->child;
                temp->child->prev = temp;
                temp->child = NULL;
                while(findtail->next)
                {
                    findtail = findtail->next;
                }
                findtail->next = n;
                if(n)
                    n->prev = findtail;
            }
            if(!temp->next)
                break;
            temp = temp->next;
        }
        return head;
    }
};

138.复制带随机指针的链表

执行用时 :60 ms, 在所有 C++ 提交中击败了55.87%的用户

内存消耗 :22.1 MB, 在所有 C++ 提交中击败了18.59%的用户

/*
// Definition for a Node.
class Node {
public:
    int val;
    Node* next;
    Node* random;

    Node() {}

    Node(int _val, Node* _next, Node* _random) {
        val = _val;
        next = _next;
        random = _random;
    }
};
*/
class Solution {
public:
    Node* copyRandomList(Node* head) {
        if(head == NULL)
            return NULL;
        Node *temp = head;
        while(temp)
        {
            Node *clone_node = new Node(temp->val,temp->next,NULL);
            temp->next = clone_node;
            temp = clone_node->next;
        }
        temp = head;
        while(temp)
        {
            if(temp->random)
                temp->next->random = temp->random->next;
            temp = temp->next->next;
        }
        temp = head;
        Node *copy_head = temp->next;
        Node *copy_temp = temp->next;
        while(temp->next)
        {
            temp->next = copy_temp->next;
            temp = temp->next;
            if(!temp)
            {
                copy_temp->next = NULL;
                break;
            }
            copy_temp->next = temp->next;
            copy_temp = copy_temp->next;
        }
        return copy_head;
    }
};

执行用时 :16 ms, 在所有 C++ 提交中击败了74.66%的用户

内存消耗 :13.4 MB, 在所有 C++ 提交中击败了91.04%的用户

/*
// Definition for a Node.
class Node {
public:
    int val;
    Node* next;
    Node* random;
    
    Node(int _val) {
        val = _val;
        next = NULL;
        random = NULL;
    }
};
*/
class Solution {
public:
    Node* copyRandomList(Node* head) {
        if (head == NULL)
            return NULL;
        Node* temp = head;
        Node* copytemp = head;
        while (temp != NULL)
        {
            copytemp = new Node(temp->val);
            copytemp->next = temp->next;
            temp->next = copytemp;
            temp = copytemp->next;
        }
        temp = head;
        copytemp = temp->next;
        while (copytemp != NULL)
        {
            if (temp->random != NULL)
                copytemp->random = temp->random->next;
            temp = copytemp->next;
            if (temp == NULL)
                break;
            copytemp = temp->next;
        }
        Node* res = head->next;
        temp = head;
        copytemp = temp->next;
        while (copytemp != NULL)
        {
            temp->next = copytemp->next;
            temp = temp->next;
            if (temp == NULL)
                break;
            copytemp->next = temp->next;
            copytemp = copytemp->next;
        }
        return res;
    }
};

61.旋转链表

执行用时 :20 ms, 在所有 C++ 提交中击败了30.81%的用户

内存消耗 :9 MB, 在所有 C++ 提交中击败了75.78%的用户

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* rotateRight(ListNode* head, int k) {
        if(!head)
            return NULL;
        ListNode *temp = head;
        int length = 1;
        while(temp->next)
        {
            ++length;
            temp = temp->next;
        }
        k = k%length;
        ListNode *tail = temp;
        tail->next = head;
        temp = head;
        int loc = length - k - 1;
        while(loc)
        {
            temp = temp->next;
            --loc;
        }
        ListNode *new_head = temp->next;
        temp->next = NULL;
        return new_head;
    }
};

探索以外其他链表题

146.LRU缓存机制

执行用时 :112 ms, 在所有 C++ 提交中击败了88.97%的用户

内存消耗 :39.8 MB, 在所有 C++ 提交中击败了63.10%的用户

struct DListNode{
    pair<int, int> key_value;
    DListNode* pre;
    DListNode* next;
    DListNode(pair<int, int> x):key_value(x), pre(NULL), next(NULL){}
};
class LRUCache {
private:
    DListNode* head;
    DListNode* last;
    unordered_map<int, DListNode*> record;
    int max_len;
public:
    LRUCache(int capacity) {
        max_len = capacity;
        head = NULL;
        last = NULL;
    }
    
    int get(int key) {
        if (record.count(key) <= 0 ||record[key] == NULL)
        {
            return -1;
        }
        DListNode* get_node = record[key];
        if (get_node == last)
        {
            return record[key]->key_value.second;
        }
        if (get_node == head)
        {
            head = head->next;
            head->pre = NULL;
        }
        else{
            get_node->next->pre = get_node->pre;
            get_node->pre->next = get_node->next;
        }
        get_node->next = NULL;
        last->next = get_node;
        get_node->pre = last;
        last = get_node;
        return record[key]->key_value.second;
    }
    
    void put(int key, int value) {
        DListNode* temp = NULL;
        if (record.count(key) > 0)
        {
            temp = record[key];
            temp->key_value.second = value;
            if (temp == last)
            {
                return ;
            }
            if (temp != head)
            {
                temp->pre->next = temp->next;
                temp->next->pre = temp->pre;
            }
            else{
                head = head->next;
                head->pre = NULL;
            }
            last->next = temp;
            temp->pre = last;
            last = temp;
        }
        else
        {
            temp = new DListNode({key, value});
            if (record.size() >= max_len)
            {
                DListNode* t = head;
                head = head->next;
                record.erase(t->key_value.first);
                delete t;
            }
            record.insert({key, temp});
            if (record.size() == 1)
            {
                head = temp;
                last = temp;
                return ;
            }
            last->next = temp;
            temp->pre = last;
            last = temp;
        }
    }
};

/**
 * Your LRUCache object will be instantiated and called as such:
 * LRUCache* obj = new LRUCache(capacity);
 * int param_1 = obj->get(key);
 * obj->put(key,value);
 */

237.删除链表中的节点

执行用时 :16 ms, 在所有 cpp 提交中击败了76.57%的用户

内存消耗 :9.2 MB, 在所有 cpp 提交中击败了27.52%的用户

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    void deleteNode(ListNode* node) {
        if ( node == NULL )
            return ;
        ListNode *todelete = NULL;
        while (node->next->next != NULL)
        {
            node->val = node->next->val;
            node = node->next;
        }
        if (node->next->next == NULL)
        {
            todelete = node->next;
            node->val = node->next->val;
            node->next = NULL;
        }
        if (todelete != NULL)
        {
            delete todelete;
            todelete = NULL;
        }
        return ;
    }
};

执行用时 :20 ms, 在所有 cpp 提交中击败了26.44%的用户

内存消耗 :9.3 MB, 在所有 cpp 提交中击败了11.09%的用户

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    void deleteNode(ListNode* node) {
        if (node == NULL)
            return ;
        ListNode* temp = node;
        while(temp->next != NULL)
        {
            temp->val = temp->next->val;
            node = temp;
            temp = temp->next;
        }
        node->next = NULL;
        return ;
    }
};

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    void deleteNode(ListNode* node) {
        if (node == NULL)
            return ;
        ListNode* temp = NULL;
        while (node->next->next != NULL)
        {
            node->val = node->next->val;
            node = node->next;
        }
        node->val = node->next->val;
        temp = node->next;
        node->next = NULL;
        delete temp;
        return ;
    }
};

执行用时 :16 ms, 在所有 C++ 提交中击败了71.85%的用户

内存消耗 :9 MB, 在所有 C++ 提交中击败了85.10%的用户

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    void deleteNode(ListNode* node) {
        if (node == NULL)
            return ;
        ListNode* temp = node;
        temp->val = temp->next->val;
        ListNode* del = temp->next;
        temp->next = del->next;
        delete del;
        return ;
    }
};

876.链表的中间结点

执行用时 :4 ms, 在所有 C++ 提交中击败了64.15%的用户

内存消耗 :8.9 MB, 在所有 C++ 提交中击败了5.14%的用户

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* middleNode(ListNode* head) {
        ListNode* low = head;
        ListNode* fast = head;
        while(fast)
        {
            if(fast->next)
            {
                fast = fast->next->next;
                low = low->next;
            }
            else
                break;
        }
        return low;
    }
};

噔噔噔邓不利多儿

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
leetcode探索_数据结构简介_链表

目录2.两数相加19.删除链表的倒数第N个节点21.合并两个有序链表61.旋转链表138.复制带随机指针的链表141.环形链表142.环形链表II160.相交链表203.移除链表元素206.反转链表234.回文链表237.删除链表中的节点328.奇偶链表430.扁平化多级双向链表707.设计链表876.链表的中间结点2.两数相加...
复制链接

扫一扫