链表相关手撕算法===更新ing

创建新链表

复制一条链表

ListNode* copy(ListNode* head)
{
	ListNode* curr=head;
	ListNode* dummyNode=new ListNode(0);
	ListNode* pre=dummyNode;
	while(curr)
	{
		ListNode* node=new ListNode(curr->val);
		pre->next=node;
		curr=curr->next;
		pre=node;
	}
	return dummyNode->next; 
}

头插法创建新链表

    ListNode* create(ListNode* nodeHead, vector<int>& nums)
    {
        ListNode* newNode;
        for(int i=0;i<nums.size();i++)
        {
            newNode=neW ListNode(nums[i]);
            newNode->next=nodeHead->next;
            nodeHead->next=newNode;
        }
        return nodeHead;
    }

尾插法创建新链表

    ListNode* create(ListNode* nodeRear, vector<int>& nums)
    {
        ListNode* newNode;
        ListNode* tmp=nodeRear;
        for(int i=0;i<nums.size();i++)
        {
            newNode=neW ListNode(nums[i]);
            tmp->next=newNode;
            tmp=newNode; 
        }
        return nodeRear;
    }

合并链表

合并两个从大到小的链表为从小到大的链表

要求：每个节点只能访问一次，所以不能使用翻转后合并的思路。实现代码如下【原理参考头插法】

	ListNode* merge(ListNode* t1, ListNode*q1)
    {
        ListNode* newList=nullptr;
        ListNode* currList;
        while(t1 && q1)
        {
             if(t1->val > q1->val)
            {
                currList=t1->next;
                t1->next=newList;
                newList=t1;
                t1=currList;
            }
            else
            {
                currList=q1->next;
                q1->next=newList;
                newList=q1;
                q1=currList;
            }
        }
        while(t1)
        {
            currList=t1->next;
            t1->next=newList;
            newList=t1;
            t1=currList;
        }
        while(q1)
        {
            currList=q1->next;
            q1->next=newList; 
            newList=q1;
            q1=currList;
        }
        return newList;
    }

倒序输出链表

void daoxu(ListNode* curr)
{
	if(curr==nullptr) return;
    daoxu(curr->next);
    cout<<curr->val<<endl;
}

链表倒数第k个节点

思路：头节点前加入一个dummyNode，快慢指针从dummyNode开始，先将fast指针移动k+1步，然后同时移动快慢指针，直至fast指针为null，此时，slow指针的下一个节点即为倒数第k个节点。

ListNode* dummyNode=new ListNode(0);
dummyNode->next=head;
ListNode* fast=dummyNode;
ListNode* slow=dummyNode;
int n=k+1;
while(n--)
{
    fast=fast->next;
}
while(fast)
{
    fast=fast->next;
    slow=slow->next;
}
return slow->next;