Question

我的意思是创建我自己的链表类（我不能使用Java的LinkedList类）并通过交换指针而不是数据来实现选择排序。

我已经创建了一个双链接的MyLinkedList类，但是我在使用sort方法时遇到了麻烦。我已经尝试了很多东西，但没有任何效果 - 甚至没有任何有意义的东西可以在这里发布以进行修正。（我知道我需要使用至少一个临时节点。）它必须是选择排序。

我不是在寻找有人为我编码，必然;我希望有人可以帮我一个算法，然后我可以自己变成代码。非常感谢任何帮助。

以下是我实现MyLinkedList类和相关Node类的方法：

public class MyLinkedList
{
    private Node head;
    private int count;

    public MyLinkedList()
    {
        head = new Node(null);
        count = 0;
    }

    public void add(String line)
    {
        Node temp = new Node(line);
        Node current = head;

        while (current.getNext() != null)
        {
            current = current.getNext();
        }

        temp.setLine (line);  // not sure this is how to do it
        current.setNext(temp);
        temp.setPrev(current);
        count++;
    }

    public void displayList()
    {
        Node current = head;

        for (int i = 0; i < count; i++)
        {
            current = current.getNext();
            System.out.println(current.getLine());
        }
    }

    public void sortList()
    {       
        Node start = head;
        Node index = start;
        Node min = start;

        Node temp1, temp2;

        while (start.getNext() != null)
        {
            index = index.getNext();

            if (index.getLine().compareTo(min.getLine()) < 0)
            {
                min = index;
            }

            //swap - HELP, PLEASE :-)
            {
                // Algorithm???
            }
        }
    }

    public int size()
    {
        return count;
    }


    private class Node
    {
        String textLine;
        Node next;
        Node prev;

        public Node()
        {
            textLine = null;
            next = null;
            prev = null;
        }

        public Node (String line)
        {
            textLine = (line);
            next = null;
            prev = null;
        }

        public Node (String line, Node node1, Node node2)
        {
            textLine = line;
            prev = node1;
            next = node2;
        }

        public String getLine()
        {
            return textLine;
        }

        public Node getNext()
        {
            return next;
        }

        public Node getPrev()
        {
            return prev;
        }

        public void setLine(String line)
        {
            textLine = line;
        }

        public void setNext(Node nextNode)
        {
            next = nextNode;
        }

        public void setPrev(Node prevNode)
        {
            prev = prevNode;
        }
    }
}

Answer 1

如果空MyLinked List中有一个节点，即使它只是一个null prev，next和数据，也可能会让人感到困惑，所以你需要小心那个MyLinkedList构造函数 - 如果只读head = null;，它可能会容易得多。

如果MyLinked List有一个tail节点，也可以将链接保存到最后，以找到add应放置新Node的位置，这将非常有用}。

之后，我认为问题在于你没有注意到你需要两个循环：一个用于遍历列表以跟踪未排序节点的起始位置，一个用于从中找到最小节点。您还需要为swap编写Node方法，以便您可以编写类似于未经测试的伪代码的内容，它恰好看起来很像Java

for (index = head; index != null; index = index.getNext()) {
  min = index;
  for (test = min.getNext(); test != null; test = test.getNext) {
    if (test.getLine().compareTo(min.getLine()) < 0)
        min = test;
  }
  if (min != index) {
    swap(index, min);
    index = min;
  }
}

和交换看起来大致相似

public void swap(Node other)
{
  Node temp;

  temp = next;
  next = other.getNext();
  other.setNext(temp);

  temp = prev;
  prev = other.getPrev();
  other.setPrev(temp);

  other.getNext().setPrev(this);
  other.getPrev().setNext(this);

  this.getNext().setPrev(other);
  this.getPrev().setNext(other);
}

再次注意这是完全未经测试的，甚至没有看过编译器。

请务必考虑特殊情况，例如列表为空或者只有一个元素，以及列表中只有一个节点未分类时。

我没有指出swap实际上比那复杂得多，我不能离开。我添加了几行来纠正要交换的节点之前和之后节点中的指针。您还需要考虑：

交换的任何一个节点是否都在列表的末尾，在这种情况下，列表中的head（如果有的话，tail）将需要更新而不是相邻节点中的指针。这很明显。
要交换的节点是否在列表中彼此相邻，如果应用常规算法，则会得到指向自身的节点。那不太明显。

家庭作业 - Java - 选择在我创建的双链表上排序

1 个答案: