数据结构课后习题：Reversing Linked List

题目描述：

 题目解读：

1、需要每K步进行反转，剩下少于K的子表不反转

2、需要考虑输入数据有非法值，即有些节点不在链表中

思路：

1、用地址addr作为key存储链表节点，C语言由于没有哈希表，直接用addr作为数组的下标。

2、完成链表节点的存储后，需要找出链表的头节点，这里需要用next值作为key，存储本节点是否是其他节点的下一个节点：具体为，如果通过next能找到合法的链表节点，则这个合法的链表节点就不可能是头结点，循环给每一个节点打上标记

3、为了处理有些节点不在链表的场景，需要对找出的头结点进行合法性校验：遍历该头结所连接的链表，查看是否能找到结尾。若能最后找到next为-1的节点，则证明找到了正确的头结点。

4、在进行k步反转时，需要重新计算链表的长度，用新计算的链表长度 / K 得到需要反转的次数

5、逆序输出采用堆栈实现

下面是自己的代码实现：

#include <stdio.h>
#include <string.h>

#define NULL -1
#define MAX_SIZE 100001
typedef struct T_node * list;
typedef struct T_node
{
    int addr;
    int data;
    int next; 
    int valid;
}node_t;

int nextaddr[MAX_SIZE]; /* 存储下一个链表地址的空间 */
node_t nodeBuf[MAX_SIZE] = {0}; /* 存储链表节点的空间 */
//简易堆栈
int top = -1;
list stack[MAX_SIZE];
#define pop(top)   ((top > -1) ? stack[top--] : 0)
#define push(x, top)   (top != MAX_SIZE-1) ? stack[++top] = (x) : 0
#define isempty(top)  ((top == -1) ? 1 : 0)
#define gettop(top)   (isempty(top) != 1 ? stack[top] : 0)
#define getnext(next) (next!=NULL ? &nodeBuf[(next)] :(list) 0)
/*===============================================================*/

list reverse_link(list L, int k, int revercnt)
{   
    list ret = 0;
    list Rear = 0;
    int j = 0;
    for (j = 0; j < revercnt; j++)
    {
        int i = 0;
        /* 倒序的内容入栈 */
        while (L != 0 && i < k)
        {
            push(L, top);
            L = getnext(L->next);
            i++;
        }
        /* 第一次逆序，堆栈的第一个节点为头结点 */
        if (!isempty(top))
        {
            if (ret == 0)
                ret = gettop(top);
            else
                Rear->next = gettop(top)->addr; /* 记录上一次逆序后的尾部节点 */
        }
        /* 弹出节点，然后将该节点的下一个节点地址设置为堆栈的头结点 */
        while (!isempty(top))
        {
            list n = pop(top);
            if (isempty(top))
            {
                if (L)
                    n->next = L->addr;
                else
                    n->next = NULL;
                Rear = n;
            }
            else
            {
                list topnode = gettop(top);
                n->next = topnode->addr;
            }
        
        }
    }
    return ret;
}

void printL(list L)
{
    while (L)
    {
        if (L->next == NULL)
        {
            printf("%05d %d %d", L->addr, L->data, L->next);
            break;
        }
        else
            printf("%05d %d %05d
", L->addr, L->data, L->next);
        L = &nodeBuf[L->next];
    }
}

int main(void)
{
    
    int addr, num, k, i = 0;
    list first = 0;
    scanf("%d %d %d",&addr, &num, &k);
    while (i < num)
    {
        node_t n = {0};
        n.next = NULL;
        scanf("%d %d %d", &n.addr, &n.data, &n.next);
        n.valid = 1;
        nodeBuf[n.addr] = n;
        if (n.next != NULL)
            nextaddr[n.next] = 1;
        else
        {
            nextaddr[n.addr] = 1;
            first = &nodeBuf[n.addr];
        } 
        i++;
    }
    i = 0;
    /* 找到链表的头结点  */
    while (i < MAX_SIZE)
    {
        if (nodeBuf[i].valid && nextaddr[nodeBuf[i].addr] == 0)
        {
            list temp = &nodeBuf[i];
            first = &nodeBuf[i];
            num = 0;
            while (temp && temp->valid)
            {
                num++;
                temp = getnext(temp->next);
            }/* 这里为了解决不在链表上的节点，所以要重新计算链表的节点数目  */
            if (!temp)
                break;
            else
                num = 0;/* 这里找到的不是第一个节点 */
        }
        i++;
    }
    list L = reverse_link(first, k, num/k);
    printL(L);
    return 0;
}

有什么更好的方式能找到正确的链表头结点呢？