数据结构——Reversing Linked List

02-线性结构3 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 (≤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

分析:这道题很有意思,题目要求给定一个链表,长度N,需要反向输出的长度K,就是说对一个链表实现循环前K个反向输出, 直到输出长度小于K。例子: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。我的算法设计是:首先设计单向链表的反向输出函数,返回首地址。然后定义数组来存储这些不同段的首地址,最后将这些段连接起来。算法复杂度O(N)。

如果只是这样的话,这道题也不能算难。但是仔细看输入输出要求:

1、输入的链表还需要重新按照给定的当前地址与下一个地址排序。我设计的算法是:首先找出在链表中找出给定的首地址。然后对当前结点指向地址与后面结点的当前地址进行判断(遍历),如相等则与当前结点的下一个结点进行数据交换。算法复杂度大于O(N),但小于O(N^2).

2、输入的链表中有些是无效结点,需要剔除。我的思路是判断结点指向地址是否等于-1.

3、链表的逆序算法原理:

代码有些长,两百多行,可以只看函数实现部分,输入输出可以不看,欢迎互相探讨,谢谢!

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

typedef struct LNode *List;
struct LNode{
	char Address[6];	
	int Data;
	char Next_Address[6];
	List next;
}; 

void Gets(char a[]);
List ReadInput(int N);
void Print(List L);
List Reversing(List L, char First_Address[], int K, int N);
void LSord(List L, List P);	
List Ni_Xu(List L,int K);

int main()
{
//	while(getchar()!=EOF)
//	{
	List L,R;
	/*	
	**	0<N<=10^5,0<K<=N;
	*/
	char First_Address[6]; 
	int N,K,i;
	Gets(First_Address);
	scanf("%d%d",&N,&K);
	getchar();
	L = ReadInput(N);
//	printf("结果:\n");
	R = Reversing(L, First_Address, K, N);
	Print(R);
//}
	return 0;
}

List ReadInput(int N)
{
	List L,P,t;
	int i;
	L = (List)malloc(sizeof(struct LNode));
	P = L;
	for(i = 0; i < N; i++)
	{
		Gets(P->Address);
		scanf("%d",&P->Data);
		getchar();
		Gets(P->Next_Address);
		
		t = P;
		P = (List)malloc(sizeof(struct LNode));
		t->next = P;
	}
	free(P);
	t->next = NULL;
	
	return L; 
}

void Print(List L)
{
	List P = L;
	if(P == NULL)	printf("NULL\n");
	for( ; P != NULL; P = P->next)
		printf("%s %d %s\n", P->Address, P->Data, P->Next_Address);
}

List Reversing(List L, char First_Address[], int K, int N)
{
	List P,P1,t;
	int i,cnt=1;
	/*	
	**	将链表按地址排序
	*/ 

	for(P = L; P != NULL; P = P->next)		/* 查找首地址,并放于头结点 测试:OK*/ 
	{
		if( strcmp( First_Address, P->Address) == 0 )	/* 交换头结点与查找结点的元素 */ 
		{
			LSord( L, P );
			break;	
		}		
	}
	for(P = L; P->next != NULL; P = P->next)		/* 按地址重排 */ 
	{
		P1 = P->next;
		for(; P1 != NULL; )
		{
			if( strcmp( P->Next_Address, P1->Address) != 0 )
				P1 = P1->next;
			else
			{
				LSord(P->next,P1);
				break;
			}
		}
	}
	for( P = L; strcmp(P->Next_Address,"-1") != 0 ; P = P->next)		/* cnt 实际有效结点数 */	
		cnt++;
	P->next = NULL;
//	Print(L);	
	
	P = L;
	int len;
	if( cnt % K == 0)	len = cnt/K;
	else			len = cnt/K +1;
	
	List R[len];		/* 分段保存逆序后的链表 */ 
	for(i = 0; P != NULL && (i+1)*K <= cnt; i++)	/* 变换前K个元素顺序 */
	{
		List f0 = P;
		int j;
		for(j = 0; j < K; j++)
			P = P->next; 
		R[i] = Ni_Xu(f0,K);
	} 
	if( cnt % K != 0)			/* 为变换的段 */ 
		R[i] = P;
	else					/* 后面指向NULL */ 
	{
		P = R[i-1];
		int j;
		for(j = 1; j < K; j++)
			P = P->next; 
		P->next = NULL;
	}	
		
	for(i=0; i<len-1; i++)		/* 将分段后的链表连接 */ 
	{
		P = R[i];
		int j;
		for(j = 1; j < K; j++)
			P = P->next; 
		P->next = R[i+1];
	}
	
	P = R[0];			/* 此时下一个结点的地址需要重新修改 */ 
	for( ;P->next != NULL; P = P->next)
		strcpy(P->Next_Address,P->next->Address);
	P->Next_Address[0] = '-';	/* 最后一个结点下一个地址为-1 */ 
	P->Next_Address[1] = '1';
	P->Next_Address[2] = '\0';
	
//	Print(R[0]);	
//	printf("test4\n");
	return R[0];
}

/*	
**	交换L,P中元素
*/ 
void LSord(List L, List P)	
{
	char s1[6],s2[6];
	int d;	
	
	strcpy(s1, L->Address);
	strcpy(s2, L->Next_Address);
	d = L->Data;
			
	strcpy(L->Address, P->Address);
	strcpy(L->Next_Address, P->Next_Address);
	L->Data = P->Data;
				
	strcpy(P->Address, s1);
	strcpy(P->Next_Address, s2);
	P->Data = d;
	
} 

List Ni_Xu(List L,int K)
{
	List P0,P,t;
	int i;
	P0 = L;
	P = P0->next;
	for( i = 1; P != NULL && i < K; i++ )
	{
		t = P->next;
		P->next = P0;
		P0 = P;
		P = t; 
	}
	return P0;
}

void Gets(char a[])
{
	int i;

	for(i=0;;i++)
	{
		a[i]=getchar();
		if(a[i] == ' ' || a[i] == '\n')	break;
	}
	a[i] = '\0';
}

 

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
题目描述 给定一个常数 $K$ 以及一个单链表 $L$,请编写程序将 $L$ 中每 $K$ 个结点反转。例如:给定 $L$ 为 1→2→3→4→5→6,$K$ 为 3,则输出应该为 3→2→1→6→5→4;如果 $K$ 为 4,则输出应该为 4→3→2→1→5→6,即最后不到 $K$ 个元素不反转。 输入格式 每个输入包含一个测试用例。每个测试用例第 1 行给出第 1 个结点的地址、结点总个数正整数 $N (\le 10^5)$、以及正整数 $K (\le N)$,即要求反转的子链结点的个数。结点的地址是 5 位非负整数,NULL 地址用 −1 表示。 接下来有 $N$ 行,每行格式为: Address Data Next 其中 Address 是结点地址;Data 是该结点保存的整数数据;Next 是下一结点的地址。题目保证给出的链表不为空。 输出格式 对每个测试用例,顺序输出反转后的链表,其上每个结点占一行,格式与输入相同。 输入样例 00100 6 4 00000 4 99999 00100 1 12309 68237 6 -1 33218 3 00000 99999 5 68237 23333 2 33218 输出样例 00000 4 33218 33218 3 12309 12309 1 99999 99999 5 68237 68237 6 23333 23333 2 -1 题目分析 本题需要将链表中每 $K$ 个结点反转,可以采用迭代的方法,每次找到 $K$ 个结点,将这 $K$ 个结点反转,然后将这 $K$ 个结点的前驱结点指向反转后的第一个结点,将反转后的 $K$ 个结点的最后一个结点指向下一个要反转的结点,然后继续进行下一轮反转。 需要注意的是,如果链表长度不足 $K$,则不进行反转。 代码实现
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值