链表基础
打印一个自定义链表。
#include<iostream>
using namespace std;
struct ListNode
{
int val;//数据域
ListNode* next;//指针域
ListNode(int val) :val(val), next(NULL)
{
}
};
int main()
{
ListNode a(1);
ListNode b(2);
ListNode c(3);
ListNode d(4);
ListNode e(5);
a.next = &b;
b.next = &c;
c.next = &d;
d.next = &e;
ListNode* head = &a;
while (head)
{
cout << head->val << endl;
head = head->next;
}
return 0;
}
链表逆序-1
已知链表的头结点,在不申请额外空间的前提下,将链表逆序。
#include<iostream>
using namespace std;
struct ListNode
{
int val;//数据域
ListNode* next;//指针域
ListNode(int val) :val(val), next(nullptr)
{
}
};
ListNode* reversedList(ListNode* head)
{
ListNode* newList = nullptr;
ListNode* nextNode = nullptr;
while (head)
{
nextNode = head->next;
head->next = newList;
newList = head;
head = nextNode;
}
return newList;
}
int main()
{
ListNode a(1);
ListNode b(2);
ListNode c(3);
ListNode d(4);
ListNode e(5);
a.next = &b;
b.next = &c;
c.next = &d;
d.next = &e;
ListNode* head = &a;
cout << "原链表:" << endl;
while (head)
{
cout << head->val << endl;
head = head->next;
}
head = reversedList(&a);
cout << "逆序后的链表:" << endl;
while (head)
{
cout << head->val << endl;
head = head->next;
}
return 0;
}
链表逆序-2
已知链表的头结点,在不申请额外空间的前提下,将链表从位置m到n逆序。
#include<iostream>
using namespace std;
struct ListNode
{
int val;//数据域
ListNode* next;//指针域
ListNode(int val) :val(val), next(nullptr)
{
}
};
ListNode* reversedAreaList(ListNode* head, int start, int end)
{
int areaLength = end - start + 1;
ListNode* newList = nullptr;
ListNode* preListNode = nullptr;//逆序前的头节点前驱
ListNode* result = head;
while (head && --start)
{
preListNode = head;
head = head->next;
}
ListNode* currListTail = head;
while (head && areaLength)
{
ListNode* nextNode = head->next;
head->next = newList;
newList = head;
head = nextNode;
areaLength--;
}
currListTail->next = head;
if (preListNode)
{
preListNode->next = newList;
}
else
{
result = newList;
}
return result;
}
int main()
{
ListNode a(1);
ListNode b(2);
ListNode c(3);
ListNode d(4);
ListNode e(5);
a.next = &b;
b.next = &c;
c.next = &d;
d.next = &e;
ListNode* head = &a;
cout << "原链表:" << endl;
while (head)
{
cout << head->val << endl;
head = head->next;
}
head = reversedAreaList(&a,2,4);
cout << "逆序m-n后的链表:" << endl;
while (head)
{
cout << head->val << endl;
head = head->next;
}
return 0;
}
链表交点
已知单链表A的头节点指针A,单链表B的头节点指针B,两个链表相交,求两链表交点的对应节点。
1-容器实现
#include<iostream>
using namespace std;
#include<set>
struct ListNode
{
int val;//数据域
ListNode* next;//指针域
ListNode(int val) :val(val), next(nullptr)
{
}
};
ListNode* intersectionNode(ListNode* headA, ListNode* headB)
{
set<ListNode*> nodeset;
while (headA)
{
nodeset.insert(headA);
headA = headA->next;
}
while (headB)
{
if (nodeset.find(headB) != nodeset.end())
{
return headB;
}
headB = headB->next;
}
return nullptr;
}
int main()
{
ListNode a(1);
ListNode b(2);
ListNode c(3);
ListNode d(4);
ListNode e(5);
a.next = &b;
b.next = &c;
c.next = &d;
d.next = &e;
ListNode f(6);
ListNode g(7);
f.next = &g;
g.next = &d;
ListNode* head = intersectionNode(&a,&f);
if (head)
{
cout << head->val << endl;
}
return 0;
}
2-遍历实现
#include<iostream>
using namespace std;
struct ListNode
{
int val;//数据域
ListNode* next;//指针域
ListNode(int val) :val(val), next(nullptr)
{
}
};
int getListLength(ListNode* head)
{
int len = 0;
while (head)
{
len++;
head = head->next;
}
return len;
}
ListNode* advanceNode(int shortLen, int longLen, ListNode* head)
{
int len = longLen - shortLen;
while (head && len)
{
head = head->next;
len--;
}
return head;
}
ListNode* intersectionNode(ListNode* headA, ListNode* headB)
{
int lengthA = getListLength(headA);
int lengthB = getListLength(headB);
if (lengthA < lengthB)
{
headB = advanceNode(lengthA, lengthB, headB);
}
else
{
headA = advanceNode(lengthB, lengthA, headA);
}
while (headA && headB)
{
if (headA == headB)
{
return headB;
}
headA = headA->next;
headB = headB->next;
}
return nullptr;
}
int main()
{
ListNode a(1);
ListNode b(2);
ListNode c(3);
ListNode d(4);
ListNode e(5);
a.next = &b;
b.next = &c;
c.next = &d;
d.next = &e;
ListNode f(6);
ListNode g(7);
f.next = &g;
g.next = &d;
ListNode* head = intersectionNode(&a,&f);
if (head)
{
cout << head->val << endl;
}
return 0;
}
链表求环
已知链表可能存在环,若有环返回环起始节点,否则返回NULL;
1-容器实现
#include<iostream>
#include<set>
using namespace std;
struct ListNode
{
int val;//数据域
ListNode* next;//指针域
ListNode(int val) :val(val), next(nullptr)
{
}
};
ListNode* startNode(ListNode* head)
{
set<ListNode*> nodeset;
while (head)
{
if (nodeset.find(head) != nodeset.end())
{
return head;
}
nodeset.insert(head);
head = head->next;
}
return NULL;
}
int main()
{
ListNode a(1);
ListNode b(2);
ListNode c(3);
ListNode d(4);
ListNode e(5);
a.next = &b;
b.next = &c;
c.next = &d;
d.next = &e;
e.next = &c;
ListNode* head = startNode(&a);
if (head)
{
cout << head->val << endl;
}
return 0;
}
2-遍历实现(快慢指针赛跑)
#include<iostream>
#include<set>
using namespace std;
struct ListNode
{
int val;//数据域
ListNode* next;//指针域
ListNode(int val) :val(val), next(nullptr)
{
}
};
ListNode* startNode(ListNode* head)
{
ListNode* slow = head;
ListNode* fast = head;
ListNode* meet = NULL;
while (fast)
{
slow = slow->next;
fast = fast->next;
if (!fast)
{
return NULL;
}
fast = fast->next;
if (fast == slow)
{
meet = fast;
break;
}
}
if (!meet)
{
return NULL;
}
while (head && meet)
{
if (head == meet)
{
return head;
}
head = head->next;
meet = meet->next;
}
return NULL;
}
int main()
{
ListNode a(1);
ListNode b(2);
ListNode c(3);
ListNode d(4);
ListNode e(5);
a.next = &b;
b.next = &c;
c.next = &d;
d.next = &e;
e.next = &c;
ListNode* head = startNode(&a);
if (head)
{
cout << head->val << endl;
}
return 0;
}
链表划分
已知链表头与数值指针val,要求将所有小于val的节点放在大于或等于val的节点前,且保持这些节点的原来的位置不变。
#include<iostream>
#include<set>
using namespace std;
struct ListNode
{
int val;//数据域
ListNode* next;//指针域
ListNode(int val) :val(val), next(nullptr)
{
}
};
ListNode* DivideListNode(ListNode* head,int val)
{
ListNode lesshead(0);//设置两个临时头节点
ListNode morehead(0);
ListNode* lessptr = &lesshead;//对应指针指向这两个头节点
ListNode* moreptr = &morehead;
while (head)
{
if (head->val < val)//将小于val的节点值放在lessptr后
{
lessptr->next = head;
lessptr = head;
}
else
{
moreptr->next = head;
moreptr = head;
}
head = head->next;
}
lessptr->next = morehead.next;//将less链表尾与more链表头相连
moreptr->next = NULL;
return lesshead.next;
}
int main()
{
ListNode a(6);
ListNode b(8);
ListNode c(3);
ListNode d(1);
ListNode e(2);
a.next = &b;
b.next = &c;
c.next = &d;
d.next = &e;
ListNode* head = DivideListNode(&a,3);
while(head)
{
cout << head->val << endl;
head = head->next;
}
return 0;
}
链表的深度拷贝
已知一个复杂的链表,节点中有一个指向本链表任意某个节点的随机指针(可以为空),求该链表的深度拷贝。
#include<iostream>
#include<map>
#include<vector>
using namespace std;
struct ListNode
{
int val;//数据域
ListNode* next;//指针域
ListNode* randomptr;//随机指针
ListNode(int val) :val(val), next(nullptr),randomptr(nullptr)
{
}
};
ListNode* DivideListNode(ListNode* head)
{
map<ListNode*, int> nodemap;
vector<ListNode*> nodevec;
ListNode* ptr = head;
int i = 0;
while (ptr)
{
nodevec.push_back(new ListNode(ptr->val));
nodemap[ptr] = i;
i++;
ptr = ptr->next;
}
ptr = head;
i = 0;
nodevec.push_back(0);
while (ptr)
{
nodevec[i]->next = nodevec[i + 1];
if (ptr->randomptr)
{
int id = nodemap[ptr->randomptr];
nodevec[i]->randomptr = nodevec[id];
}
ptr = ptr->next;
i++;
}
return nodevec[0];
}
int main()
{
ListNode a(1);
ListNode b(2);
ListNode c(3);
ListNode d(4);
ListNode e(5);
a.next = &b;
b.next = &c;
c.next = &d;
d.next = &e;
a.randomptr = &c;
b.randomptr = &b;
c.randomptr = &b;
e.randomptr = nullptr;
ListNode* head = DivideListNode(&a);
while(head)
{
cout << head->val;
if(head->randomptr)
cout << head->randomptr->val << endl;
else
cout << endl;
head = head->next;
}
return 0;
}
链表合并-1
已知两个已排序的链表,头节点指针分别为headA和headB,现要求将这两个链表合并,合并后仍为有序的,并返回合并后的头节点。
#include<iostream>
#include<map>
#include<vector>
using namespace std;
struct ListNode
{
int val;//数据域
ListNode* next;//指针域
ListNode(int val) :val(val), next(nullptr)
{
}
};
ListNode* mergeList(ListNode* headA,ListNode* headB)
{
ListNode tmpNode(0);
ListNode* ptr = &tmpNode;
while (headA && headB)
{
if (headA->val < headB->val)
{
ptr->next = headA;
headA = headA->next;
}
else
{
ptr->next = headB;
headB = headB->next;
}
ptr = ptr->next;
}
if (headA)
{
ptr->next = headA;
}
else
{
ptr->next = headB;
}
return tmpNode.next;
}
int main()
{
ListNode a(1);
ListNode b(2);
ListNode c(3);
ListNode d(4);
ListNode e(5);
ListNode f(6);
a.next = &b;
b.next = &c;
d.next = &e;
e.next = &f;
ListNode* head = mergeList(&a,&d);
while(head)
{
cout << head->val << endl;
head = head->next;
}
return 0;
}
链表合并-2
已知k个已排序链表头节点指针,要求将这k个链表合并合并后仍为有序的,并返回合并后的该链表的头节点。
1-容器排序实现
#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
struct ListNode
{
int val;//数据域
ListNode* next;//指针域
ListNode(int val) :val(val), next(nullptr)
{
}
};
bool cmp(const ListNode *a,const ListNode *b)
{
return a->val < b->val;
}
ListNode* sortList(vector<ListNode*> vec)
{
vector<ListNode*> nodevec;
for (int i = 0; i < vec.size(); i++)
{
ListNode* head = vec[i];
while (head)
{
nodevec.push_back(head);
head = head->next;
}
}
if (!nodevec.size())
{
return NULL;
}
sort(nodevec.begin(), nodevec.end(), cmp);
nodevec[nodevec.size() - 1]->next = NULL;
for (int i = 1; i < nodevec.size(); i++)
{
nodevec[i - 1]->next = nodevec[i];
}
return nodevec[0];
}
int main()
{
ListNode a(6);
ListNode b(5);
ListNode c(4);
ListNode d(3);
ListNode e(2);
ListNode f(1);
a.next = &b;
c.next = &d;
e.next = &f;
vector<ListNode*> vec;
vec.push_back(&a);
vec.push_back(&c);
vec.push_back(&e);
ListNode* head = sortList(vec);
while(head)
{
cout << head->val << endl;
head = head->next;
}
return 0;
}
2-分治递归实现
#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
struct ListNode
{
int val;//数据域
ListNode* next;//指针域
ListNode(int val) :val(val), next(nullptr)
{
}
};
ListNode* mergeTwoList(ListNode* headA, ListNode* headB)
{
ListNode tmpNode(0);
ListNode* ptr = &tmpNode;
while (headA && headB)
{
if (headA->val < headB->val)
{
ptr->next = headA;
headA = headA->next;
}
else
{
ptr->next = headB;
headB = headB->next;
}
ptr = ptr->next;
}
if (headA)
{
ptr->next = headA;
}
else
{
ptr->next = headB;
}
return tmpNode.next;
}
ListNode* mergeKList(vector<ListNode*> vec)
{
if (!vec.size())
{
return NULL;
}
if (vec.size() == 1)
{
return vec[0];
}
if (vec.size() == 2)
{
return mergeTwoList(vec[0], vec[1]);
}
int size = vec.size() / 2;
vector<ListNode*> leftvec;
vector<ListNode*> rightvec;
for (int i = 0; i < size; i++)
{
leftvec.push_back(vec[i]);
}
for (int i = size; i < vec.size(); i++)
{
rightvec.push_back(vec[i]);
}
ListNode* headA = mergeKList(leftvec);
ListNode* headB = mergeKList(rightvec);
return mergeTwoList(headA, headB);
}
int main()
{
ListNode a(1);
ListNode b(7);
ListNode c(3);
ListNode d(4);
ListNode e(5);
ListNode f(8);
a.next = &b;
c.next = &d;
e.next = &f;
vector<ListNode*> vec;
vec.push_back(&a);
vec.push_back(&c);
vec.push_back(&e);
ListNode* head = mergeKList(vec);
while(head)
{
cout << head->val << endl;
head = head->next;
}
return 0;
}