Question

我在名为WordNode的类中有一个链表，它包含以下属性：

String _word; WordNode _next;

我有另一个类，它是“实际列表”，只保存对列表头部的引用，该类称为TextList，它接收String并且应该放入每个单词列出的String已分类。例如，对于句子：

coding in Java is cool.

链表如下：

coding >>> cool >>> Java >>> in >>> is.

箭头就像指向列表中下一个节点的指针。

我想首先把所有单词放在一个链表（TextList类）中，然后创建一个MERGE SORT来对链表中的单词进行排序。

我要做的是采用拆分方法将列表拆分为两个列表：“odd”和“evens”，这些是这些方法：

private TextList splitOdds(){
    boolean flag=true;
    TextList odds=new TextList();
    WordNode o=null;
    WordNode ptr=_head;
    while (ptr.getNext()!=null){
        if(flag)
            o=new WordNode(ptr.getWord(),o);
        ptr=ptr.getNext();
         flag=!flag;
    }
    odds._head=o;;
    return odds;
}

private TextList splitEvens(){
    boolean flag=true; 
    TextList evens=new TextList();
    WordNode e=null;
    WordNode ptr=this._head.getNext();
    while (ptr!=null){
        if(flag)
            e=new WordNode(ptr.getWord(),e);
        ptr=ptr.getNext();
        flag=!flag;
    }
    evens._head=e;
    return evens;
}

分裂确实有效。

但我不知道从哪里继续。我想以递归方式调用split方法并拆分列表，直到它是一个或两个节点的列表，但我无法弄清楚如何做到这一点。

编辑：不能使用第三类，由练习禁止。还持有TextList的长度。只保留每个单词的次数由WordNode类上的属性显示。

Answer 1

恕我直言，这个概念是错误的。你不需要在这里使用merge-sort。尝试搜索PriorityQueue或实际BinaryHeap以解决此任务。其次，链表上的合并排序不是一个好主意，因为它根本不会有效。我认为你应该完全重写你的解决方案。

NB。只需实现操作YourLinkedList.getByIndex（）以获取方便，添加大小属性来保存链表中的项目数，然后再创建一个linkedList并执行自下而上的合并排序，就像使用简单数组一样。

结构：

public class Item {

    private String word;
    private Item next;

    public Item(String word) {
        this.word = word;
    }

    public Item getNext() {
        return next;
    }
    public void setNext(Item next) {
        this.next = next;
    }
    public String getWord() {
        return word;
    }
    public void setWord(String word) {
        this.word = word;
    }

}

链接列表：

public class LinkedList {

    private int size = 0;
    private Item first = null;  

    public void swapFragment(LinkedList list, int from, int to) {
        if (from >= 0 && to < size) {
            list.get(to-from).setNext(this.get(to+1));          
            if (from > 0) {
                this.get(from-1).setNext(list.get(0));
            } else {
                this.first = list.get(0);
            }
        }       
    }   
    public void addItem(String word) {
        if (first == null) {
            first = new Item(word);
        } else {
            Item item = first;
            while (item.getNext() != null) {
                item = item.getNext();
            }   
            item.setNext(new Item(word));
        }
        this.size++;
    }

    public Item get(int index) {
        if (index >= size) {
            return null;
        } else {
            Item item = first;
            for(int i = 1; i <= index; i++) {
                item = item.getNext();
            }
            return item;
        }
    }

    public int getSize() {
        return size;
    }
    public void setSize(int size) {
        this.size = size;
    }

    public String toString() {
        Item item = first;
        String message = null;
        if (item != null) {
            message = item.getWord() + " ";
        } else {
            return null;
        }
        while (item.getNext() != null) {
            item = item.getNext();
            message = message + item.getWord() + " ";
        }
        return message;
    }


}

合并排序：

public class ListMergeSort {

    public void sort(LinkedList list, int lo, int hi) {
        if (hi <= lo) {
            return;
        }
        int mid = lo + (hi-lo)/2;
        sort(list, lo, mid);
        sort(list, mid+1, hi);      
        merge(list, lo, hi, mid);       
    }

    private void merge(LinkedList list, int lo, int hi, int mid) {
        int i = lo;
        int j = mid+1;
        LinkedList newList = new LinkedList();
        for (int k = lo; k <= hi; k++) {
            if (i > mid) {
                newList.addItem(list.get(j).getWord());
                j++;
            } else if (j > hi) {
                newList.addItem(list.get(i).getWord());
                i++;
            } else if (list.get(i).getWord().compareTo(list.get(j).getWord()) < 0) {
                newList.addItem(list.get(i).getWord());
                i++;
            } else {
                newList.addItem(list.get(j).getWord());
                j++;
            }           
        }
        list.swapFragment(newList, lo, hi);
    }

}

字符串测试类：

import org.junit.*;

public class MergeTest {

    @Test
    public void testWords() {
        LinkedList list = new LinkedList();
        list.addItem("word");
        list.addItem("pipe");
        list.addItem("trainer");
        list.addItem("stark");
        list.addItem("33");
        list.addItem("dmitry");
        ListMergeSort lms = new ListMergeSort();
        lms.sort(list, 0, list.getSize()-1);        
    }

}

现在，您只需要创建一个接收字符串作为参数的类，使用String.split（）将其拆分，并将生成的单词添加到内部LinkedList数据结构中。然后使用合并排序对它们进行排序，然后得到结果。

Answer 2

这当然是假设您在每次插入或删除时保留列表的长度。您所要做的就是将列表分成两半，同时保留原始列表的头/根。在实现合并排序时，您甚至不需要任何中间列表。

    LinkedList LinkedList::split(){
            _Node_* p=head, *q=p;
            for(int i=0; i<len/2; i++){
                    q=p;
                    p=p->next;
            }
            LinkedList ret;
            ret.head=p;
            ret.len=len-len/2;
            len=len/2;
            q->next=NULL;
            return ret;
    }

合并排序与字符串

2 个答案: