【PAT】1052. Linked List Sorting （链表）及测试点问题

【PAT】1052. Linked List Sorting （链表）及测试点问题

题目原文:

1052 Linked List Sorting (25 分)

A linked list consists of a series of structures, which are not necessarily adjacent in memory. We assume that each structure contains an integer key and a Next pointer to the next structure. Now given a linked list, you are supposed to sort the structures according to their key values in increasing order.

Input Specification:

Each input file contains one test case. For each case, the first line contains a positive N (<105) and an address of the head node, where N is the total number of nodes in memory and the address of a node is a 5-digit positive integer. NULL is represented by −1.

Then N lines follow, each describes a node in the format:

Address Key Next

where Address is the address of the node in memory, Key is an integer in [−105,105], and Next is the address of the next node. It is guaranteed that all the keys are distinct and there is no cycle in the linked list starting from the head node.

Output Specification:

For each test case, the output format is the same as that of the input, where N is the total number of nodes in the list and all the nodes must be sorted order.

Sample Input:

5 00001
11111 100 -1
00001 0 22222
33333 100000 11111
12345 -1 33333
22222 1000 12345

Sample Output:

5 12345
12345 -1 00001
00001 0 11111
11111 100 22222
22222 1000 33333
33333 100000 -1

题目大意：

给出一系列数据（节点的格式），然后对date排序并输出

知识点：

• 【结构体】+【链表】

• 首先结构体在构建的时候，为了链表进行操作的时候方便所以加入了标记量

struct NODE {
    int address, key, next;
    bool flag;
}node[100000];

• 有了结构体里的标记量就尽量在原链表进行操作，防止在搬移赋值的时候乱掉，越界
• 柳神很好看的一个写法，对for掌握很好

    for(int i = s; i != -1; i = node[i].next) {
        node[i].flag = true;
        cnt++;
    }

坑点：

• 给的节点有的是无用的（我还以为坑在“and there is no cycle in the linked list starting from the head node.”想了了半天就是没想到，但观察输出中有个数就知道不对劲）
• 极端“0”的去情况，也就是全为脏数据

小结：

自己的代码老是考虑不全面，哎pat简直是测试岗哈哈

自己的代码不够简洁，导致为“补坑而改BUG”反而容易出问题！

代码：

柳妹子的：

分析：建立结构体数组，按照从首地址开始的顺序（直到-1）遍历一遍整个链表，将在链表中的结点的flag标记为true，并且统计cnt（有效结点的个数）。（因为有的结点根本不在链表中）

然后将链表进行排序，如果flag == false就把他们移动到后面（即：reuturn a.flag > b.flag）,最后只输出前cnt个链表的信息～

原文链接：https://blog.csdn.net/liuchuo/article/details/52144537

#include <iostream>
#include <algorithm>
using namespace std;
struct NODE {
    int address, key, next;
    bool flag;
}node[100000];
int cmp1(NODE a, NODE b) {
    return !a.flag || !b.flag ? a.flag > b.flag : a.key < b.key;
}
int main() {
    int n, cnt = 0, s, a, b, c;
    scanf("%d%d", &n, &s);
    for(int i = 0; i < n; i++) {
        scanf("%d%d%d", &a, &b, &c);
        node[a] = {a, b, c, false};
    }
    for(int i = s; i != -1; i = node[i].next) {
        node[i].flag = true;
        cnt++;
    }
    if(cnt == 0) {
        printf("0 -1");
    } else {
        sort(node, node + 100000, cmp1);
        printf("%d %05d\n", cnt, node[0].address);
        for(int i = 0; i < cnt; i++) {
            printf("%05d %d ", node[i].address, node[i].key);
            if(i != cnt - 1)
                printf("%05d\n", node[i + 1].address);
            else
                printf("-1\n");
        }
    }
    return 0;
}

我的：（未AC!!）

import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.Scanner;

public class P1052_LinkedListSorting {
	static int temp[][]=new int [100010][2];
	static node arr[];
	
	static class node{
		int begin;
		int key;
		int end;
		public int getEnd() {
			return end;
		}
		public void setEnd(int end) {
			this.end = end;
		}
		public node(int begin, int key, int end) {
			super();
			this.begin = begin;
			this.key = key;
			this.end = end;
		}
		
	}
	
	static class mycomparater implements Comparator<node>{
		@Override
		public int compare(node o1, node o2) {
			if(o1.key<=o2.key){
				return -1;
			}else{
				return 1;
			}
		}
	}
	
	public static void main(String[] args) {
		Scanner sc= new Scanner(System.in);
		int n= sc.nextInt();
		int start=sc.nextInt();

		ArrayList<node> list= new ArrayList<>();
		for (int i = 0; i < n; i++) {
			int begin=sc.nextInt();
			int key=sc.nextInt();
			int end=sc.nextInt();
			temp[begin][0]=key;
			temp[begin][1]=end;
		}
		
		link(start,list);
		int l=list.size();
		arr=new node[l];
		for (int i = 0; i < l; i++) {
			arr[i]=list.get(i);
		}
		
		DecimalFormat df = new DecimalFormat("00000");
		Arrays.sort(arr, new mycomparater());
		System.out.println(arr.length+" "+df.format(arr[0].begin));
		for (int i = 0; i < n; i++) {
			if(i!=n-1){
				System.out.println(df.format(arr[i].begin)+" "+arr[i].key+" "+df.format(arr[i+1].begin));
			}else{
				System.out.println(df.format(arr[i].begin)+" "+arr[i].key+" "+"-1");
			}
			
		}
	}

	private static void link(int start, ArrayList<node> list) {
		if(temp[start][1]==-1){
			list.add(new node(start,temp[start][0],temp[start][1]));
			return;
		}else{
			list.add(new node(start,temp[start][0],temp[start][1]));
			link(temp[start][1],list);
		}
		
	}

}

“我的肩上是风，风上是闪烁的星群”