LeetCode中一些链表方面的题

记录一下链表的一些题目

#include "stdafx.h"
#include<iostream>
#include"MyChain.h"
#include <stack>
using namespace std;
//一个Y形链表
//35-45 -75-25-35-5-15
//55-25-65/
ListNode *yChain[2] = { 0 };
ListNode *loopChain =nullptr;
void getYChain() {
	ListNode *p1 = new ListNode(15);
	ListNode *p2 = new ListNode(5,p1);
	ListNode *p3 = new ListNode(35,p2);
	ListNode *p4 = new ListNode(25,p3);
	ListNode *p5 = new ListNode(75,p4);
	ListNode *p6 = new ListNode(45,p5);
	ListNode *p7 = new ListNode(35,p6);
	ListNode *p0 = new ListNode(65,p5);
	ListNode *p9 = new ListNode(25,p0);
	ListNode *p8 = new ListNode(55,p9);
	yChain[0] = p7;
	yChain[1] = p8;
}
//一个环形链表
//35-45 -75-25-35-5-15----------->75
ListNode* getLoopChain() {
	ListNode *p1 = new ListNode(15);
	ListNode *p2 = new ListNode(5, p1);
	ListNode *p3 = new ListNode(35, p2);
	ListNode *p4 = new ListNode(25, p3);
	ListNode *p5 = new ListNode(75, p4);
	ListNode *p6 = new ListNode(45, p5);
	ListNode *p7 = new ListNode(35, p6);
	p1->next = p5;
	loopChain = p7;
	return p7;
}

//反转单链表递归
ListNode* reverseList1(ListNode* head) {
	if (!head || !(head->next)) return head;
	ListNode* node = reverseList1(head->next);
	head->next->next = head;
	head->next = NULL;
	return node;
}
ListNode* reverseList2(ListNode* head) {
	if (!head)return head;
	ListNode *p = head, *q = head->next, *r = nullptr;
	head->next = nullptr;
	while (q) {
		r = q->next;
		q->next = p;
		p = q;
		q = r;
	}
	head->next = nullptr;
	return p;
}
ListNode* reverseList(ListNode* head) {
	ListNode* pre = NULL;
	while (head) {
		ListNode* next = head->next;
		head->next = pre;
		pre = head;
		head = next;
	}
	return pre;
}
//反转部分单链表
ListNode *turnPartChain(ListNode*head, int begin, int last) {
	int n = last - begin,i=n;
	ListNode* pBegin = head,*p= head->next,*q=nullptr,*r=nullptr;
	//先定位到要反转的前一个位置
	while (p&&--i>1)
	{
		p = p->next;
	}
	q = p->next;
	while (n--&&q)
	{
		r = q->next;
		q->next = p;
		p = q;
		q = r;
	}
	return nullptr;
}
//是否有环
bool isThereLoop(ListNode* head) {
	if (!head)
	{
		return false;
	}
	ListNode* fast = head;
	ListNode* slow = head;
	while (fast&&fast->next)
	{ 
		slow = slow->next;
		fast = fast->next->next;
		if (slow==fast)
		{
			return true;
		}
	}
	return false;
}
//6形链表的入口
void get6typeEntrance(ListNode*head) {
	if (!head)
	{
		return ;
	}
	ListNode* fast = head;
	ListNode* slow = head;
	ListNode* phead = head; 
	while (fast&&fast->next)
	{
		slow = slow->next;
		fast = fast->next->next;
		if (slow == fast)
		{
			cout << "相遇点："<<slow->val << endl;
			while (phead!=fast)
			{
				phead = phead->next;
				fast = fast->next;
			}
			cout << "入口点：" << phead->val << endl;
			break;
		}
	}
}
ListNode *detectCycle(ListNode *head) {
	if (!head || !head->next)return head;
	ListNode* fast = head, *slow = head, *pre = head;
	while (fast&&fast->next) {
		slow = slow->next;
		fast = fast->next->next;
		if (fast == slow) {
			while (pre != slow) {
				pre = pre->next;
				slow = slow->next;
				if (pre == slow)return pre;
			}
		}
	}
	return nullptr;
}
//两个链表相交节点
void chainCross(ListNode*p1, ListNode*p2) {
	int len1 = 0, len2 = 0,diff=0;
	ListNode* ptemp1 = p1, *ptemp2 = p2;
	while (ptemp1) {
		ptemp1 = ptemp1->next;
		len1++;
	}
	while (ptemp2)
	{
		ptemp2 = ptemp2->next;
		len2++;
	}
	ptemp1 = p1, ptemp2 = p2;
	if (len1>len2)
	{
		diff = len1 - len2;
		while (diff--)ptemp1 = ptemp1->next;
		while (ptemp1&&ptemp2)
		{
			if (ptemp1==ptemp2)
			{
				cout << "已找到" << ptemp1->val;
				return;
			}			
			ptemp1 = ptemp1->next;
			ptemp2 = ptemp2->next;
		}
		cout << "未找到" << endl;
	}
	else {
		diff = len2 - len1;
		while (diff--)ptemp2 = ptemp2->next;
		while (ptemp1&&ptemp2)
		{
			if (ptemp1 == ptemp2)
			{
				cout << "已找到" << ptemp1->val;
				return;
			}
			ptemp1 = ptemp1->next;
			ptemp2 = ptemp2->next;
		}
		cout << "未找到" << endl;
	}
}
ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
	int len1 = 0, len2 = 0, diff = 0;
	ListNode*p1 = headA, *p2 = headB;
	if (!headA || !headB)return nullptr;
	while (p1) {
		len1++;
		p1 = p1->next;
	}
	while (p2) {
		len2++;
		p2 = p2->next;
	}
	p1 = headA;
	p2 = headB;
	if (len1>len2) {
		diff = len1 - len2;
		while (diff--)p1 = p1->next;
		while (p1&&p2) {
			if (p1 == p2)return p1;
			p1 = p1->next;
			p2 = p2->next;
		}
	}
	else {
		diff = len2 - len1;
		while (diff--)p2 = p2->next;
		while (p1&&p2) {
			if (p1 == p2)return p1;
			p1 = p1->next;
			p2 = p2->next;
		}
	}
	return nullptr;
}

