链表算法：合并两个有序链表将小于x的数据置于链表前部分链表的回文判断

Posted 2021-07-18 蚍蜉撼树谈何易

一、合并两个有序链表
方法一、通过插入思想完成
1.首先确定头结点是l1链表还是l2链表
2.根据l1与l2当前指向的数据判断应该插入到哪一位置
3.若此时已遍历到某一链表的结束位置，则将新链表的最后一个元素指向另一链表的起始位置（从判断的当前元素开始的位置），循环结束。

struct ListNode* mergeTwoLists(struct ListNode* l1, struct ListNode* l2){
    struct ListNode *head = NULL,*pre = NULL;;
    while(l1 != NULL || l2 != NULL)
    {
        if(head == NULL)
        {
            if(l1 == NULL)
            {
                return l2;
            }
            else if(l2 == NULL)
            {
                return l1;
            }
            else
            {
                if(l1->val <= l2->val)
                {
                    head = l1;
                    pre = head;
                    l1 = l1->next;
                }
                else
                {
                    head = l2;
                    pre = head;
                    l2 = l2->next;
                }
            }
        }
        else
        {
            if(l1 == NULL)
            {
                pre->next = l2;
                break;
            }
            else if(l2 == NULL)
            {
                pre->next = l1;
                break;
            }
            else
            {
                if(l1->val <= l2->val)
                {
                    pre->next = l1;
                    pre = pre->next;
                    l1 = l1->next;
                }
                else
                {
                    pre->next = l2;
                    pre = pre->next;
                    l2 = l2->next;
                }
            }
        }
    }
    return head;
}

方法二、递归思想

struct ListNode* mergeTwoLists(struct ListNode* l1, struct ListNode* l2) {
    if(l1==NULL)
        return l2;
    if(l2==NULL)
        return l1;
    if(l1->val < l2->val)//确定合成链表的首元素,l1或l2指向位移
    {
        l1->next = mergeTwoLists(l1->next,l2);
        return l1;
    }else{
        l2->next = mergeTwoLists(l1,l2->next);
        return l2;
    }
}

详细讲解对应小破站：合并链表
二、将小于x的数据置于链表的前半部分

ListNode* partition(ListNode* pHead, int x)
{
	if (pHead == NULL)
	{
		return;
	}
	//思路：先将大于x的元素排成一列，再将小于x的链表排成一列，最后连接起来即可
	ListNode* pheader1 = NULL;//记录的是大于等于x的链表
	ListNode* pheader2 = NULL;//记录的是小于x的链表
	ListNode* ptail1 = NULL;//维护的是大于x的链表尾结点
	ListNode* ptail2 = NULL;//维护的是小于x的链表尾结点
	while (pHead)
	{
		if (pHead->val >= x)
		{
			if (pheader1 == NULL)
			{
				pheader1 = pHead;//先确定首元素
				ptail1 = pheader1;//同时更新尾结点
			}
			else
			{
				ptail1->next = pHead;
				ptail1 = pHead;
			}
		}
		else
		{
			if (pheader2 == NULL)
			{
				pheader2 = pHead;
				ptail2 = pheader2;
			}
			else
			{
				ptail2->next = pHead;//每次采取尾插的方式插入
				ptail2 = pHead;
			}
		}
		pHead = pHead->next;
	}
	if (pheader2 != NULL)
	{

		ptail2->next = pheader1;//将两个链表连接起来，同时设立终止结点（将最后一个元素的next置为空，便于访问）
		ptail1->next = NULL;
		return pheader2;
	}
	else
	{
		ptail1->next = NULL;
		return pheader1;
	}

}
};

三、链表的回文判断
方法：
1.先利用快慢指针找到该链表的中间结点
2.找到中间结点slow后，自slow开始将slow之后链表逆序，整合成一个新链表
3.将新链表与slow前面的链所形成的链表进行比对。当对比到最后一个元素时，所有元素都相同时返回true，否则false。

class PalindromeList {
public:
    bool chkPalindrome(ListNode* A) {
        //解题思路：首先利用快慢指针方法得出链表的中间结点
        //将后半部分逆置
        //将一份为二的两个链表进行对比
      ListNode*fast=A;
      ListNode*slow=A;
        while(fast&&fast->next)
        {
            slow=slow->next;
            fast=fast->next->next;
        }
        ListNode*pre=NULL;
        ListNode*pcur=slow;
        ListNode*pnext=NULL;
        while(pcur)
        {
            pnext=pcur->next;
            pcur->next=pre;
            pre=pcur;
            pcur=pnext;
        }
        while(pre!=NULL&&A!=NULL)
        {
            if(pre->val!=A->val)
            {
                return false;
            }
            pre=pre->next;
            A=A->next;
        }
        return true;
        
        
    }
};

希望大家越来越好吧（词穷了！！！）