Question

我已经工作了几个小时，试图按字母顺序排列字符串的链表（类似字典）。给定的字符串仅为小写。例如，输入：“hello my name is albert”将在列表中排序为：节点1：albert，节点2：你好，节点3：是，等。

我的代码到目前为止读取了一个字符串，如上例所示，并将其作为节点插入 - 无序。

我在网上搜索了按字母顺序对链接列表进行排序并获得良好性能的方法，我发现合并排序非常有用。我已使用 compareTo（）将合并排序更改为字符串，但我的代码在以下行中返回nullPointerException错误：

if(firstList._word.compareTo(secondList._word) < 0){

我正在寻找帮助来修复以下代码或按字母顺序排序链表的其他方式（不使用Collection.sort）

我的完整代码是（在尝试添加合并排序以使用我的代码之后）：

public class TextList
{
    public WordNode _head;

    public TextList() 
    {
    _head = null;
    }

    public TextList (String text)
    {
        this._head = new WordNode();
        int lastIndex = 0;
        boolean foundSpace = false;
        String newString;
        WordNode prev,next;
        if (text.length() == 0) {
            this._head._word = null;
            this._head._next = null;
        }
        else {
        for (int i=0;i<text.length();i++)
        {
                if (text.charAt(i) == ' ') {
               newString = text.substring(lastIndex,i);
               insertNode(newString);
               // Update indexes
                lastIndex = i;
                // set to true when the string has a space
                foundSpace = true;  
        }
    }
        if (!foundSpace) {
            //If we didnt find any space, set the given word
            _head.setWord(text);
            _head.setNext(null);

        }
        else {
            //Insert last word
            String lastString = text.substring(lastIndex,text.length());
            WordNode lastNode = new WordNode(_head._word,_head._next);
            _head.setNext(new WordNode(lastString,lastNode));

        }

        sortList(_head);

    }
}

      private void insertNode(String word)
      {
      //Create a new node and put the curret node in it
      WordNode newWord = new WordNode(_head._word,_head.getNext());
      //Set the new information in the head
      _head._word = word;
      _head.setNext(newWord);
    }

private WordNode sortList(WordNode start) {
        if (start == null || start._next == null) return start;
        WordNode fast = start;
        WordNode slow = start;
        // get in middle of the list :
        while (fast._next!= null && fast._next._next !=null){
            slow = slow._next; fast = fast._next._next;
        }
        fast = slow._next;
        slow._next=null;
        return mergeSortedList(sortList(start),sortList(fast));
        }

        private WordNode mergeSortedList(WordNode firstList,WordNode secondList){
            WordNode returnNode = new WordNode("",null);
            WordNode trackingPointer = returnNode;
            while(firstList!=null && secondList!=null){
                if(firstList._word.compareTo(secondList._word) < 0){
                    trackingPointer._next = firstList; firstList=firstList._next;
                }
                else {
                    trackingPointer._next = secondList; secondList=secondList._next
                    ;}
                trackingPointer = trackingPointer._next;
            }
            if (firstList!=null) trackingPointer._next = firstList;
            else if (secondList!=null) trackingPointer._next = secondList;
            return returnNode._next;
            }

        public String toString() {
            String result = "";
            while(_head.getNext() != null){
                _head = _head.getNext();
                result += _head._word + ", ";
            }
            return "List: " + result;
}


    public static void main(String[] args) {
        TextList str = new TextList("a b c d e a b");
        System.out.println(str.toString());
    }

}

Answer 1

在过去，我已经制作了一种方法，可以在数组中按字母顺序对字符串进行排序作为学校硬件，所以这就是：

    private void sortStringsAlphabetically(){
    for (int all = 0; all < names.length; all++) {
        for (int i = all + 1; i < names.length; i++) {
            if (names[all].compareTo(names[i]) > 0) {
                String tmp = names[i];
                names[i] = names[all];
                names[all] = tmp;
            }
        }
    }
}

这段代码适用于数组，特别适用于名称数组。您可以调整它以使用列表，这非常简单，特别是如果我们考虑List接口及其所有实现中的各种方法。

干杯。

Answer 2

如果你不想拥有一个巨大的代码来获取单词的每个第一个字母并对其进行排序，那么使用Collection.sort（）进行处理

我不知道Collection.sort（）上的问题是什么，所以使用它

这是一个简短的代码，完全符合您的要求：

String test = "hello my name is albert";
test = test.replaceAll(" ", "\n");
String[] te = test.split("\n");
List<String> stlist = new ArrayList<String>();
for(String st : te) {
    stlist.add(st);
}
Collections.sort(stlist);

Answer 3

关于NPE，你说这可能是因为你首先在头部有一个空字符串，并继续在插入方法中添加它。

this._head = new WordNode();

此外，添加最后一个元素也不合适。只需重复使用下面的插入方法

insertNode(text.substring(lastIndex,text.length()));

当您将字符串转换为有衬里的列表时，这些是我认为有问题的

您可以使用以下代码处理第一个空值

private void insertNode(String word) {
    if (this._head == null) {
        this._head = new WordNode(word, null);
    } else {
        WordNode newWord = new WordNode(_head._word, _head.getNext());
        _head._word = word;
        _head.setNext(newWord);
    }
}

按字母顺序排序java链表（类似字典）

3 个答案: