ListNode *reverseKGroup(ListNode *head, int k) {
ListNode *tail = head;
ListNode *first, *temp;
if (k <= 1) {
return head;
}
for (int i = 0; i < k; ++i) {
if (tail == NULL) {
return head;
}
tail = tail->next;
}
tail = reverseKGroup(tail, k);
first = head;
for (int i = 0; i < k - 1; ++i) {
temp = first->next;
first->next = temp->next;
temp->next = head;
head = temp;
}
first->next = tail;
return head;
}
int main() {
int n = 5;
int k = 3;
struct ListNode *head = createNode(1);
struct ListNode *p = head;
int i;
for (i = 2; i <= n; i++) {
p->next = createNode(i);
p = p->next;
}
p = head;
while (p) {
printf("%d->", p->val);
p = p->next;
}
printf("NIL\n");
struct ListNode *new_head = reverseKGroup(head, k);
p = new_head;
while (p) {
printf("%d->", p->val);
p = p->next;
}
printf("NIL\n");
return 0;
}
ListNode *reverseKGroup(ListNode *head, int k) {
if( !head )
return NULL;
if( head->next==NULL || k==1)
return head;
int count = 0;
ListNode *pre,*tmp,*post;
tmp = head;
while( tmp )
{
if(++count == k)
break;
tmp = tmp->next;
}
if(count < k)
return head;
vector<ListNode *> v;
tmp = head;
for(int i=0;i<k;i++)
{
v.push_back(tmp);
tmp = tmp->next;
}
post = tmp;
head = v.back();
pre = head;
for(int i=k-2;i>=0;--i)
{
tmp = v[i];
pre->next = tmp;
pre = pre->next;
}
pre->next = reverseKGroup(post,k);
return head;
}
ListNode *reverseKGroup(ListNode *head, int k) {
if (head == nullptr || head->next == nullptr || k < 2)
return head;
ListNode *next_group = head;
//如果剩余的节点个数不足k个，则返回head
for (int i = 0; i < k; ++i) {
if (next_group)
next_group = next_group->next;
else
return head;
}
// next_group is the head of next group
// new_next_group is the new head of next group after reversion
ListNode *new_next_group = reverseKGroup(next_group, k);
ListNode *prev = NULL, *cur = head;
while (cur != next_group) {
ListNode *next = cur->next;
//第一个节点后继指向new_next_group，后面每个节点后继指向前一个节点
cur->next = prev ? prev : new_next_group;
//prev和cur向后移动一个元素
prev = cur;
cur = next;
}
return prev; // prev will be the new head of this group
}
ListNode *reverseKGroup(ListNode *head, int k)
{
if (head == nullptr || head->next == nullptr || k < 2)
return head;
ListNode *next_group = head;
for (int i = 0; i < k; ++i)
{
if (next_group)
next_group = next_group->next;
else
return head;
}
// next_group is the head of next group
// new_next_group is the new head of next group after reversion
ListNode *new_next_group = reverseKGroup(next_group, k);
ListNode *prev = NULL, *cur = head;
while (cur != next_group)
{
ListNode *next = cur->next;
cur->next = prev ? prev : new_next_group;
prev = cur;
cur = next;
}
return prev; // prev will be the new head of this group
}
/*
For example,
Given this linked list: 1->2->3->4->5
For k = 2, you should return: 2->1->4->3->5
For k = 3, you should return: 3->2->1->4->5
*/
ListNode *reverseKGroup(ListNode *head, int k) {
if(!head) return NULL;
ListNode* cur = head;
int i = 0;
while(cur)
{
i++;
if(i>=k) break;
cur = cur->next;
}
if(i<k)
return head;
ListNode* pre = NULL;
ListNode* next;
cur = head;
i = k;
while(cur && i>0)
{
next = cur->next;
cur->next = pre;
pre = cur;
cur = next;
i--;
}
head->next = reverseKGroup(cur, k);
//pre is the return
return pre;
}
ListNode* reverseKGroup(ListNode* head, int k) {
if(head == NULL || k<=1) {
return head;
}
ListNode* cur = head, *pre=head, *next;
int m=1;
while(m < k && cur) {
m++;
cur = cur->next;
}
if(cur) {
next = cur->next;
cur->next = NULL;
pre = reverseNode(head);
ListNode *tail = pre;
while(tail->next) {
tail = tail->next;
}
tail->next = reverseKGroup(next, k);
}
return pre;
}
ListNode *reverseKGroup(ListNode *head, int k) {
//递归解法
if (head == nullptr || k == 1){
return head;
}
int len = 0;
ListNode *count = head;
while(count != nullptr){
count = count -> next;
len ++;
}
//当不足k个的时候，不逆转直接返回
if (len < k){
return head;
}
ListNode *cur = head -> next;
ListNode *next = head;
//逆转k个
for (int i = 0; i < k - 1; i ++){
ListNode *post = cur -> next;
cur -> next = next;
next = cur;
cur = post;
}
//将k个后面的数传递过去继续逆转
head -> next = reverseKGroup(cur, k);
return next;
}
ListNode* reverseKGroup(ListNode* head, int k) {
ListNode* p1 = head;
ListNode* current = head;
ListNode* nxt = NULL;
ListNode* prev = NULL;
int i = 0;
while(p1){
p1=p1->next;
i++;
}
int n = i/k;
if(n==0)
return head;
if(head == NULL)
return head;
int count = 0;
while(current && count<k){
nxt = current->next;
current->next = prev;
prev = current;
current = nxt;
count++;
}
if(nxt!=NULL)
head->next = reverseKGroup(nxt,k);
return prev;
}
int main(int argc, char const *argv[])
{
List L1;
L1 = CreateEvenList(3);
PrintList(L1);
L1 = reverseKGroup(L1, 2);
PrintList(L1);
return 0;
}
ListNode *reverseKGroup(ListNode *head, int k) {
if(!head || k<=1) return head;
ListNode *cur = head;
int cnt = k;
while(--cnt && cur->next) cur = cur->next;
if(cnt>0) return head;
ListNode *tmp = reverseKGroup(cur->next, k);
cur->next = NULL;
ListNode *newh = reverse(head);
head->next = tmp;
return newh;
}
ListNode* reverseKGroup(ListNode* head, int k) {
auto node = head;
// it's confusing until finding out the
// trick that putting "!node" before "update node"
for (int i=0; i < k; ++i) {
if (!node) return head; // do nothing as list is too sort
node = node->next;
}
auto new_head = reverse(head, node);
head->next = reverseKGroup(node, k);
return new_head;
}
ListNode *reverseKGroup(ListNode *head, int k) {
if(head == NULL || k==1){
return head;
}
auto node = head;
for(int i=0;i<k;++i){
if(!node) return head;
node = node->next;
}
//递归实现
auto new_head = ReverseList(head, node);
head->next = reverseKGroup(node, k);
return new_head;
}
int main()
{
int set[] = {0, 1, 2, 3, 4, 5, 6};
struct ListNode *res = NULL;
int k;
for(k = 2; k <= 7; k++)
{
struct ListNode *list1 = initlist(set, sizeof(set)/sizeof(int));
res = reverseKGroup(list1, k);
printlist(res);
}
}
ListNode* reverseKGroup(ListNode* head, int k) {
ListNode* pointers[k];
for(int i=0; i<k; i++){
pointers[i] = head;
if(!head) return pointers[0];
head = head->next;
}
// reverse
for(int i=k-1; i>0; i--){
pointers[i]->next = pointers[i-1];
}
pointers[0]->next = reverseKGroup(head, k);
return pointers[k-1];
}
/* recursive:
* C ---> B ---> A ---> D ---> E
* | | |
* head end cur
*/
ListNode* reverseKGroup(ListNode* head, int k) {
if (k <= 1) return head;
ListNode *cur = head, *end = head;
for(int i=0; i<k; i++) {
if(!cur) return head;
cur = cur->next;
}
cur = head;
for(int i=0; i<k-1; i++) {
cur = end->next;
end->next = cur->next;
cur->next = head;
head = cur;
}
end->next = reverseKGroup(end->next, k);
return head;
}
ListNode* reverseKGroup(ListNode* head, int k) {
ListNode *cur = head;
for (int i=0; i<k; i++) {
if (cur == NULL) return head;
cur = cur->next;
}
ListNode *ret = reverseKGroup(cur, k);
ListNode *tmp = head;
for (int i=0; i<k; i++) {
cur = tmp;
tmp = tmp->next;
cur->next = ret;
ret = cur;
}
return ret;
}
ListNode *reverseKGroup(ListNode *head, int k) {
if (head == nullptr || head->next == nullptr || k < 2)
return head;
ListNode *next_group = head;
for (int i = 0; i < k; ++i) {
if (next_group)
next_group = next_group->next;
else
return head;
}
ListNode *new_next_group = reverseKGroup(next_group, k);
ListNode *prev = NULL, *cur = head;
while (cur != next_group) {
ListNode *next = cur->next;
cur->next = prev ? prev : new_next_group;
prev = cur;
cur = next;
}
return prev;
}
/**
* @param head a ListNode
* @param k an integer
* @return a ListNode
*/
ListNode *reverseKGroup(ListNode *head, int k) {
// Write your code here
if (k == 1)
return head;
if (head == nullptr)
return nullptr;
ListNode *next;
ListNode *new_head = nullptr;
ListNode *new_tail = nullptr;
int len = 0;
ListNode *temp = head;
while (temp) {
len ++;
temp = temp->next;
if (len == k) {
break;
}
}
if (len < k)
return head;
int count = k;
while (head && count-- > 0) {
next = head->next;
head->next = nullptr;
if (new_head == nullptr) {
new_head = head;
new_tail = head;
}
else {
head->next = new_head;
new_head = head;
}
head = next;
}
ListNode *next_step_head = reverseKGroup(head, k);
new_tail->next = next_step_head;
return new_head;
}
struct ListNode* reverseKGroup(struct ListNode* head, int k) {
if(k == 1)
return head;
struct ListNode *pre = NULL, *cur = head, *head_temp = head;
for(int i = k; i > 0; --i) {
if(cur) {
pre = cur;
cur = cur -> next;
}
else
return head; // 剩余结点个数不足K个时，不需要进行反转，直接返回即可
}
if(cur == NULL) // 只有k个结点
return reverseList(head);
else { // 结点数大于k
pre -> next = NULL; // 执行此步是为了执行下一步的reverseList()
head = reverseList(head);
head_temp -> next = reverseKGroup(cur, k); // 递归进行余下操作
}
return head;
}
ListNode* reverseKGroup(ListNode* head, int k) {
if (head == NULL) return NULL;
ListNode* cur = head;
stack<ListNode*> st;
for (int i = 1; i <= k && cur; i++){
st.push(cur);
cur = cur->next;
if (i < k && cur == NULL) return head;
}
ListNode* current = head = st.top();
st.pop();
while(!st.empty()){
current->next = st.top();
st.pop();
current = current->next;
}
current->next = reverseKGroup(cur, k);
return head;
}
// -----------------------------------------------------------------------------
//virtual
bool Solution::Test()
{
bool pass = true;
{
int a[] = {};
ListNode * list = ll_create(a, sizeof(a) / sizeof(int));
ListNode * list_reversed = reverseKGroup(list, 0);
std::vector<int> v = ll_transform(list_reversed);
pass = pass && (v.empty());
}
{
int a[] = {};
ListNode * list = ll_create(a, sizeof(a) / sizeof(int));
ListNode * list_reversed = reverseKGroup(list, 1);
std::vector<int> v = ll_transform(list_reversed);
pass = pass && (v.empty());
}
{
int a[] = {};
ListNode * list = ll_create(a, sizeof(a) / sizeof(int));
ListNode * list_reversed = reverseKGroup(list, 3);
std::vector<int> v = ll_transform(list_reversed);
pass = pass && (v.empty());
}
{
int a[] = { 1 };
ListNode * list = ll_create(a, sizeof(a) / sizeof(int));
ListNode * list_reversed = reverseKGroup(list, 0);
std::vector<int> v = ll_transform(list_reversed);
pass = pass && (v.size() == 1) && (v[0] == 1);
}
{
int a[] = { 1 };
ListNode * list = ll_create(a, sizeof(a) / sizeof(int));
ListNode * list_reversed = reverseKGroup(list, 1);
std::vector<int> v = ll_transform(list_reversed);
pass = pass && (v[0] == 1);
}
{
int a[] = { 1 };
ListNode * list = ll_create(a, sizeof(a) / sizeof(int));
ListNode * list_reversed = reverseKGroup(list, 3);
std::vector<int> v = ll_transform(list_reversed);
pass = pass && (v.size() == 1) && (v[0] == 1);
}
{
int a[] = { 1 };
ListNode * list = ll_create(a, sizeof(a) / sizeof(int));
ListNode * list_reversed = reverseKGroup(list, 1);
std::vector<int> v = ll_transform(list_reversed);
pass = pass && (v.size() == 1) && (v[0] == 1);
}
{
int a[] = { 1, 2 };
ListNode * list = ll_create(a, sizeof(a) / sizeof(int));
ListNode * list_reversed = reverseKGroup(list, 0);
std::vector<int> v = ll_transform(list_reversed);
pass = pass && (v.size() == 2) && (v[0] == 1) && (v[1] == 2);
}
{
int a[] = { 1, 2 };
ListNode * list = ll_create(a, sizeof(a) / sizeof(int));
ListNode * list_reversed = reverseKGroup(list, 1);
std::vector<int> v = ll_transform(list_reversed);
pass = pass && (v.size() == 2) && (v[0] == 1) && (v[1] == 2);
}
{
int a[] = { 1, 2 };
ListNode * list = ll_create(a, sizeof(a) / sizeof(int));
ListNode * list_reversed = reverseKGroup(list, 2);
std::vector<int> v = ll_transform(list_reversed);
pass = pass && (v.size() == 2) && (v[0] == 2) && (v[1] == 1);
}
{
int a[] = { 1, 2 };
ListNode * list = ll_create(a, sizeof(a) / sizeof(int));
ListNode * list_reversed = reverseKGroup(list, 3);
std::vector<int> v = ll_transform(list_reversed);
pass = pass && (v.size() == 2) && (v[0] == 1) && (v[1] == 2);
}
{
int a[] = { 1, 2, 3, 4, 5, 6, 7, 8 };
ListNode * list = ll_create(a, sizeof(a) / sizeof(int));
ListNode * list_reversed = reverseKGroup(list, 3);
std::vector<int> v = ll_transform(list_reversed);
pass = pass && (v.size() == 8) &&
(v[0] == 3) && (v[1] == 2) && (v[2] == 1) &&
(v[3] == 6) && (v[4] == 5) && (v[5] == 4) &&
(v[6] == 7) && (v[7] == 8);
}
{
int a[] = { 1, 2, 3, 4, 5, 6, 7, 8 };
ListNode * list = ll_create(a, sizeof(a) / sizeof(int));
ListNode * list_reversed = reverseKGroup(list, 4);
std::vector<int> v = ll_transform(list_reversed);
pass = pass && (v.size() == 8) &&
(v[0] == 4) && (v[1] == 3) && (v[2] == 2) && (v[3] == 1) &&
(v[4] == 8) && (v[5] == 7) && (v[6] == 6) && (v[7] == 5);
}
return pass;
}
ListNode *swapPairs(ListNode *head) {
// Start typing your C/C++ solution below
// DO NOT write int main() function
return reverseKGroup(head,2);
}
