02-线性结构1. Reversing Linked List (25)

02-线性结构1. Reversing Linked List (25)

Given a constant K and a singly linked list L, you are supposed to reverse the links of every K elements on L. For example, given L being 1→2→3→4→5→6, if K = 3, then you must output 3→2→1→6→5→4; if K = 4, you must output 4→3→2→1→5→6.

Input Specification:

Each input file contains one test case. For each case, the first line contains the address of the first node, a positive N (<= 105) which is the total number of nodes, and a positive K (<=N) which is the length of the sublist to be reversed. The address of a node is a 5-digit nonnegative integer, and NULL is represented by -1.

Then N lines follow, each describes a node in the format:

Address Data Next

where Address is the position of the node, Data is an integer, and Next is the position of the next node.

Output Specification:

For each case, output the resulting ordered linked list. Each node occupies a line, and is printed in the same format as in the input.

Sample Input:
00100 6 4
00000 4 99999
00100 1 12309
68237 6 -1
33218 3 00000
99999 5 68237
12309 2 33218

Sample Output:
00000 4 33218
33218 3 12309
12309 2 00100
00100 1 99999
99999 5 68237
68237 6 -1

#include <stdio.h>
#include <stdlib.h>
#define MAX_SIZE 100004

typedef struct tagLNode
{
    int addr;      
    int data;      
    int nextAddr;  
    struct tagLNode *next;  
} LNode;

LNode *listReverse(LNode *head, int k);
void printList(LNode *a);

int main()
{
    int firstAddr;
    int n = 0;            
    int k = 0;           
    int num = 0;          
    int data[MAX_SIZE];   
    int next[MAX_SIZE];   
    int tmp;     
    int i, j;         
    LNode *a;
    scanf("%d %d %d", &firstAddr, &n, &k);    
    a= malloc(sizeof(LNode)* (n + 1));
    a[0].nextAddr = firstAddr;   

    for (i = 1; i < n+1; i++)
    {
        scanf("%d", &tmp);
        scanf("%d %d", &data[tmp], &next[tmp]);        
    }
    i = 1;
    while (1)
    {
        if (a[i-1].nextAddr == -1)
        {
            a[i-1].next = NULL;
            num = i-1;
            break;            
        }
        a[i].addr = a[i-1].nextAddr;
        a[i].data = data[a[i].addr]; 
        a[i].nextAddr = next[a[i].addr];
        a[i-1].next = a+i;

        i++;
    }

    LNode *p = a;                    
    LNode *rp = NULL;                
    if (k <= num )
    {  
        for (i = 0; i < (num/k); i++)
        {   
            rp = listReverse(p, k);  
            p->next = rp;            
            p->nextAddr = rp->addr;            
            j = 0;         
            while (j < k)
            {
                p = p->next;
                j++;
            }
        }
    }

    printList(a);
    free(a);
    a = NULL;
    return 0;   
}

void printList(LNode *a)
{
    LNode *p = a;

    while (p->next != NULL)
    {
        p = p->next;        
        if (p->nextAddr != -1 )
        {       
            printf("%.5d %d %.5d\n", p->addr, p->data, p->nextAddr);
        }
        else
        {           
            printf("%.5d %d %d\n", p->addr, p->data, p->nextAddr);
        }    
    }
}

LNode *listReverse(LNode *head, int k)
{
    int count = 1;
    LNode *new = head->next;
    LNode *old = new->next;
    LNode *tmp = NULL;

    while (count < k)
    {
        tmp = old->next;
        old->next = new;
        old->nextAddr = new->addr;
        new = old;  
        old = tmp;  
        count++;
    }

    head->next->next = old;  
    if (old != NULL)
    { 
        head->next->nextAddr = old->addr; 
    }
    else
    {    
        head->next->nextAddr = -1;       
    }
    return new;
}