合并链表和翻转链表

其实链表之类的题目几乎都可以先把元素提取到数组，再移到链表的方法。如果一时搞不清楚指针的移动等，可以尝试。

将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。
输入：l1 = [1,2,4], l2 = [1,3,4]
输出：[1,1,2,3,4,4]

class Solution {
public:
    ListNode* mergeTwoLists(ListNode* list1, ListNode* list2) {
        //链表类几乎都可以先提取到数组中再操作
        // vector<int> arr;
        // ListNode* l1=list1;
        // ListNode* l2=list2;
        // if(l1==nullptr&&l2==nullptr)
        //     return l1;
        // if(l1==nullptr&&l2!=nullptr)
        //     return l2;
        // if(l1!=nullptr&&l2==nullptr)
        //     return l1;
        // while(l1!=nullptr)
        // {
        //     arr.push_back(l1->val);
        //     l1=l1->next;
        // }
        // while(l2!=nullptr)
        // {
        //     arr.push_back(l2->val);
        //     l2=l2->next;
        // }
        // sort(arr.begin(),arr.end());
        // ListNode* head1;
        // ListNode* head2;
        // head1=list1;
        // head2=list2;
        // int i=0;
        // int n=arr.size();
        // // while(list1->next!=nullptr) 直接在原链表变换，主要是需要连接两个链表
        // // { 
        // //     list1->val=arr[i];
        // //     i++;
        // //     list1=list1->next;
        // // }
        
        // // list1->val=arr[i];
        // // i++;
        // // while(list2!=nullptr)
        // // {
        // //     list2->val=arr[i];
        // //     i++;
        // //     list2=list2->next;
        // // }
        // // list1->next=head2;
        // // return head1;
        // ListNode *head=new ListNode();  //新建一个链表。主要是知道new新建节点的操作
        // head->val=arr[0];
        // ListNode* tmp=head;
        // for(int j=1;j<n;j++)
        // {
        //     ListNode *node=new ListNode();
        //     node->val=arr[j];
        //     tmp->next=node;
        //     tmp=node;
            
        // }
        // return head;
        /用迭代法，不需要额外的空间，注意设一个空节点,串联两个链表
        ListNode* l1=list1;
        ListNode* l2=list2;
        if(l1==nullptr&&l2==nullptr)
            return l1;
        ListNode *prehead=new ListNode();
        ListNode *pre=prehead;
        while(l1!=nullptr&&l2!=nullptr)
        {
            if(l1->val<l2->val)
            {
                pre->next=l1;
                l1=l1->next;
                pre=pre->next;
            }
            else
            {
                pre->next=l2;
                l2=l2->next;
                pre=pre->next;
            }
        }
        if(l1!=nullptr)
        {
            pre->next=l1;
        }
        else{
            pre->next=l2;
        }
        return prehead->next;

        
    }
};

给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。
输入：head = [1,2]
输出：[2,1]

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        // if(head==nullptr||head->next==nullptr)
        //     return head;
        // vector<int> arr;
        // ListNode* tmp=head;
        // ListNode* tmp2=head;
        // while(tmp!=nullptr)
        // {
        //     arr.push_back(tmp->val);
        //     tmp=tmp->next;
        // }
        // int n=arr.size();
        // for(int i=n-1;i>=0;i--)
        // {
        //     tmp2->val=arr[i];
        //     tmp2=tmp2->next;
        // }
        // return head;
        ListNode* prev=nullptr;
        ListNode* temp;
        //ListNode* temp = head;
        //border conditon
       // if (temp == nullptr)
        //    return temp;
        ListNode* curr=head;
        while(curr!=nullptr)
        {
        temp=curr->next;
        curr->next=prev;
        prev=curr;
        curr=temp;
        }
        return prev;

    }
};

注意要在head前面先设一个空节点，防止头结点的next指针无法消去。其次就是先保存原来的指针next指向，不然无法找到下一个元素。