每K个元素翻转一次链表，若最后剩余元素不足K个，不进行翻转(美团2014校招试题)

给定一个单链表和一个整数k，要求每隔k个元素翻转链表一次

struct node{

   int key;
   struct node* next;

};

typedef node* List;

实现函数：List kReverse(List  head，int k)

比如：

原始链表为：1—>2—>3—>4—>5—>6

k=2 翻转为：2—>1—>4—>3—>6—>5

k=3 翻转为：3—>2—>1—>6—>5—>4

k=4 翻转为：4—>3—>2—>1—>5—>6

#include <stdio.h>
#include <stdlib.h>

typedef struct node
{
    int data;
    struct node* next;
}node, *List;


List kReverse(List head,int k)
{	
    List oldHead = NULL;
	List newHead = NULL;//链表翻转完之后的第一个节点
    List previousGroupTail = NULL;
	
	int n = 0;
	int num = 0;
	int count = 1;
	int reverseNum;
    //链表为空或链表中只有一个元素，则不需要翻转
    if (head == NULL || head->next == NULL)
	    return head;
	
    oldHead = head;
     //链表长度
	while (head != NULL) 
	{
	  head = head->next;
	  n++;
	}
	
	reverseNum = n / k;//需要翻转的链表的个数 
		
	newHead = head = oldhead;
		
	while (head != NULL && num < reverseNum) 
    {
		List groupTail = head;//groupTail记录分组内的头结点，即为翻转后分组内的尾节点
		List prev = NULL;
		List next = NULL;
		int i;
		//翻转具有k个元素的链表分组，每循环一次后，pre指向翻转前分组内最后一个节点，head指向下一个分组的第一个节点
		for (i = 1; i <= k && head != NULL; i++) 
		{
		      next = head->next;
		      head->next = prev;
			  prev = head;
		      head = next;
		}
            //newHead指向第一个分组翻转之后的第一个节点			
	    if (count == 1) 
		{
	        newHead = prev;
	        count++;
         } 		
	    if(previousGroupTail != NULL) 
        {
	       previousGroupTail->next = prev;
        }
	    previousGroupTail = groupTail;
		num++;
	}
	//处理最后的不组K个的元素节点，此时head指向剩下的元素的第一个节点	
	if (head != NULL)
	{ 
	    if (previousGroupTail != NULL)
		{ 
	       previousGroupTail->next = head;
        } 
    } 
    return newHead;
}


void push(List* head_ref, int new_data)
{
    List new_node = (List) malloc(sizeof(node));         
    new_node->data  = new_data;
    new_node->next = (*head_ref);    
    (*head_ref) = new_node;
}


int main()
{
     List head = NULL;
	 List head1 = NULL;

     push(&head, 8);
     push(&head, 7);
     push(&head, 6);
     push(&head, 5);
     push(&head, 4);
     push(&head, 3);
     push(&head, 2);
     push(&head, 1);
		

	 head1 = kReverse(head, 3);
	 
	 printf("翻转后：");
	 while (head1 != NULL) 
	 {
	    printf("%d ",head1->data);
		head1 = head1->next;
	 }

     printf("\n");
		
	return 0;	
}

方法2：

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
}