1、使用常量空间复杂度在O(n log n)时间内对链表进行排序。
思路:
/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */ class Solution { public: //找到链表中的中点 ListNode *findMiddle(ListNode *head){ ListNode *chaser = head; ListNode *runner = head->next; while(runner !=NULL &&runner->next != NULL){ chaser = chaser->next; runner = runner->next->next; } return chaser; } //将两组链表进行排序 ListNode *mergeTwoLists(ListNode* l1, ListNode* l2){ if(l1==NULL) return l2; if(l2==NULL) return l1; ListNode *dummy = new ListNode(0); ListNode *head = dummy; while(l1!=NULL && l2!=NULL){ if(l1->val > l2->val){ head->next = l2; l2 = l2->next; }else{ head->next = l1; l1 = l1->next; } head = head->next; } if(l1==NULL) head->next = l2; if(l2==NULL) head->next = l1; return dummy->next; } ListNode *sortList(ListNode *head) { if(head==NULL || head->next == NULL) return head; ListNode* middle = findMiddle(head); ListNode* right = sortList(middle->next); middle -> next = NULL; ListNode* left = sortList(head); return mergeTwoLists(left, right); } };
2、给出单链表L:L 0→L 1→...→L n-1→L n,
将其重新排序为:L 0→L n→L 1→L n-1→L 2→L n-2→......
您必须在不改变节点值的情况下就地执行此操作。
例如,
给定{1,2,3,4},将其重新排序为{1,4,2,3}。
思路:快慢指针找到中间节点,将后面的链表反转(前插法),合并链表
/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */ class Solution { public: void reorderList(ListNode *head) { ListNode *slow = head; ListNode *fast = head; //快慢指针找到中间节点 while(fast->next!=NULL && fast->next->next!=NULL){ slow = slow->next; fast = fast->next->next; } //拆分链表,并反转中间节点之后的链表 ListNode *after = slow->next; slow->next = NULL; ListNode *pre = NULL; while(after!=NULL){ ListNode *temp = after->next; after->next = pre; pre = after; after = temp; } // 合并两个表 ListNode *left = head; after = pre; while(left!=NULL && after!=NULL){ ListNode *ltemp = left->next; ListNode *rtemp = after->next; left->next = after; left = ltemp; after->next = left; after = rtemp; } } };
3、给定链表,返回循环开始的节点。 如果没有循环,则返回null。
跟进:
你能不用额外的空间解决它吗?
思路:
1)首先判断是否有环,有环时,返回相遇的节点,无环,返回null
2)有环的情况下, 求链表的入环节点
/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */ class Solution { public: ListNode *detectCycle(ListNode *head) { ListNode *slow = head; ListNode *fast = head; //找到相遇点 while(fast!=NULL && fast->next!=NULL){ slow=slow->next; fast=fast->next->next; //如果快慢指针相遇 if(slow==fast){ ListNode *temp = NULL; //一边走一边将走过的路清空,当遇到空时,此时就是相遇点 while(head->next){ temp = head->next; head->next = NULL; head = temp; } return head; } } return NULL; } };
4、给定一个链表,确定它是否有一个循环。
跟进:
你能不用额外的空间解决它吗?
思路:
利用快慢节点相遇即有环,
慢节点一次走一格
快捷点一次走两格
/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */ class Solution { public: bool hasCycle(ListNode *head) { ListNode *slow = head; ListNode *fast = head; //找到相遇点 while(fast!=NULL && fast->next!=NULL){ slow=slow->next; fast=fast->next->next; //如果快慢指针相遇 if(slow==fast) return true; } return false; } };
5、给出链表,使得每个节点包含一个附加的随机指针,该指针可以指向列表中的任何节点或为空。
返回列表的深层副本。
思路:
先拷贝新节点,插入到原节点的后边;然后再 拷贝随机指针;最后将新节点从原链表中分离出,注意要保证原链表正常。
/** * Definition for singly-linked list with a random pointer. * struct RandomListNode { * int label; * RandomListNode *next, *random; * RandomListNode(int x) : label(x), next(NULL), random(NULL) {} * }; */ class Solution { public: RandomListNode *copyRandomList(RandomListNode *head) { RandomListNode *p,*copy; if (!head) return NULL; //先将拷贝原节点产生的新节点,放在原节点的后面 for(p=head;p;p=p->next){ copy = new RandomListNode(p->label); copy->next = p->next; p = p->next = copy; } //拷贝random指针 for(p=head;p;p=copy->next){ copy = p->next; copy->random = (p->random?p->random->next:NULL); } //删除新节点 for(p=head,head=copy=p->next;p;){ p = p->next = copy->next; copy = copy->next = (p?p->next:NULL); } return head; } };
6、将位置m的链接列表反转到n。 在原地和一次通过。
例如:
给定1-> 2-> 3-> 4-> 5-> NULL,m = 2且n = 4,
return1->4->3-> 2->5-> NULL。
注意:
给定m,n满足以下条件:
1≤m≤n≤列表长度。
/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */ class Solution { public: ListNode *reverseBetween(ListNode *head, int m, int n) { ListNode *dummy = new ListNode(-1); ListNode *preStart,*Start; dummy->next = head; preStart = dummy; Start = head; for(int i=1;i<m;i++){ preStart = Start; Start = Start->next; } for(int i=0;i<n-m;i++){ ListNode *temp = Start->next; Start->next = temp->next; temp->next = preStart->next; preStart->next = temp; } return dummy->next; } };
7、给定链表和值x,对其进行分区,使得小于x的所有节点都在大于或等于x的节点之前。
您应该保留两个分区中每个分区中节点的原始相对顺序。
例如,
给定1-> 4-> 3-> 2-> 5-> 2和x = 3,
return1-> 2->2->4->3->5。
思路:
创建两张链表,分别我list01和list01
把节点值小于x的节点链接到链表1上,节点值大等于x的节点链接到链表2上。
/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */ class Solution { public: ListNode *partition(ListNode *head, int x) { //创建两个链表 ListNode *list01 = new ListNode(-1); ListNode *list02 = new ListNode(-2); ListNode *cur1 = list01; ListNode *cur2 = list02; while(head!=NULL){ //把节点值小于x的节点链接到链表1上 if(head->val < x){ cur1->next = head; cur1=cur1->next; } //节点值大等于x的节点链接到链表2上 else{ cur2->next = head; cur2=cur2->next; } head = head->next; } //合并两个链表 cur1->next = list02->next; cur2->next = NULL; return list01->next; } };
8、给定一个列表,将列表向右旋转k个位置,其中k为非负数。
例如:
给定1-> 2-> 3-> 4-> 5-> NULL和k = 2,
返回4-> 5-> 1-> 2-> 3-> NULL。
思路:
先遍历一遍,得出链表长度len,注意k可能会大于len,因此k%=len。
将尾结点next指针指向首节点,形成一个环,接着往后跑len-k步,从这里断开,就是结果
/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */ class Solution { public: ListNode *rotateRight(ListNode *head, int k) { if(head==NULL) return NULL; ListNode *p=head; int len=1; //计算连链表的长度 while(p->next){ len++; p=p->next; } k = len - k%len; //首尾相连 p->next = head; for(int i=0;i<k;i++){ p=p->next; } head = p->next; p->next = NULL; return head; } };
9、给定已排序的链接列表,删除所有具有重复数字的节点,只留下原始列表中的不同数字。
例如,
给定1-> 2-> 3-> 3-> 4-> 4-> 5,返回1-> 2-> 5。
给定1-> 1-> 1-> 2-> 3,return2-> 3。
思路:
首先要找到第一个非重复的节点作为头结点,
直接找比较麻烦,可以添加一个新结点list作为伪头结点,
最后返回list->next即可。
/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */ class Solution { public: ListNode *deleteDuplicates(ListNode *head) { if(head==NULL) return NULL; ListNode *list = new ListNode(head->val-1); list->next = head; ListNode *preStart = list; while(preStart->next && preStart->next->next){ ListNode *Start = preStart->next; ListNode *aftStart = Start->next; if(Start->val!=aftStart->val){ preStart->next = Start; preStart = Start; }else{ while(aftStart && Start->val==aftStart->val){ aftStart=aftStart->next; } preStart->next = aftStart; } } return list->next; } };
10、给定已排序的链接列表,删除所有重复项,使每个元素只出现一次。
例如,
给定1-> 1-> 2,return1-> 2。
给定1-> 1-> 2-> 3-> 3,返回1-> 2-> 3。
/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */ class Solution { public: ListNode *deleteDuplicates(ListNode *head) { if(head == NULL || head->next == NULL) return head; ListNode* p1 = head; while(p1 != NULL && p1->next != NULL) { ListNode* p2 = p1->next; if(p1->val != p2->val) { p1->next = p2; p1 = p1->next; continue; } while(p2->next != NULL && p1->val == p2->next->val) p2 = p2->next; p1->next = p2->next; delete p2; p1 = p1->next; } return head; } };
11、合并两个已排序的链接列表并将其作为新列表返回。 新列表应该通过拼接前两个列表的节点来完成。
思路:和归并排序的思想一样
/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */ class Solution { public: ListNode *mergeTwoLists(ListNode *l1, ListNode *l2) { ListNode *head = new ListNode(0); ListNode *t = head; while (l1 != NULL || l2 != NULL) { if (l1 == NULL) { t->next = l2; l2 = l2->next; } else if (l2 == NULL) { t->next = l1; l1 = l1->next; } else if (l1->val < l2 -> val){ t->next = l1; l1 = l1->next; } else { t->next = l2; l2 = l2->next; } t = t->next; } return head->next; } };
12、给定链表,一次反转链表k的节点并返回其修改后的列表。
如果节点数不是k的倍数,那么最后的剩余节点应该保持不变。
您可能无法更改节点中的值,只能更改节点本身。
只允许常量内存。
例如,
鉴于此链表:1-> 2-> 3-> 4-> 5
对于k = 2,您应该返回:2-> 1-> 4-> 3-> 5
对于k = 3,您应该返回:3-> 2-> 1-> 4-> 5
/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */ class Solution { public: ListNode *reverseKGroup(ListNode *head, int k) { /* if(head==NULL || head->next==NULL || k<2) return head; ListNode *dummy = new ListNode(-1); dummy->next = head; ListNode *Start = head; ListNode *preStart = dummy; ListNode *temp; int len = 1; while(head!=NULL){ len++; head=head->next; } for(int i=0;i<len/2;i++){ for(int j=i+1;j<len;j++){ temp = Start->next; Start->next = temp->next; temp->next = preStart->next; preStart->next = temp; } preStart = Start; Start = Start->next; } return dummy->next; */ if(head == NULL || head->next == NULL || k < 2) return head; ListNode *dummy = new ListNode(-1); dummy->next = head; ListNode *pre = dummy, *cur = head, *temp; int len = 0; //计算链表的长度 while (head != NULL) { len ++ ; head = head->next; } for (int i = 0; i < len / k; i ++ ) { for (int j = 1; j < k; j ++ ) { temp = cur->next; cur->next = temp->next; temp->next = pre->next; pre->next = temp; } pre = cur; cur = cur->next; } return dummy->next; } };
13、给定链表,交换每两个相邻节点并返回其头部。
例如,
给定1-> 2-> 3-> 4,您应该返回列表as2-> 1-> 4-> 3。
您的算法应该只使用恒定空间。 您可能无法修改列表中的值,只能更改节点本身。
/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */ class Solution { public: ListNode *swapPairs(ListNode *head) { if(head==NULL || head->next==NULL ) return head; ListNode *dummy = new ListNode(-1); dummy->next = head; ListNode *Start = head; ListNode *aftStart = head->next; ListNode *preStart = dummy; ListNode *temp; while(Start!=NULL && aftStart!=NULL){ temp = aftStart->next; Start->next = temp; aftStart->next = Start; preStart->next = aftStart; preStart = Start; Start = temp; aftStart = temp->next; } return dummy->next; } };
14、给定链表,从列表末尾删除第n个节点并返回其头部。
例如,
给定链表:1-> 2-> 3-> 4-> 5,n = 2。
从末尾删除第二个节点后,链表变为1-> 2-> 3-> 5。
注意:
给定n将始终有效。
尝试一次性完成此操作。
/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */ class Solution { public: ListNode *removeNthFromEnd(ListNode *head, int n) { if(head==NULL ) return head; ListNode *dummy = new ListNode(0); dummy->next = head; head = dummy; ListNode *slow = head; ListNode *fast = head; for(int i=0;i<n;i++){ fast = fast->next; } while(fast->next!=NULL){ fast = fast->next; slow = slow->next; } ListNode *temp = slow->next; slow->next = slow->next->next; delete temp; return dummy->next; } };