C语言链表左旋转功能修复：支持超过链表长度的循环旋转需求

问题说明 #

现有代码仅支持k小于等于链表长度的左旋转操作，无法处理k大于链表总长度的循环旋转需求，需要做两处核心修改即可实现对应能力。

具体修改点 #

• 移除main函数中k必须小于等于链表长度的判断限制，所有正整数k都可传入旋转函数处理
• 重构RotateALinkedList函数，增加链表长度计算、k值取模的逻辑，消除无效旋转实现循环能力

修改后完整代码 #

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

typedef struct numbers_list
{
    int data;
    struct numbers_list* next;
}number;

void RotateALinkedList(number** head, int node); //the function that rotate the linked list
int CreateLinkedList(number** head, int iNumberofNode);
int attachToEnd(number** head, int k);
void PrintTheList(number* pNode);
void FreeAllocatedMemory(number** head);

int main(void)
{
    int list_len = 0;
    int data = 0;
    number* head = NULL;
    printf("How many nodes in list? ");
    scanf("%d", &list_len);
    getchar();
    CreateLinkedList(&head, list_len);
    printf("Choose a number k, and the list will be rotated k places to the left: ");
    scanf("%d", &data);
    getchar();
    // 移除原有长度校验，所有合法k都传入函数处理
    RotateALinkedList(&head, data);
    PrintTheList(head);
    FreeAllocatedMemory(&head);
    getchar();
    return 0;
}

void RotateALinkedList(number** head, int node)
{
    // 异常场景直接返回
    if (*head == NULL || node <= 0) {
        return;
    }
    // 计算链表总长度
    int len = 0;
    number* p = *head;
    while (p != NULL) {
        len++;
        p = p->next;
    }
    // 取模得到实际需要旋转的步数，消除循环无效旋转
    int k = node % len;
    if (k == 0) {
        // 取模为0说明旋转后和原链表一致，无需操作
        return;
    }
    // 原有旋转逻辑
    p = *head;
    number* tempNode = NULL;
    for (int count = 1; (count < k) && (p != NULL); count++)
    {
        p = p->next;
    }
    tempNode = p;
    while (p->next != NULL)
    {
        p = p->next;
    }
    p->next = *head;
    *head = tempNode->next;
    tempNode->next = NULL;
}

int CreateLinkedList(number** head, int iNumberofNode)
{
    int data = 0;
    int iRetValue = -1;
    int count = 0;
    number* pNewNode = NULL;
    for (count = 0; count < iNumberofNode; count++)
    {
        printf("Enter number: ");
        scanf("%d", &data);
        getchar();
        if ((*head) == NULL)
        {
            pNewNode = (number*)malloc(sizeof(number));
            if (pNewNode != NULL)
            {
                pNewNode->data = data;
                pNewNode->next = NULL;
                *head = pNewNode;
                iRetValue = 0;
            }
        }
        else
        {
            iRetValue = attachToEnd(head, data);
        }
    }
    return iRetValue;
}

int attachToEnd(number** head, int k)
{
    int iRetValue = -1;
    number* pLastNode = NULL;
    number* pNewNode = NULL;
    pLastNode = *head;
    pNewNode = (number*)malloc(sizeof(number));
    if (pNewNode != NULL)
    {
        pNewNode->data = k;
        pNewNode->next = NULL;
        iRetValue = 0;
    }
    if (pLastNode == NULL)
    {
        *head = pNewNode;
    }
    else
    {
        while (pLastNode->next != NULL)
        {
            pLastNode = pLastNode->next;
        }
        pLastNode->next = pNewNode;
    }
    return iRetValue;
}

void PrintTheList(number* pNode)
{
    printf("the rotated list:\n");
    while (pNode != NULL)
    {
        printf("%d  ", pNode->data);
        pNode = pNode->next;
    }
}

void FreeAllocatedMemory(number** head)
{
    number* ptempNode = NULL;
    number* pFirstNode = NULL;
    pFirstNode = *head;
    while (pFirstNode != NULL)
    {
        ptempNode = pFirstNode;
        pFirstNode = pFirstNode->next;
        free(ptempNode);
    }
    *head = NULL;
}

效果验证 #

假设链表长度为3，输入k=4时，程序会自动计算4%3=1，实际执行左移1位操作，符合循环旋转的需求；如果输入k=3，取模后为0，链表保持原有顺序不做无效旋转。

内容的提问来源于stack exchange，提问作者roee attias