数据结构 PAT 02-线性结构2 Reversing Linked List 单链表实现

02-线性结构2 Reversing Linked List

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 (≤10​5​​)
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

自己用了一种好蠢的方法，再加上又是C语言，真的好蠢；其实可以用静态链表，明天更新

#include <stdio.h>
#include <stdlib.h>
struct Node
{
int address;
unsigned data; // 整数<=105
int nextAddress; // 下个结点的五位数地址
struct Node *next; // 连接下个结点的指针
};
typedef struct Node LNode;
typedef LNode *List;

List listCreate()
{
List l, rear, tempPtr; // 创建链表指针
int firstNodeAddress, N, K;
int i, address, data, nextAddress;

scanf("%d %d %d", &firstNodeAddress, &N, &K);
/* 创建一个头结点，存放链表信息 */
l = (List)malloc(sizeof(LNode));
l->address = N; // 输入结点的总个数
l->data = K; // 反向子列的长度
l->nextAddress = firstNodeAddress; // 第一个结点的数字地址
l->next = NULL;
rear = l;

/* 依输入顺序用尾插法，插入各结点 */
for (i = 0; i < N; i ++)
{
scanf("%d %d %d", &address, &data, &nextAddress);
tempPtr = (List)malloc(sizeof(LNode));
tempPtr->address = address;
tempPtr->data = data;
tempPtr->nextAddress = nextAddress;
tempPtr->next = NULL;
rear->next = tempPtr;
rear = tempPtr;
}
return l;
}

List listSort(List L)
{
if (L==NULL) return NULL;

List tempPtr, rear, prePtr, newPtr, lNode;
int N, realN, nextPosition;
realN=0;
N = L->address; // 输入结点的总数N
newPtr = (List)malloc(sizeof(LNode)); // 新头结点指向链表
newPtr->next = L->next;

L->next = NULL; // 将原头结点与原链表断开，用来准备指向排好序的链表
rear = L;
nextPosition = rear->nextAddress; // 存放下一个结点的数字地址
while (nextPosition != -1)
{
prePtr = newPtr; // tempPtr的前驱指针
tempPtr = prePtr->next;

while (tempPtr && tempPtr->address!=nextPosition)
{
prePtr = tempPtr; // pre指向其前驱
tempPtr = tempPtr->next;
}
if (tempPtr->address == nextPosition)
{
/* 将当前结点接入新链 */
lNode = tempPtr;
rear->next = lNode;
rear = lNode;

realN++; // 计算排序后链表的真实长度
prePtr->next = tempPtr->next; // 从旧链中删除该结点
rear->next = NULL; // 新链尾指针的next置空
}
// 给新链表下一个结点数字地址赋值
nextPosition = rear->nextAddress;
}
while (newPtr) // 删除多余结点
{
tempPtr =newPtr;
newPtr=newPtr->next;
free(tempPtr);
}
L->address = realN; // 链表中有效结点的总个数
return L;
}

// 思路：创建一新临时头结点，指向链表，再将原头结点的next置空，并对需要反转的进行头插入法即可(有头结点方便操作)
List listReverse(List L)
{
int N, K, M, i, j;
List header, lNode, tempHeader, tempPtr;
N = L->address; // 链表中的总结点
K = L->data; // 反转的个数
M = N/K; // 需要反转的轮数

// 新头结点指向原链
tempHeader = (List)malloc(sizeof(LNode));
tempHeader->next = L->next;
tempPtr = tempHeader->next;

L->next = NULL;
header = L;
j = 0;
for (i = 0; i < M*K; i++)
{
lNode = tempPtr;
// 从原链表中去除结点
tempHeader->next = tempPtr->next;
tempPtr = tempPtr->next;
// 头插入法插入结点
lNode->next = header->next;
header->next = lNode;
j++;
if (j == K)
{
// 下一轮开始头插，必须将指针移动到链表尾部
while (header->next)
header = header->next;
j = 0;
}
}
if (M != 0)
header->next = tempHeader->next;
free(tempHeader); // 释放临时结点
// 将地址信息进行处理
L->nextAddress = L->next->address;
tempPtr = L->next;
while (tempPtr)
{
if (tempPtr->next)
tempPtr->nextAddress = tempPtr->next->address;
else
tempPtr->nextAddress = -1;
tempPtr = tempPtr->next;
}
return L;
}

void printList(List L)
{
int i, N;
List tempNode = L->next; //pointer of firstNode
N = L->address; // 结点总数
for(i = 0; i< N; i++)
{
printf("%05d ", tempNode->address);
printf("%d ", tempNode->data);
if(tempNode->nextAddress == -1)
printf("%d", tempNode->nextAddress);
else
printf("%05d", tempNode->nextAddress);
printf("\n");
tempNode = tempNode->next;
}
}

int main()
{
/* 创建并读入链表 */
List l = listCreate();
/* 将链表排序 */
l = listSort(l);
/* 反转链表 */
l = listReverse(l);
/* 打印链表 */
printList(l);
return 0;
}