//就地删除某个
void deleteChainNode(ListNode* toBeDel) {
	if (!toBeDel||(!toBeDel->next))
	{
		cout << "非法或者为空" << endl;
		return;
	}
	ListNode* ptemp = toBeDel->next;
	toBeDel->val = ptemp->val;
	toBeDel->next = ptemp->next;
	ptemp->next = nullptr;
	delete ptemp;
}
//逆序输出_递归
void reversePrint(ListNode*p) {
	if (!p)
	{
		return;
	}
	if (!p->next)
	{
		cout << p->val<<"\t";
		return;
	}
	reversePrint(p->next);
	cout << p->val << "\t";
}
//逆序输出_非递归
void reversePrint2(ListNode*p) {
	if (!p)
	{
		return;
	}
	stack<ListNode*>s;
	while (p)
	{
		s.push(p);
		p = p->next;
	}
	ListNode* temp=nullptr;
	while (!s.empty())
	{
		temp = s.top();
		s.pop();
		cout << temp->val << "\t";
	}
}
//删除重复
void removeDup(ListNode*head) {
	if (!head)
	{
		return;
	}
	ListNode* p=head,*temp=nullptr;
	while (p->next)
	{
		if (p->next->val==p->val)
		{
			temp = p->next;
			p->next = temp->next;
			temp->next = nullptr;
			delete temp;
		}
		p = p->next;
	}
	cout << head;
}
//删除指定值
void removeHelper(ListNode *&head, int val)
{
	if (head == nullptr)
	{
		return;
	}
	else if (head->val == val)
	{
		head = head->next;
	}
	removeHelper(head->next, val);
}
ListNode *removeElements(ListNode *&head, int val)
{
	ListNode **list = &head;

	while (*list != nullptr)
	{
		if ((*list)->val == val)
		{
			*list = (*list)->next;
		}
		else
		{
			list = &(*list)->next;
		}
	}

	return head;
}
//是否回文序列
ListNode* reversNodes(ListNode*head) {
	ListNode* pre = nullptr;
	ListNode* next = nullptr;
	while (head) {
		next = head->next;
		head->next = pre;
		pre = head;
		head = next;
	}
	return pre;
}
bool isPalindrome(ListNode* head) {
	//     stack<ListNode*>s;
	//     ListNode* p=head;
	//     if(!head)return true;
	//     while(p){
	//         s.push(p);
	//         p=p->next;
	//     }
	//     p=head;
	//     while(p){
	//         if((p->val)!=(s.top()->val))return false;
	//         s.pop();
	//         p = p->next;
	//     }
	//     return true;
	ListNode* fast = head, *slow = head;
	while (fast&&fast->next) {
		fast = fast->next->next;
		slow = slow->next;
	}
	fast = reversNodes(slow);
	slow = head;
	while (fast) {
		if (slow->val != fast->val)return false;
		slow = slow->next;
		fast = fast->next;
	}
	return true;
}
ListNode *palindromeTemp=nullptr;
bool isPalindromeRec(ListNode*head) {
	if (!head)return true;
	int a = palindromeTemp->val, b = head->val;
	bool isPalin = isPalindromeRec(head->next) && (palindromeTemp->val == head->val); 
	palindromeTemp = palindromeTemp->next;
	return isPalin;
}
bool isPalindrome2(ListNode* head) {
	palindromeTemp = head;
	return isPalindromeRec(head);
}
//合并两个链表
ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
	ListNode* dummy = new struct ListNode(0);
	ListNode* p = l1, *q = l2, *temp = dummy;
	while (p&&q) {
		if (p->val<q->val) {
			dummy->next = p;
			p = p->next;
		}
		else {
			dummy->next = q;
			q = q->next;
		}
		dummy = dummy->next;
	}
	dummy->next = q ? q : p;
	return temp->next;
}
//向右移动k个
ListNode* rotateRight(ListNode* head, int k) {
	if (k<1)return head;
	int ktemp = 1;
	ListNode* p = head, *q = head, *newHead = nullptr;
	while (p = p->next)ktemp++;
	if(ktemp>k)ktemp = k%ktemp;
	if (ktemp == k)return head;
	p = head;
	while (ktemp--&&p)p = p->next;
	if (ktemp > 0)return head;
	while (p&&p->next) {
		q = q->next;
		p = p->next;
	}
	newHead = q->next;
	q->next = nullptr;
	p->next = head;
	return newHead;
}
//排序

