目录
① 203.移除链表元素
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* struct ListNode *next;
* };
*/
typedef struct ListNode ListNode;
struct ListNode* removeElements(struct ListNode* head, int val) {
ListNode*newHead = NULL, *newTail = NULL;
ListNode*pcur = head;
while(pcur != NULL)
{
if(pcur->val != val)
{
if(newHead == NULL)
{
//将新链表的头尾指针指向原链表头节点
newHead = newTail = pcur;
}
else
{
newTail->next = pcur;
newTail = newTail->next;
}
}
pcur = pcur->next;
}
if(newTail != NULL)
{
newTail->next = NULL;
}
return newHead;
}
② 206.反转链表
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* struct ListNode *next;
* };
*/
struct ListNode* reverseList(struct ListNode* head) {
struct ListNode* prev = NULL;//哨兵位
struct ListNode* cur = head;//头节点
while (cur)
{
// 哨兵位（prev） 节点1（cur） 节点2（cur->next）
struct ListNode* next = cur->next;//创建一个中间节点
//开始改变链表的方向
cur->next = prev;//节点2先指向节点1的前一个节点
prev = cur;//哨兵位往后移动
cur = next;//节点1向后移动
}
return prev;
}
③ 876.链表的中间节点
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* struct ListNode *next;
* };
*/
struct ListNode* middleNode(struct ListNode* head) {
//慢指针（一次走一步）
struct ListNode* slow = head;
//快指针（一次走两步）
struct ListNode* fast = head;
while(fast && fast->next){
slow = slow->next;
fast = fast->next->next;
}
return slow;
}
④ 返回倒数第k个节点（面试题）
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* struct ListNode *next;
* };
*/
int kthToLast(struct ListNode* head, int k) {
struct ListNode *fast = head, *slow = head;
//本题采用的是相对法：
// fast先运动k个节点
// 假设该链表的节点个数是 m+k 个
// 则先走k个节点，剩下fast指针到null指针时，即走了m个节点
// 此时，slow指针就剩余k个节点
while(k--){
fast = fast->next;
}
while(fast != NULL){
slow = slow->next;
fast = fast->next;
}
return slow->val;
}
⑤ 21.合并两个有序链表
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* struct ListNode *next;
* };
*/
struct ListNode* mergeTwoLists(struct ListNode* list1, struct ListNode* list2) {
if(list1 == NULL)
{
return list2;
}if(list2 == NULL)
{
return list1;
}
struct ListNode* l1 = list1;
struct ListNode* l2 = list2;
struct ListNode* newHead, *newTail;
newHead = newTail = NULL;
while(l1 && l2)
{
//比大小
if(l1->val < l2->val)
{
if(newHead == NULL)
{
newHead = newTail = l1;
}
else
{
newTail->next = l1;
newTail = newTail->next;
}
l1 = l1->next;
}
else
{
if(newHead == NULL)
{
newHead = newTail = l2;
}else
{
newTail->next = l2;
newTail = newTail->next;
}
l2 = l2->next;
}
}
if(l1)
{
newTail->next = l1;
}
if(l2)
{
newTail->next = l2;
}
return newHead;
}
⑥ 160.相交链表
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* struct ListNode *next;
* };
*/
struct ListNode *getIntersectionNode(struct ListNode *headA, struct ListNode *headB) {
struct ListNode* curA = headA, *curB = headB;
int lenA = 1, lenB = 1;
while(curA->next){
curA = curA->next;
++lenA;
}
while(curB->next){
curB = curB->next;
++lenB;
}
if(curA != curB){
return NULL;
}
//假设法
int gap = abs(lenA - lenB);
struct ListNode* longList = headA, *shortList = headB;
if(lenB > lenA){
longList = headB;
shortList = headA;
}`
while(gap--){
longList = longList->next;
}
while(longList != shortList){
longList = longList->next;
shortList = shortList->next;
}
return longList;
}
⑦ 138.随机链表的复制（深拷贝）
/**
* Definition for a Node.
* struct Node {
* int val;
* struct Node *next;
* struct Node *random;
* };
*/
struct Node* copyRandomList(struct Node* head) {
struct Node* cur = head;
while(cur){
struct Node * copy = (struct Node*)malloc(sizeof(struct Node));
//赋值
copy->val = cur->val;
//将copy链表插入原链表中
copy->next = cur->next;
cur->next = copy;
//cur向后移动
cur = copy->next;
}
//将copy链表中random指针的指向与原链表中的指针对调
cur = head;
while(cur){
struct Node* copy = cur->next;
if(cur->random == NULL){
copy->random = NULL;
}
else{
copy->random = cur->random->next;
}
cur = copy->next;
}
cur = head;
struct Node* copyHead = NULL,* copyTail =NULL;
while(cur){
struct Node* copy = cur->next;
if(copyTail == NULL)
{
copyHead = copyTail = copy;
}else
{
copyTail->next = copy;
copyTail = copyTail->next;
}
//cur向后移动
cur = copy->next;
}
return copyHead;
}
