1074 Reversing Linked List (25 point(s))

1074 Reversing Linked List (25 point(s))

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

链表。

思路很简单,主要考虑两点:

1. 可能存在不在链表中的无效结点;

2. 注意输出格式,比如补零。

一定要读题仔细,看着样例分析的过程中,以为要先排序(样例正好是这样的),然后再每K个元素翻转,结果浪费了整整半个小时。 

#include<iostream>
#include<cstring>
#include<vector>
#include<algorithm>
using namespace std;
const int MAX = 1e5+7;
int data[MAX];
int nextAdd[MAX];
int main(void){
	int root,N,K;cin>>root>>N>>K;
	int address,key,next;
	for(int i=0;i<N;i++){
		cin>>address>>key>>next;
		data[address]=key;
		nextAdd[address]=next;
	}
	vector<int> v;
	while(root!=-1){
		v.push_back(root);
		root = nextAdd[root];
	}
	for(int i=0;i+K<=v.size();i=i+K){
		reverse(v.begin()+i,v.begin()+i+K);
	}
	for(int i=0;i<v.size();i++){
		if(i==v.size()-1) printf("%05d %d -1\n",v[i],data[v[i]]);
		else printf("%05d %d %05d\n",v[i],data[v[i]],v[i+1]);
	}
	return 0;
} 

 

### PTA 7-2 重排链表解法 对于PTA平台上的7-2重排链表题目,可以采用类似于LeetCode第143题的方法来解决这个问题。具体来说,在处理单链表 \(L\) 的时候,目标是将其重新排列成特定模式:\(L_0 \rightarrow L_n \rightarrow L_1 \rightarrow L_{n-1} \rightarrow L_2 \rightarrow L_{n-2}\ldots\)[^3]。 为了实现这一目标,通常会采取以下策略: #### 方法概述 1. **找到中间节点** 首先利用快慢指针技术定位到链表的中间位置。这一步骤有助于后续操作中的效率提升。 2. **反转后半部分链表** 找到中间节点之后,将链表从中点断开并单独对后面的部分执行翻转操作。这样做可以让后面的元素按照相反顺序连接起来。 3. **交替合并两段链表** 接下来就是把前一半未改变顺序的链表同已经反转过的另一半依次交错相连,从而形成最终所需的输出形式。 下面是具体的Python代码实现方式: ```python class ListNode: def __init__(self, val=0, next=None): self.val = val self.next = next def reorderList(head: ListNode) -> None: if not head or not head.next: return # Step 1: Find the middle of the list using slow and fast pointers. slow, fast = head, head while fast and fast.next: slow = slow.next fast = fast.next.next # Step 2: Reverse the second half of the linked list starting from 'slow'. prev, curr = None, slow while curr: temp_next = curr.next curr.next = prev prev = curr curr = temp_next # Now `prev` points to the last element (new start point after reversing). # Step 3: Merge two halves by alternating nodes between them. first_half, second_half = head, prev while second_half.next: tmp_first = first_half.next tmp_second = second_half.next first_half.next = second_half second_half.next = tmp_first first_half = tmp_first second_half = tmp_second ``` 此算法的时间复杂度主要取决于遍历次数以及每次遍历时的操作量级,整体时间复杂度大约为O(n),其中n代表链表长度;空间复杂度则保持在常数级别O(1),因为只用了有限数量额外变量存储临时状态信息。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值