//ListNode* sortList(ListNode* head) {
//	ListNode* p = head, *q = nullptr, *temp = nullptr;
//	while (p&&p->next) {
//		temp = p;
//		q = p->next;
//		while (q) {
//			temp = temp->val<q->val ? q : temp;
//			q = q->next;
//		}
//		swap(p->val, temp->val);
//	}
//	return head;
//}
ListNode* merge(ListNode*l1, ListNode* l2) {
	ListNode head(0);
	ListNode* cur = &head;
	while (l1&&l2) {
		if (l1->val<l2->val) {
			cur->next = l1;
			l1 = l1->next;
		}
		else {
			cur->next = l2;
			l2 = l2->next;
		}
		cur = cur->next;
	}
	cur->next = l1 ? l1 : l2;
	return head.next;
}

ListNode* sortList(ListNode* head) {
	/*
	ListNode* p=head,*q=nullptr,*temp=nullptr;
	while(p&&p->next){
	temp=p;
	q=p->next;
	while(q){
	temp=temp->val<q->val?temp:q;
	q=q->next;
	}
	swap(p->val,temp->val);
	p=p->next;
	}
	return head;
	}*/
	if (!head || !head->next)return head;
	ListNode* fast = head, *slow = head;
	while (fast&&fast->next) {
		slow = slow->next;
		fast = fast->next->next;
	}
	ListNode* right = sortList(slow->next);
	slow->next = nullptr;
	ListNode* left = sortList(head);
	return merge(left, right);
}
//插入排序
ListNode* insertionSortList(ListNode* head) {
	if (!head) {
		return head;
	}

	ListNode *helper = new ListNode(0); //new starter of the sorted list
	ListNode *cur = head; //the node will be inserted
	ListNode *pre = helper; //insert node between pre and pre.next
	ListNode *next = nullptr; //the next node will be inserted
							  //not the end of input list
	while (cur) {
		next = cur->next;
		//find the right place to insert
		while (pre->next && pre->next->val < cur->val) {
			pre = pre->next;
		}
		//insert between pre and pre.next
		cur->next = pre->next;
		pre->next = cur;
		pre = helper;
		cur = next;
	}

	return helper->next;
}
//123456--->162534
void reorderList1(ListNode *head) {
	if (!head || !head->next) return;
	// find the middle node: O(n)
	ListNode *p1 = head, *p2 = head->next;
	while (p2 && p2->next) {
		p1 = p1->next;
		p2 = p2->next->next;
	}
	// cut from the middle and reverse the second half: O(n)
	ListNode *head2 = p1->next;
	p1->next = NULL;
	p2 = head2->next;
	head2->next = NULL;
	while (p2) {
		p1 = p2->next;
		p2->next = head2;
		head2 = p2;
		p2 = p1;
	}
	// merge two lists: O(n)
	for (p1 = head, p2 = head2; p1; ) {
		auto t = p1->next;
		p1 = p1->next = p2;
		p2 = t;
	}
}
void reorderList2(ListNode* head) {
	if (!head || !head->next)return;
	ListNode* temp = head, *pre = temp;
	while (temp->next) {
		pre = temp;
		temp = temp->next;
	}
	pre->next = nullptr;
	temp->next = head->next;
	head->next = temp;
	reorderList2(temp->next);
}
//将树转为平衡二叉树
struct TreeNode {
	int val;
	TreeNode *left;
	TreeNode *right;
	TreeNode(int x) : val(x), left(NULL), right(NULL) {}
	
};
TreeNode* sortedListToBST(ListNode* head) {
	if (!head)return nullptr;
	if(!head->next)return new TreeNode(head->val);
	ListNode* fast = head, *slow = head;
	ListNode* left = slow, *right = slow;
	while (fast&&fast->next) {
		left = slow;
		slow = slow->next;
		fast = fast->next->next;
	}
	cout << slow->val << " ";
	right = slow->next;
	TreeNode *root = new TreeNode(slow->val);
	left->next = nullptr;
	slow->next = nullptr;
	root->left = sortedListToBST(head);
	root->right = sortedListToBST(right);
	return root;
}
//将偶数位置的全部移动到右边
ListNode* oddEvenList(ListNode* head)
{
	if (!head) return head;
	ListNode *odd = head, *evenhead = head->next, *even = evenhead;
	while (even && even->next)
	{
		odd->next = odd->next->next;
		even->next = even->next->next;
		odd = odd->next;
		even = even->next;
	}
	odd->next = evenhead;
	return head;
}
//每间隔k组进行反转
ListNode* reverseKGroup(ListNode* head, int k) {
	if (!head || k == 1)return head;
	int ktemp = k;
	ListNode* cur = head, *turnHead = head;
	while (ktemp--) {
		if (!cur)return head;
		cur = cur->next;
	}
	ListNode* nextG = reverseKGroup(cur, k);
	ListNode*p = head, *q = head->next, *r = nullptr;
	while (p&&p->next&&--k) {
		r = q->next;
		q->next = p;
		p = q;
		q = r;
	}
	head->next = nextG;
	return p;
}
//链表相加首部对齐
ListNode *addTwoNumbers(ListNode *l1, ListNode *l2) {
	ListNode preHead(0), *p = &preHead;
	int extra = 0;
	while (l1 || l2 || extra) {
		if (l1) extra += l1->val, l1 = l1->next;
		if (l2) extra += l2->val, l2 = l2->next;
		p->next = new ListNode(extra % 10);
		extra /= 10;
		p = p->next;
	}
	return preHead.next;
}
//链表相加尾部对齐
ListNode* addToFront(int val, ListNode* head) {
	ListNode* temp = new ListNode(val);
	temp->next = head;
	return temp;
}
ListNode* addTwoNumbersTail(ListNode* l1, ListNode* l2) {
	int n1 = 0, n2 = 0, carry = 0;
	ListNode *curr1 = l1, *curr2 = l2, *res = NULL;
	while (curr1) { curr1 = curr1->next; n1++; }
	while (curr2) { curr2 = curr2->next; n2++; }
	curr1 = l1; curr2 = l2;
	while (n1 > 0 && n2 > 0) {
		int sum = 0;
		if (n1 >= n2) { sum += curr1->val; curr1 = curr1->next; n1--; }
		if (n2 > n1) { sum += curr2->val; curr2 = curr2->next; n2--; }
		res = addToFront(sum, res);
	}
	curr1 = res; res = NULL;
	while (curr1) {
		curr1->val += carry; carry = curr1->val / 10;
		res = addToFront(curr1->val % 10, res);
		curr2 = curr1;
		curr1 = curr1->next;
		delete curr2;
	}
	if (carry) res = addToFront(1, res);
	return res;
}
ListNode* addTwoNumbersTail2(ListNode* l1, ListNode* l2) {
	return addTwoNumbers(reverseList(l1), reverseList(l2));
}
//Given 1->4->3->2->5->2 and x = 3,return 1->2->2->4->3->5.
//相当于将构建1-2-2  4-3-5，再把他们连起来
ListNode *partition(ListNode *head, int x) {
	ListNode node1(0), node2(0);
	ListNode *p1 = &node1, *p2 = &node2;
	while (head) {
		if (head->val < x)
			p1 = p1->next = head;
		else
			p2 = p2->next = head;
		head = head->next;
	}
	p2->next = NULL;
	p1->next = node2.next;
	return node1.next;
}
//删除所有有重复数字的节点11123455--->234
ListNode* deleteDuplicates1(ListNode* head) {
	if (!head || !head->next)return head;
	ListNode *newhead = new ListNode(0);
	newhead->next = head;
	ListNode *cur = head, *pre = newhead, *q = cur->next;
	while (cur) {
		q = cur->next;
		if (q&&cur->val == q->val) {
			while (cur&&cur->val == q->val)cur = cur->next;
			pre->next = cur;
		}
		else {
			pre = cur;
			cur = q;
		}
	}
	return newhead->next;
}
ListNode* deleteDuplicates(ListNode* head) {
	if (!head) return 0;
	if (!head->next) return head;

	int val = head->val;
	ListNode* p = head->next;

	if (p->val != val) {
		head->next = deleteDuplicates(p);
		return head;
	}
	else {
		while (p && p->val == val) p = p->next;
		return deleteDuplicates(p);
	}
}
//删除倒数第k个节点