02-线性结构3 Reversing Linked List （25 分）

Posted 2021-01-09 interim

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

using System;
using System.Collections.Generic;




struct Point
{
    public string X;
    public int Y;
    public string Z;
    public Point(string v1, int v2, string v3) : this()
    {
        this.X = v1;

        this.Y = v2;
        this.Z = v3;
    }
}
struct Point2
{
    public string X;
    public int Y;
    public int Z;
    public Point2(string v1, int v2, int v3) : this()
    {
        this.X = v1;
        this.Y = v2;
        this.Z = v3;
    }
}
class T
{


    static void Main(string[] args)

    {
        List<Point> pList = new List<Point>();
        List<Point> newList = new List<Point>();

        var v = Console.ReadLine().Split(new[] { " " }, StringSplitOptions.RemoveEmptyEntries);

        Point2 P = new Point2(v[0], int.Parse(v[1]), int.Parse(v[2]));
        for (int i = 0; i < P.Y; i++)
        {
            var temp = Console.ReadLine().Split(new[] { " " }, StringSplitOptions.RemoveEmptyEntries);

            pList.Add(new Point(temp[0], int.Parse(temp[1]), temp[2]));


        }
        var addr = P.X;
        while (addr != "-1")
        {
            var p = pList.FindIndex(x => (x.X == addr));
            if (p>=0)
            {
                newList.Add(pList[p]);
                addr = pList[p].Z;
            }
            pList.RemoveAt(p);
        }


        List<Point> rList = new List<Point>();
        var max = newList.Count / P.Z;
        var c = 0;
        for (int i = 0; i < max; i++)
        {
            for (int j = P.Z - 1; j >= 0; j--)
            {
                c = P.Z * i + j;
                if (c < newList.Count)
                {
                    rList.Add(newList[c]);
                }
            }
        }
        int m = max * P.Z;
        while (m < newList.Count)
        {
            rList.Add(newList[m++]);
        }
        List<Point> rList2 = new List<Point>();

        for (int i = 0; i < rList.Count - 1; i++)
        {
            Point tt = new Point();
            tt = rList[i];
            tt.Z = rList[i + 1].X;


            rList2.Add(tt);
        }
        Point t = new Point();
        t = rList[rList.Count - 1];
        t.Z = "-1";
        rList2.Add(t);

        foreach (var item in rList2)
        {
            Console.WriteLine(item.X + " " +
                 item.Y + " " +
                 item.Z);
        }
    }
}