我将如何在一个简单的有向图中倒数？

Question

So I have this graph with books I'm iterating through and printing them out.

public class Books : IBookFinder
{
    private Books(Books next, string book)
    {
        Next = next;
        Book = book;
    }

    public Books Next { get; }
    public string Book { get; }

    public Books Previous(string book)
    {
        return new Books(this, book);
    }

    public static Books Create(string book)
    {
        return new Books(null, book);
    }

    public string FromLeft(Books books, int numberFromLeft)
    {
        for (int i = 1; i < numberFromRight; i++)
        {
            books = books?.Next; //Go through the books and return null if books is null.
        }

        return books.book; //Should probably check for null here as it crashes if the input number is out of book range (something else than 1-4)
    }

    public string FromRight(Books books, int numberFromRight
    {
        //How to implement this bad boy?
    }
}

All is well and good, but I want to implement a method FromRight so that I can write out the name of the book from it's placement in the graph, given a number input. For example, if inputting "3", it should output "Lord of the Rings". How would I go about doing that? Any hints greatly appreciated.

class Program
{
    static void Main(string[] args)
    {
        var curr = Books
            .Create("Harry Potter")
            .Previous("Lord of the Rings")
            .Previous("Twilight")
            .Previous("Da Vinci Code");

        while (curr != null)
        {
            if (curr.Next != null)
            {
                Console.Write(curr.Book + " --- ");
            }
            else
            {
                Console.WriteLine(curr.Book);
            }
            curr = curr.Next;
        }

        Console.WriteLine("Input number to pick a book");

        var bookNumber = Console.ReadLine();
        int n;

        if (int.TryParse(bookNumber, out n)) //Checking if the input is a #
        {

        }
        else
        {
            Console.WriteLine("Input was not a number!");
        }
        Console.WriteLine(bookNumber);

        Console.ReadLine();
    }
}

UPDATE:

I've managed to figure out a way to do it, without having to make a doubly linked list, even though that is of course probably the optimal solution for this problem.

I've made a helper function Count(), which takes the list and counts entries:

    private int Count(Books books)
    {
        int count = 1;
        while (books.Next != null)
        {
            books = books.Next;
            count++;
        }

        return count;
    }

I then use the return value of this method to select books from the right:

    public string FromRight(Books books, int numberFromRight)
    {
        var bookCount = Count(books); //Getting the amount of books.
        for (int i = numberFromRight; i < bookCount; i++)
        {
            books = boos?.Next; 
        }

        return books.Book;
    }

Answer 1

Since you are creating this like a linked list, to go backwards you need to create a doubly linked list: https://en.wikipedia.org/wiki/Doubly_linked_list

Your current code has no representation of the previous node. Set the previous node as that of the current while creating the next, then its iterating is just like you did originally.

Iterate until there is no Next, then print until there is no previous.

Answer 2

A single-linked list can only be iterated in a single direction, so it's not possible to go backwards.

To get the nth element from the left, you simply need to go next n times. But to figure out elements from the right, you first need to get to the end. So to get the last element, you need to go next as often as possible. To get the next to last element, you need to go to the end and return the element before that.

You may see where this is going: In order to get the nth element from the right, you need to remember the last n elements while iterating through the linked list. This also means that in the worst case, you remember every item when getting the first element from the left—but from the right.

Implementing this is not too difficult, you can do this very easily with a list of length numberFromRight but since you are inserting at the end and removing elements from the beginning you would be shifting elements all the time. So you better use a fixed-length queue. Or you use a array with a variable pointer which avoids having to shift anything. A FromRight method could look like this:

public Element FromRight(int numberFromRight)
{
    // increment the offset by one, so that `0` means the last element,
    // and `1` means the one before last, etc.
    numberFromRight++;

    // create an array with `numberFromRight` slots
    Element[] arr = new Element[numberFromRight];

    // add the current item to the array
    arr[0] = this;

    // `i` is the index where to add the next element
    int i = 1 % numberFromRight;

    // iterate through all elements until the very end
    Element current = this;
    while (current.Next != null)
    {
        current = current.Next;

        // add the current element to the array
        arr[i] = current;

        // increment the index by one, overflowing back to the beginning of the array
        i = (i + 1) % numberFromRight;
    }

    // the element at position `i` is the nth element from the right.
    return arr[i];
}

(I've chosen to implement this without your Books type since you mixed Books and Customers in a confusing way and I didn't get that. This works for arbitrary linked lists.)

If you find yourself accessing elements from the end more regularly, you should consider using a doubly linked list instead which also maintains a pointer to the left element. This means that more references need be be maintained (increasing the complexity for list operations a bit) but results in a way better performance (since iterating from the end is the same as iterating from the beginning).

In general, you should always choose a data structure that fits your access pattern. No data structure is perfect for everything, so it's important to understand the differences and to know what you really need in your application so you can choose well.