2019.10.21——反转链表、合并两个排序的链表

题目一描述

输入一个链表，反转链表后，输出新链表的表头。

题目一思路

这题其实很基础，就是考察一些链表结构的知识。当然题目给出的是单链表结构并且每个节点都只指向下一个节点。我们需要做的就是将他们反过来。那么我们也把一般特例拿出来处理，比如链表为空之类的，其次我们可以设置三个指针，pHead，temp，temp1，其中pHead指向的是进行到哪个节点的下一个节点，temp指向的是新链表当中的“头”结点，temp1指向的是操作的节点。比如链表{123}，pHead指向1，我们首先设置temp指向Null，temp1也指向1，首先判断pHead->next是否为Null，然后将pHead=pHead->next，其次我们将temp1的next指向temp，将temp1赋于temp，将pHead赋于temp1，依次循环即可。这里要注意的是，循环结束之后pHead指向的是原链表的最后一个节点，也就是我们所需求链表的头结点，需要将其pHead->next指向temp。这样即完成了链表的反转。

题目一代码

/*
struct ListNode {
	int val;
	struct ListNode *next;
	ListNode(int x) :
			val(x), next(NULL) {
	}
};*/
class Solution {
public:
    ListNode* ReverseList(ListNode* pHead) {
        if(pHead==NULL)
            return NULL;
        ListNode* temp=NULL;
        ListNode* temp1=pHead;
        while(pHead->next!=NULL)
        {
            pHead=pHead->next;
            temp1->next=temp;
            temp=temp1;
            temp1=pHead;
        }
        pHead->next = temp;
        return pHead;
    }
};

 

题目二描述

输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。

题目二思路

两个单调递增链表的合并，合并依旧要满足单调不减。其实思路和合并两个单调递增的数组是一致的，只不过可能链表比较复杂一点。那我这里讲述一种方式，
首先还是把特殊情况先拿出来说，比如链表pHead1或者pHead2为空之类的，其次我们新建一个链表FinalList，并赋予初值-1，指向空节点，再初始一个root等于FinalList，因为root用于返回而FinalList用来操作，然后进行循环，这里循环结束的条件是pHead1为空或者pHead2为空，循环的内容大家看代码也可以清楚。循环结束我们需要判断是pHead1还是pHead2为空，若pHead1为空，那我们需要将pHead2剩余的节点接到新链表后面，若pHead2为空，那我们需要将pHead1剩余的节点接到新链表后面，这样也就完成了。当然最后我们返回的是root->next。

题目二代码

/*
struct ListNode {
	int val;
	struct ListNode *next;
	ListNode(int x) :
			val(x), next(NULL) {
	}
};*/
class Solution {
public:
    ListNode* Merge(ListNode* pHead1, ListNode* pHead2)
    {
        if(pHead1==NULL)
            return pHead2;
        if(pHead2==NULL)
            return pHead1;
        ListNode* FinalList=new ListNode(-1);
        FinalList->next=NULL;
        ListNode* root=FinalList;
        while(pHead1!=NULL&&pHead2!=NULL)
        {
            if(pHead1->val<=pHead2->val)  //判断链表哪个值小先进行操作
            {
                FinalList->next=pHead1;  //FinalList指向pHead1
                pHead1=pHead1->next;  //pHead1往后指，
                					  //因为一个节点已经被处理
                FinalList=FinalList->next;
            }
            else
            {
                FinalList->next=pHead2;
                pHead2=pHead2->next;
                FinalList=FinalList->next;
            }
        }
        if(pHead1==NULL)
        {
            while(pHead2!=NULL)
            {
                FinalList->next=pHead2;
                pHead2=pHead2->next;
                FinalList=FinalList->next;
            }
        }
        if(pHead2==NULL)
        {
            while(pHead1!=NULL)
            {
                FinalList->next=pHead1;
                pHead1=pHead1->next;
                FinalList=FinalList->next;
            }
        }
        
        return root->next;
    }
};

  
另外还有一种类似的方法是我当初没想明白的时候敲的，我这里是把两个链表的值都存储到一个数组当中，当然数组里面是保证单调不减的，然后再创建新链表，依次从数组当中取值建立新节点，然后完成这个新链表并返回。
这种的话比较繁琐麻烦，不过更好理解吧。

/*
struct ListNode {
    int val;
    struct ListNode *next;
    ListNode(int x) :
            val(x), next(NULL) {
    }
};*/
class Solution {
public:
    ListNode* Merge(ListNode* pHead1, ListNode* pHead2)
    {
        int a[100];
        bool flag1=false;
        bool flag2=false;
        int i=0;
        if(pHead1==NULL)
            return pHead2;
        if(pHead2==NULL)
            return pHead1;
        while(pHead1!=NULL&&pHead2!=NULL)
        {
            if(pHead1->val<=pHead2->val)
            {
                a[i++]=pHead1->val;
                pHead1=pHead1->next;
            }
            else
            {
                a[i++]=pHead2->val;
                pHead2=pHead2->next;
            }
            if(pHead1==NULL)
            {
                flag1=true;
                break;
            }
            if(pHead2==NULL)
            {
                flag2=true;
                break;
            }
        }
        if(flag1)
        {
            while(pHead2!=NULL)
            {
                a[i++]=pHead2->val;
                pHead2=pHead2->next;
            }
        }
        if(flag2)
        {
            while(pHead1!=NULL)
            {
                a[i++]=pHead1->val;
                pHead1=pHead1->next;
            }
        }
        ListNode* FinalList=new ListNode(a[0]);
        ListNode *p;
        ListNode *temp0 = FinalList;
        for(int j=1;j<i;j++)
        {
            p=new ListNode(a[j]);
            temp0->next=p;
            temp0=temp0->next;
        }
        return FinalList;
    }
};