在阵列列表中存储多个链接列表。如何最好地访问它们并对它们执行链接列表特定操作？

Question

我将链接列表存储在数组列表中。每个链接列表包含不同的项目。我想从数组列表中检索特定的链表，例如在索引位置0处，并执行某些操作，例如从前面穿过。但是，我在将数组项目识别为链接列表时遇到问题。这样做的最佳方式是什么？

如果我有

静态ArrayList ar = new ArrayList（）;

静态DLinkedList b =新的DLinkedList（）;

并希望做到以下几点。

b.TraverseFront（AR [0]）;

我在下面举了一个例子，我在C＃中实现了

class Program
{
    static ArrayList ar = new ArrayList();
    static DLinkedList b = new DLinkedList();

    static void Main(string[] args)
    {
        store("huggo boss");  
        b.TraverseFront(ar[0]); // THIS IS WHAT I'D LIKE TO DO BUT I DON'T KNOW HOW TO DO IT

    }


    private static void store(string s) 
    {
        DLinkedList linkedListNode = new DLinkedList();

        string output = null;
        string norm = null;
        int token = 3;
        for (int i = 0; i < s.Length; i++) 
        {

            if (!String.IsNullOrWhiteSpace(char.ToString(s[i])))
            {
                output = output + s[i];
            }
        }

        for (int j = 0; j < output.Length - token + 1 ; j++)
        {
            norm = norm + output[j] + output[j + 1] + output[j + 2]
            linkedListNode.InsertNext(norm);
            norm = null;
        }
    }
}
}


class DLinkedList
    {
        private Object data;

        private DLinkedList next;
        private DLinkedList prev;

        /*
        static void Main(string[] args)
        {
            DLinkedList node1 = new DLinkedList(1);
            DLinkedList node3 = node1.InsertNext(3);
            DLinkedList node2 = node3.InsertPrev(2);
            DLinkedList node5 = node3.InsertNext(5);
            DLinkedList node4 = node5.InsertPrev(4);

            node1.TraverseFront();
            node5.TraverseBack();
            Console.Read();
        }
        */

        public DLinkedList()
        {
            data = null;
            next = null;
            prev = null;
        }

        public DLinkedList(Object value)
        {
            data = value;
            next = null;
            prev = null;
        }

        public DLinkedList InsertNext(Object value)
        {
            DLinkedList node = new DLinkedList(value);
            if (this.next == null)
            {
                // Easy to handle
                node.prev = this;
                node.next = null; // already set in constructor
                this.next = node;
            }
            else
            {
                // Insert in the middle
                DLinkedList temp = this.next;
                node.prev = this;
                node.next = temp;
                this.next = node;
                temp.prev = node;
                // temp.next does not have to be changed
            }
            return node;
        }

        public DLinkedList InsertPrev(Object value)
        {
            DLinkedList node = new DLinkedList(value);
            if (this.prev == null)
            {
                node.prev = null; // already set on constructor
                node.next = this;
                this.prev = node;
            }
            else
            {
                // Insert in the middle
                DLinkedList temp = this.prev;
                node.prev = temp;
                node.next = this;
                this.prev = node;
                temp.next = node;
                // temp.prev does not have to be changed
            }
            return node;
        }

        public void TraverseFront()
        {
            TraverseFront(this);
        }

        public void TraverseFront(DLinkedList node)
        {
            if (node == null)
                node = this;
            System.Console.WriteLine("\n\nTraversing in Forward  
                                      Direction\n\n");

            while (node != null)
            {
                System.Console.WriteLine(node.data);
                node = node.next;
            }
        }

        public void TraverseBack()
        {
            TraverseBack(this);
        }

        public void TraverseBack(DLinkedList node)
        {
            if (node == null)
                node = this;

            while (node != null)
            {
                System.Console.WriteLine(node.data);
                node = node.prev;
            }
        }




        internal void TraverseFront(object p)
        {
            throw new NotImplementedException();
        }
    }
}