PAT|1052 Linked List Sorting(链表、排序、结构体)

题目大意

链表由一系列结构组成,这些结构在内存中不一定相邻。我们假设每个结构都包含一个整数键和一个指向下一个结构的Next指针。现在给出了一个链表,您应该按照其键值按升序对结构进行排序。

做题分析

  1. 本来以为只要控制好节点自己的地址和值即可,因此直接使用了map排序解决的问题。最后提交才发现部分用例无法通过。看了柳神的题解才知道有的节点根本不在链表之中。
    在这里插入图片描述
  • 给大家看看错误代码,引以为戒。
#include<bits/stdc++.h>
using namespace std;
int numNode, pre, value, nex;
map<int, int> myMap;
int main() {
	cin >> numNode >> pre;
	for (int i = 0; i < numNode; i++) {
		cin >> pre >> value >> nex;
		myMap.emplace(value, pre);
	}

	map<int, int>::iterator iter = myMap.begin();
	cout << numNode << ' ';
	while (iter != myMap.end()) {
		printf("%05d\n", iter->second);
		printf("%05d %d ", iter->second, iter->first);
		iter++;
	}
	cout << "-1";

	return 0;
}
  • 改完以后竟然只通过了一个用例。呜呜呜 - 在这里插入图片描述

代码如下:

#include<bits/stdc++.h>
using namespace std;
struct MyStruct
{
	int value;
	int pre;
	int nex;
	bool flag = 0;
};
int numNode;
map<int, int> myMap;
vector<MyStruct> vecNode(100000);
int main() {
	int head,pre;	
	cin >> numNode >> head;
	for (int i = 0; i < numNode; i++) {
		cin >> pre;
		cin >> vecNode[pre].value >> vecNode[pre].nex;
	}

	//遍历链表、找到位于
	for (int i = head; i != -1; i = vecNode[i].nex ) {
		myMap.emplace(vecNode[i].value, i);
	}

	if (myMap.size() == 0) {
		cout << "0 -1";
	}
	else {

		map<int, int>::iterator iter = myMap.begin();
		cout << numNode << ' ';
		while (iter != myMap.end()) {
			printf("%05d\n", iter->second);
			printf("%05d %d ", iter->second, iter->first);
			iter++;
		}
		cout << "-1";
	}
	return 0;
}

我们再次大胆猜测,是因为使用了map数据结构,无法存储相同的两个数据。不幸的是题中说明。

It is guaranteed that all the keys are distinct and there is no cycle in the linked list starting from the head node.

  • 问题终于找到了
    竟然是最后的数量没有更新(删除多余节点)
	map<int, int>::iterator iter = myMap.begin();
		cout << myMap.size() << ' ';

最后AC

在这里插入图片描述

最终代码

#include<bits/stdc++.h>
using namespace std;
struct MyStruct
{
	int value;
	int pre;
	int nex;
};
int numNode;
map<int, int> myMap;
vector<MyStruct> vecNode(100000);
int main() {
	int head,pre;	
	cin >> numNode >> head;
	for (int i = 0; i < numNode; i++) {
		cin >> pre;
		vecNode[pre].pre = pre;
		cin >> vecNode[pre].value >> vecNode[pre].nex;
	}
	//遍历链表、找到位于
	for (int i = head; i != -1; i = vecNode[i].nex ) {
		myMap.emplace(vecNode[i].value, vecNode[i].pre);
	}
	if (myMap.size() == 0) 
		cout << "0 -1";
	else {
		map<int, int>::iterator iter = myMap.begin();
		cout << myMap.size() << ' ';
		while (iter != myMap.end()) {
			printf("%05d\n", iter->second);
			printf("%05d %d ", iter->second, iter->first);
			iter++;
		}
		cout << "-1" << endl;
	}
	return 0;
}

题目总结

  • 原来题目真的会哪里都有坑,刚开始没有ac的两个用例,最后一个是因为如果是0的话没控制好,第二个是出现了部分节点孤立的情况。
  • 首先定义结构体存储节点信息。地址作为数据下表,记录信息。
  • 遍历链表,确定在链上的节点,利用map自动排序的性质,对对应的节点进行排序。
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
请参考我给出的代码框架,实现对EMPLOYEE结构体为数据的双向链表排序算法,要求按照按employeeId升序排列 typedef struct linkNode { void* data; //使用空指针使得NODE适配多种数据结构 struct linkNode* preNode; struct linkNode* nextNode; }LINKED_NODE; /*Define the struct of double linked list.*/ typedef struct { LINKED_NODE* head; LINKED_NODE* tail; size_t size; }DOUBLE_LINK_LIST; typedef struct { int employeeId; char name[20]; char ipAddress[30]; char seatNumber[20]; char group[10]; } EMPLOYEE; DOUBLE_LINK_LIST* createDoubleLinkedList() { DOUBLE_LINK_LIST* newList = (DOUBLE_LINK_LIST*)malloc(sizeof(DOUBLE_LINK_LIST)); newList->head = NULL; newList->tail = NULL; newList->size = 0; return newList; } void destroyDoubleLinkedList(DOUBLE_LINK_LIST* list) {} /*Add a new node before the head.*/ void insertHead(DOUBLE_LINK_LIST* list, void* data) // void执政适配其他data类型? {} /*Add a new node after tail.*/ void insertTail(DOUBLE_LINK_LIST* list, void* data) // 如何适配其他data类型? {} /*Insert a new node.*/ void insertNode(DOUBLE_LINK_LIST* list, void* data,int index) // 如何适配其他data类型? {} void deleteHead(DOUBLE_LINK_LIST* list) {} void deleteTail(DOUBLE_LINK_LIST* list) {} void deleteNode(DOUBLE_LINK_LIST* list, int index) {} LINKED_NODE* getNode(DOUBLE_LINK_LIST* list, int index) {} /* 遍历链表,对每个节点执行指定操作*/ void traverseList(DOUBLE_LINK_LIST* list, void (*callback)(void*)) { LINKED_NODE* currentNode = list->head; while (currentNode != NULL) { callback(currentNode->data); currentNode = currentNode->nextNode; } } void printEmployee(void* data) {}
07-25
你可以使用以下代码来实现对EMPLOYEE结构体为数据的双向链表排序算法,按照按employeeId升序排列: ```c #include <stdio.h> #include <stdlib.h> #include <string.h> typedef struct linkNode { void* data; //使用空指针使得NODE适配多种数据结构 struct linkNode* preNode; struct linkNode* nextNode; } LINKED_NODE; /*Define the struct of double linked list.*/ typedef struct { LINKED_NODE* head; LINKED_NODE* tail; size_t size; } DOUBLE_LINK_LIST; typedef struct { int employeeId; char name[20]; char ipAddress[30]; char seatNumber[20]; char group[10]; } EMPLOYEE; DOUBLE_LINK_LIST* createDoubleLinkedList() { DOUBLE_LINK_LIST* newList = (DOUBLE_LINK_LIST*)malloc(sizeof(DOUBLE_LINK_LIST)); newList->head = NULL; newList->tail = NULL; newList->size = 0; return newList; } void destroyDoubleLinkedList(DOUBLE_LINK_LIST* list) { LINKED_NODE* currentNode = list->head; while (currentNode != NULL) { LINKED_NODE* nextNode = currentNode->nextNode; free(currentNode); currentNode = nextNode; } free(list); } /*Add a new node before the head.*/ void insertHead(DOUBLE_LINK_LIST* list, void* data) { LINKED_NODE* newNode = (LINKED_NODE*)malloc(sizeof(LINKED_NODE)); newNode->data = data; newNode->preNode = NULL; newNode->nextNode = list->head; if (list->head != NULL) list->head->preNode = newNode; list->head = newNode; if (list->tail == NULL) list->tail = newNode; list->size++; } /*Add a new node after tail.*/ void insertTail(DOUBLE_LINK_LIST* list, void* data) { LINKED_NODE* newNode = (LINKED_NODE*)malloc(sizeof(LINKED_NODE)); newNode->data = data; newNode->preNode = list->tail; newNode->nextNode = NULL; if (list->tail != NULL) list->tail->nextNode = newNode; list->tail = newNode; if (list->head == NULL) list->head = newNode; list->size++; } /*Insert a new node.*/ void insertNode(DOUBLE_LINK_LIST* list, void* data, int index) { if (index < 0 || index > list->size) { printf("Invalid index\n"); return; } if (index == 0) { insertHead(list, data); return; } if (index == list->size) { insertTail(list, data); return; } LINKED_NODE* currentNode = getNode(list, index); LINKED_NODE* newNode = (LINKED_NODE*)malloc(sizeof(LINKED_NODE)); newNode->data = data; newNode->preNode = currentNode->preNode; newNode->nextNode = currentNode; currentNode->preNode->nextNode = newNode; currentNode->preNode = newNode; list->size++; } void deleteHead(DOUBLE_LINK_LIST* list) { if (list->head == NULL) return; LINKED_NODE* oldHead = list->head; list->head = oldHead->nextNode; if (list->head != NULL) list->head->preNode = NULL; free(oldHead); list->size--; if (list->size == 0) list->tail = NULL; } void deleteTail(DOUBLE_LINK_LIST* list) { if (list->tail == NULL) return; LINKED_NODE* oldTail = list->tail; list->tail = oldTail->preNode; if (list->tail != NULL) list->tail->nextNode = NULL; free(oldTail); list->size--; if (list->size == 0) list->head = NULL; } void deleteNode(DOUBLE_LINK_LIST* list, int index) { if (index < 0 || index >= list->size) { printf("Invalid index\n"); return; } if (index == 0) { deleteHead(list); return; } if (index == list->size - 1) { deleteTail(list); return; } LINKED_NODE* currentNode = getNode(list, index); currentNode->preNode->nextNode = currentNode->nextNode; currentNode->nextNode->preNode = currentNode->preNode; free(currentNode); list->size--; } LINKED_NODE* getNode(DOUBLE_LINK_LIST* list, int index) { if (index < 0 || index >= list->size) { printf("Invalid index\n"); return NULL; } LINKED_NODE* currentNode = list->head; int i = 0; while (i < index) { currentNode = currentNode->nextNode; i++; } return currentNode; } void traverseList(DOUBLE_LINK_LIST* list, void (*callback)(void*)) { LINKED_NODE* currentNode = list->head; while (currentNode != NULL) { callback(currentNode->data); currentNode = currentNode->nextNode; } } void printEmployee(void* data) { EMPLOYEE* employee = (EMPLOYEE*)data; printf("Employee ID: %d, Name: %s\n", employee->employeeId, employee->name); } int compareEmployee(const void* a, const void* b) { EMPLOYEE* employeeA = (EMPLOYEE*)a; EMPLOYEE* employeeB = (EMPLOYEE*)b; return employeeA->employeeId - employeeB->employeeId; } void sortList(DOUBLE_LINK_LIST* list) { size_t dataSize = sizeof(EMPLOYEE); EMPLOYEE** employeeArray = (EMPLOYEE**)malloc(list->size * sizeof(EMPLOYEE*)); LINKED_NODE* currentNode = list->head; size_t i = 0; while (currentNode != NULL) { employeeArray[i] = (EMPLOYEE*)currentNode->data; currentNode = currentNode->nextNode; i++; } qsort(employeeArray, list->size, dataSize, compareEmployee); currentNode = list->head; i = 0; while (currentNode != NULL) { currentNode->data = employeeArray[i]; currentNode = currentNode->nextNode; i++; } free(employeeArray); } int main() { DOUBLE_LINK_LIST* list = createDoubleLinkedList(); EMPLOYEE* employee1 = (EMPLOYEE*)malloc(sizeof(EMPLOYEE)); employee1->employeeId = 2; strcpy(employee1->name, "John"); insertHead(list, employee1); EMPLOYEE* employee2 = (EMPLOYEE*)malloc(sizeof(EMPLOYEE)); employee2->employeeId = 1; strcpy(employee2->name, "Alice"); insertHead(list, employee2); EMPLOYEE* employee3 = (EMPLOYEE*)malloc(sizeof(EMPLOYEE)); employee3->employeeId = 3; strcpy(employee3->name, "Bob"); insertHead(list, employee3); printf("Before sorting:\n"); traverseList(list, printEmployee); sortList(list); printf("\nAfter sorting:\n"); traverseList(list, printEmployee); destroyDoubleLinkedList(list); return 0; } ``` 这段代码首先定义了双向链表结构体和EMPLOYEE结构体,然后实现了双向链表的创建、销毁、插入、删除、遍历等操作。其,`sortList`函数使用了快速排序算法对双向链表的EMPLOYEE结构体按照employeeId升序进行排序。在`main`函数,创建了一个双向链表并插入了三个EMPLOYEE结构体,然后调用`sortList`函数对链表进行排序并输出结果。 请注意,在代码使用了动态内存分配(`malloc`)来分配内存,并在适当的时候使用了`free`来释放内存,以防止内存泄漏。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值