线性结构---Reversing Linked List

最新推荐文章于 2022-03-21 23:03:24 发布

原创最新推荐文章于 2022-03-21 23:03:24 发布 · 250 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#数据结构 #C++ #链表

数据结构专栏收录该内容

2 篇文章

订阅专栏

本文介绍了一种算法，用于实现单向链表中每K个元素进行逆序操作的方法。输入包括链表头节点地址、节点总数及逆序长度K等，通过定义链表结构并实现逆序功能，最后输出逆序后的链表。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

02-线性结构3 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$ ( $\le 10^5$ ) which is the total number of nodes, and a positive $K$ ( $\le 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 Nextis 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<iostream>
#include<cstdio>


using namespace std;


 struct ListNode {
	int data;
	int address;
	int nextAddress;
	ListNode *next=NULL;
};


class LinkList {
private:
	int len;
	ListNode *head;
public:
	LinkList() {
		head = new ListNode();
		len = 0;
	}
	void create(int sAddress, ListNode *a,int n) {
		ListNode *p = head;
		p->nextAddress = sAddress;
		int nextAddress = sAddress;
		int i = 0;
		//循环查找下一个节点，直到下一个节点为空
		while (nextAddress != -1) {
			if (a[i].address == nextAddress) {
				p->next = &a[i];
				nextAddress = a[i].nextAddress;
				p = p->next;
				len++;
			}
			else
				;
			i++;
			i = i % n;
		}
	}
	void display() {
		ListNode *p = head;
		//输出每一个节点，直到下一个节点为NULL，即-1
		while (p->nextAddress != -1) {
			p = p->next;
			printf("%05d %d ", p->address, p->data);
			if (p->nextAddress < 0)
				cout << p->nextAddress << endl;
			else
				printf("%05d\n", p->nextAddress);
		}
	}
	void reverse(int k) {
		//当逆序结点数为1或者单链表长度为1时，不作处理
		if (k == 1||len==1)
			return;
		int t = len /k ;	//t为需要逆序段的个数
		ListNode *s = head;	//逆序段的前一个结点
		ListNode *end;		//逆序段的后一个结点
		ListNode *p = head;
		while (t--) {
			int cnt = k;	//每一个逆序段结点的个数
			p = s;
			ListNode *temp = p->next;//当前逆序段的第一个结点
			while (cnt--)
				p = p->next;
			//p为当前逆序段的最后一个结点
			if (p->next)
				end= p->next;
			else 
				end=NULL;
			while (temp != p) {
				ListNode *q = temp->next;
				temp->next = end;
				if (end == NULL)
					temp->nextAddress = -1;
				else
					temp->nextAddress = end->address;
				end = temp;
				temp = q;
			}
			p->next = end;
			p->nextAddress = end->address;
			temp = s->next;			//temp为下一个逆序段的前一个结点
			s->next = p;			//连接当前逆序段的前一个结点和第一个结点
			s->nextAddress = p->address;
			s = temp;				//s为下一个逆序段的前一个结点
		}
	}
};


int main() {
	int sAddress, N, K;
	//sAddress为第一个结点的address
	cin >> sAddress >> N >> K;
	ListNode *a = new ListNode[N];
	for (int i = 0; i < N; i++) 
		cin >>a[i].address>> a[i].data >> a[i].nextAddress;
	LinkList A;
	A.create(sAddress,a,N);
	A.reverse(K);
	A.display();
	delete[]a;
	a = NULL;
	return 0;
}