记录一下链表的一些题目
#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个节点