链表反转

链表翻转。给出一个链表和一个数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→6→5，用程序实现。

思路是网上搜的最多的那种，从链表中提取K个元素，反转后再接入链表。但是发现网上的代码不能处理题目中最后一种情况即最后还有元素但不足K个，这里做了补充。

 pNextNode = reversenode(pNextNode);
     pLastNode->next = pNextNode;

pNextNode 是上一次反转完成后的最后一个元素的下一个元素，也就是下一次反转的第一个元素，pLastNode是上一次反转后的最后一个元素。将前者后面的链表（元素不足K）反转后再将接入之前的链表。  下面是反转链表的C语言代码，根据网上代码修改的。创建链表时以-1结束输入。

#include <stdio.h>
#include <stdlib.h>
typedef struct Node
{
    int data;
    struct Node *next;
}lnode;
//不带头节点
lnode * reversenode(lnode *head)
{
    if(head == NULL)
        return head;
    lnode *pnode;
    lnode *cur = NULL;
    while(head)
    {
        pnode = head;
        head = head->next;
        pnode->next = cur;
        cur = pnode;
    }
    return cur;
}
lnode * createnode()
{
    lnode *head = (lnode*)malloc(sizeof(lnode));
    head = NULL;
    lnode *cur = NULL;
    lnode *pre = (lnode*)malloc(sizeof(lnode));
    int num;
    while(1)
    {
        printf("input a number:");
        scanf("%d",&num);
        printf("\n");
        if(num == -1)
            break;
        cur = (lnode*)malloc(sizeof(lnode));
        cur->data = num;

        if(head == NULL)
            head = cur;

        pre->next = cur;//
        pre = cur;
    }
    cur->next = NULL;
    return head;
}
lnode* getLastNode(lnode* pHead) {
  while (NULL != pHead->next)
    pHead = pHead->next;
  return pHead;
}
lnode *reverseallnode(lnode *pHead,int k)
{
    if (k <= 1)
        return pHead;
    int pos;
    lnode* pNode = pHead;
    lnode* pNewHead;
    lnode* pNextNode;
    lnode* pLastNode = NULL;;
    pHead = NULL;
    while (pNode)
    {
        pos = 0;
        pNewHead = pNode;
        while (pNode && pos < k - 1)
        {
          pNode = pNode->next;
          pos++;
        }
        if (pNode)
        {
          pNextNode = pNode->next;
          pNode->next = NULL;
         /* if (NULL != pLastNode) {
            pLastNode->next = NULL;
          }*/
          pNewHead = reversenode(pNewHead);
          if (NULL == pHead)
          {
            pHead = pNewHead;
          } else
          {
            pLastNode->next = pNewHead;
          }
          pNode = getLastNode(pNewHead);
          pNode->next = pNextNode;
          pLastNode = pNode;
          pNode = pNextNode;
        } else
        {
          break;
        }
      }//对不满K个的节点进行反转
     pNextNode = reversenode(pNextNode);
     pLastNode->next = pNextNode;
     return pHead;
}

int main()
{
    lnode *createnode();
    lnode *reverseallnode(lnode*,int n);
    lnode *head = (lnode*)malloc(sizeof(lnode));
    head = createnode();
    head = reverseallnode(head,3);
    while(head)
    {
        printf("%d ",head->data);
        head = head->next;
    }
    return 0;
}