记录Leetcode中的报错问题

目录

• [1. 关于链表中由head向下遍历问题](#1. 关于链表中由head向下遍历问题)
• [2 涉及重排链表时，要将重排后的链表最后一个节点与nullptr相连](#2 涉及重排链表时，要将重排后的链表最后一个节点与nullptr相连)
• [3 for循环定义变量的位置不同](#3 for循环定义变量的位置不同)

1. 关于链表中由head向下遍历问题

• 如下：
  • 如果我直接使用head=head->next;往下走，就会报错
  • 只有用另一个变量next= head->next; head->next=nullptr;就不会
• 在释放当前节点之前，先保存下一个节点的指针，以确保不会访问已经被释放的内存
• 确保不会访问已经被释放的内存

class Solution {
public:
    ListNode* partition(ListNode* head, int x) {
        ListNode* cur1=nullptr;
        ListNode* pre1=nullptr;
        ListNode* cur2=nullptr;
        ListNode* pre2=nullptr;
        ListNode* next=nullptr;

       while(head!=nullptr){
            next=head->next;
            if(head->val < x){
                if(cur1==nullptr){
                    cur1=head;
                   
                }else{
                    pre1->next=head;               
                }
                 pre1=head;
            }else{
                if(pre2==nullptr){
                    cur2=head;
                    // pre2=cur2;
                }else{
                    pre2->next=head;
                
                }
                pre2=head;
            }
            head=next;

       }
       pre1->next=cur2;
       return cur1;
    }
    
};

2 涉及重排链表时，要将重排后的链表最后一个节点与nullptr相连

• 对于同一个节点重复释放内存或释放后使用；

程序执行完毕后，回对内存进行释放，如果不断开最后一个节点，会找到head为头部的链表节点，将head的某节点内存重复释放

class Solution {
public:
    ListNode* help[50000];

    void sortnode(vector<ListNode*>& arr,int l,int r){
        if(l>=r)return ;
        int m=(l+r)/2;
        
        sortnode(arr,l,m);
        sortnode(arr,m+1,r);

        int i=l,a=l,b=m+1;
        while(a<=m&&b<=r ){
            help[i++]= (arr[a]->val <arr[b]->val)? arr[a++]:arr[b++];
        }

        while(a<=m){
            help[i++]=arr[a++];
        }
        while(b<=r){
            help[i++]=arr[b++];
        }
        for (int k = l; k <= r; ++k) arr[k] = help[k];
        
    }
    ListNode* sortList(ListNode* head) {
        if(head==nullptr)return nullptr;
        int n=0;
        ListNode* cur=head;
        vector<ListNode*> arr;
        while(cur!=nullptr){
            n++;
            arr.push_back(cur);
            cur=cur->next;
        }
        if(n==1)return head;
        ListNode* newhead=nullptr;
        sortnode(arr,0,n-1);
        newhead=help[0];
        ListNode* cur1=newhead;
        for(int i=1;i<n;i++){
            
            cur1->next=help[i];
            cur1=cur1->next;
        }
        cur1->next = nullptr;//*************************
        return newhead;
        

        
    }
};

3 for循环定义变量的位置不同

for(int i=0,l=i+1,r=n-1;i<n-2;++i)

上述表示，i从0-n-3

但 l 和 r的值每次都是从1 和 n-1开始，也就是l 和i 值无关了

同时之后每次循环对r 进行也不会进行赋值为n-1

l 和r 初始化仅一次

for(int i=0;i<n-2;++i){
    int l=i+1,r=n-1;
}

上述只要循环一次就会给l 和 r 赋值；