Question

这是我在这里的第一篇文章，但我不是网站的新手（称我为潜伏者）。不幸的是，这次我似乎无法在没有询问的情况下找到我的问题的答案。无论如何，到了这一点。

我正在用java编写一个小蛇和梯子（也就是滑槽和梯子）程序，用于数据结构课程。我必须编写自己的Linked List（LL）类，（我知道有一个java util可以做得更好，但我必须了解数据结构的工作方式），这不是问题。我的LL是“半双链接”，因为我喜欢称之为它，因为它链接前进，但是有其他链接的另一个指针字段，不一定在每个节点中使用。

我想知道的是，是否可以将列表中的节点链接到另一个不同类型的列表。不好的例子：（例如。）如何将类型的节点链接到类型的节点？假设我们有一个7个内部值的LL [1,2,3,4,5,6,7]和7个字符串的LL [周一，周二，周三，周四，周五，周六，周日]。我们希望将包含1的节点链接到包含星期一的节点。

确切地说，我遇到的问题如下：我有100个节点前向链接，形成游戏板，以及循环链接列表4。我想将玩家节点链接到他们在棋盘上各自的位置，这样当他们遍历棋盘时，他们也可以跟随“蛇”和“梯子”链接。

提前致谢！

我的LLNode.java和LL.java已附加。

// LLNode.java  
// node in a generic linked list class, with a link 

public class LLNode<T> 
{
    public T info;
    public LLNode<T> next, link;

    public LLNode()
    {   
        next = null;
        link= null;
    }

    public LLNode(T element)
    {
        info = element;
        next = null;
        link = null;
    }

    public LLNode(T element, LLNode<T> n)
    {
        info = element;
        next = n;
        link = null;
    }

    public T getInfo()
    {
        return info;
    }

    public void setInfo(T element)
    {
        info = element;
    }

    public LLNode<T> getNext()
    {
        return next;
    }

    public void setNext(LLNode<T> newNext)
    {
        next = newNext;
    }

    public LLNode<T> getLink()
    {
        return link;
    }

    public void setLink(LLNode<T> newLink)
    {
        link = newLink;
    }
}

// SLL.java 
// a generic linked list class

public class LL<T> 
{
    private LLNode<T> head, tail;
    public LLNode<T> current = head;

    public LL()
    {
        head = tail = null;
    }

    public boolean isEmpty()
    {
        return head == tail;
    }

    public void setToNull()
    {
         head = tail = null;
    }

    public boolean isNull()
    {
        if(head == tail)
            if(head == null || tail == null)
                return true;
            else 
                return false;
        else 
            return false;
    }

    public void addToHead(T element)
    {
        head = new LLNode<T>(element, head);
        if (tail == null)
            tail = head;
    }

    public void addNodeToHead(LLNode<T> newNode)
    {
        head = newNode;
        if (tail == null)
            tail = head;
    }

    public void addToTail(T element)
    {
        if (!isNull())
        {
            tail.next= new LLNode<T>(element);
            tail = tail.next;
        }
        else head = tail = new LLNode<T>(element);
    }

    public void addNodeToTail(LLNode<T> newNode)
    {
        if (!isNull())
        {
            tail.next= newNode;
            tail = tail.next;
        }
        else head = tail = newNode;
    }

    public void addBefore(T element, T X)
    {
        if (!isEmpty()) // Case 1
        {
            LLNode<T> temp, n;

            temp = head;
            while( temp.next != null )
            {
                if( temp.next.info == X )
                {
                    n = new LLNode<T>(element, temp.next);
                    temp.next = n;
                    return;
                }
                else 
                temp = temp.next;
            }    
        }
        else // Case 2
            head = new LLNode<T>(element, head);
    }

    public void addBefore(T element, LLNode<T> X)
    {
        if (!isEmpty()) // Case 1
        {
            LLNode<T> temp, n;

            temp = head;
            while( temp.next != null )
            {
                if( temp.next == X )
                {
                    n = new LLNode<T>(element, X);
                    temp.next = n;
                    return;
                }
                else 
                temp = temp.next;
            }    
        }
        else // Case 2
            head = new LLNode<T>(element, head);
    }

    public T deleteFromHead()
    {
        if (isEmpty())
            return null;
        T element = head.info;
        if (head == tail)
            head = tail = null;
        else head = head.next;
        return element;
    }

    public T deleteFromTail()
    {
        if (isEmpty())
            return null;
        T element = tail.info;
        if (head == tail)
            head = tail = null;
        else 
        {
            LLNode<T> temp;
            for (temp = head; temp.next != tail; temp = temp.next);
            tail = temp;
            tail.next = null;
        }
        return element;
    }

    public void delete(T element)
    {
        if (!isEmpty())
            if (head == tail && (element.toString()).equals(head.info.toString()))
                head = tail = null;
            else if ((element.toString()).equals(head.info.toString()))
                head = head.next;
        else 
        {
            LLNode<T> pred, temp;
            for (pred = head, temp = head.next; temp != null && !((temp.info.toString()).equals(element.toString())); pred = pred.next, temp = temp.next);
            if (temp != null)
                pred.next = temp.next;
            if  (temp == tail)
                tail = pred;
        }
    }

    public void listAll()
    {
        if(isNull())
            System.out.println("\tEmpty");
        else
        {
            for ( LLNode<T> temp = head; temp!= tail.next; temp = temp.next)
                System.out.println(temp.info);
        }
    }

    public LLNode<T> isInList(T element)
    {
        LLNode<T> temp;
        for ( temp = head; temp != null && !((temp.info.toString()).equals(element.toString())); temp = temp.next);
        return temp ;
    }

    public LLNode<T> getHead()
    {
        return head;
    }

    public LLNode<T> getTail()
    {
        return tail;
    }

    public LLNode<T> getCurrent()
    {
        return current;
    }

    public void incrementCurrent()
    {
        current = current.next;
    }

    public void followCurrentLink()
    {
        current = current.link;
    }
}

Answer 1

您想要为节点对象的特定问题域进行泛型的任何特定原因？

如果你想产生这种效果，另一种方法可能是拥有节点对象的接口（可能称之为ILinkNode），在两个不同的节点类中重写getInfo和setInfo。然后nodeLink可以指向接口对象，而无需在代码中的任何地方进行特殊的类型转换。

Answer 2

在第一个列表中使用，即包含要链接到另一个列表中节点的节点的那个，Object作为泛型类型实例。

类似的东西：

    LL<Object> ll = new LL<Object>();

如果这样做，每次从列表中检索节点的值时，都必须注意转换为特定类型。

链接列表节点指向不同类型的节点

2 个答案: