数据结构与算法

//头插法逆置（带头节结点）    
void reverse(linklist &L) {
    lnode *p = L->next, *pre;
    L->next = NULL;
    while (p) {
        pre = p->next;
        p->next = L->next;
        L->next = p;
        p = pre;
    }
}

//指针反指法逆置（带头结点）
void reverse(linklist &L) {
    lnode* pre=NULL;
    lnode* cur=L->next;
    lnode* next=NULL;
    while(cur!=NULL)
    {
        next=cur->next;
        cur->next=pre;
        pre=cur;
        cur=next;
    }
    L->next = pre;
}

//每k组逆置（带头结点）
lnode *reverseFromTo(lnode *L, lnode *end) {
    lnode *pre = NULL;
    lnode *cur = L;
    lnode *next = NULL;
    while (cur != end) {
        next = cur->next;
        cur->next = pre;
        pre = cur;
        cur = next;
    }
    return pre;
}
lnode *reverseByGroup(lnode *L, int k, int length) {
  	//注意这里k!=0
  	if(k == 1)
        return L;
  	//当每组长度大于链表总长度时，直接整体逆置
    if (k > length) {
        L->next = reverseFromTo(L->next, NULL);
        return L;
    }
    lnode *start = L->next; //每组逆置的开始结点
    lnode *end = L->next;	//每组逆置的结束接结点
    lnode *rear;	//每组逆置后的尾结点
  	int count = 1;
    int flag = 1;	//标记首组逆置，链接头结点
    for (int i = 0; i < (length + 1) / k; i++) {
      	//遍历找到每组逆置的结束结点
        while (count++ != k + 1) {
            if (end == NULL) break;
            end = end->next;
        }
      	//首组逆置
        if (flag == 1) {
            L->next = reverseFromTo(start, end); //链接头结点
            rear = start; //记录尾结点
            rear->next = end; //链接剩余结点
            flag = 0;
        } else {
            rear->next = reverseFromTo(start, end);	//链接到上一组逆置后的尾结点
            rear = start;	//更新尾结点
            rear->next = end;	//链接剩余结点
        }
        start = end;	//更新逆置开始结点
        count = 1;
        //if (start == NULL)
            //return L;
    }
    return L;
}