目录
- [1. 关于链表中由head向下遍历问题](#1. 关于链表中由head向下遍历问题)
- [2 涉及重排链表时,要将重排后的链表最后一个节点与nullptr相连](#2 涉及重排链表时,要将重排后的链表最后一个节点与nullptr相连)
- [3 for循环定义变量的位置不同](#3 for循环定义变量的位置不同)
1. 关于链表中由head向下遍历问题
- 如下:
- 如果我直接使用head=head->next;往下走,就会报错
- 只有用另一个变量next= head->next; head->next=nullptr;就不会
 
- 在释放当前节点之前,先保存下一个节点的指针,以确保不会访问已经被释放的内存
- 确保不会访问已经被释放的内存
            
            
              cpp
              
              
            
          
          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的某节点内存重复释放
            
            
              cpp
              
              
            
          
          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循环定义变量的位置不同
            
            
              cpp
              
              
            
          
          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 初始化仅一次
            
            
              cpp
              
              
            
          
          for(int i=0;i<n-2;++i){
    int l=i+1,r=n-1;
}上述只要循环一次就会给l 和 r 赋值;