Question

我想使用Mergesort算法对Java中的LinkedList进行排序。
我在互联网上研究了一种解决方案，但发现的算法对数组或自声明的LinkedList进行了排序。如前所述，我需要一种对标准java LinkedList（java.util.LinkedList）进行排序的算法。
除了研究之外，我还尝试自己实施一个，但我却没有能力。我能够创建“分隔”部分，但无法编写“征服”（按排序顺序合并）部分。
这是我的代码：

cmd.Parameters.AddWithValue("@PretE", Convert.ToSingle(tbPretE.Text))

有人可以帮助我创建'sortedMerge（）'方法吗？

Answer 1

Collections.sort（）方法对LinkedList进行排序。通过将LinkedList的内容复制到一个数组，对该数组进行排序并将该数组的内容复制回LinkedList来实现。您可以实现与Collections.sort（）方法相同的功能，并使用合并排序算法对数组进行排序。

下面，我详细介绍了我的步骤和正确的代码，这些代码使用合并排序算法对Java的标准LinkedList进行了排序。

步骤：

创建一个LinkedList'orginialList'
将“ originalList”转换为整数数组“ arr”
将“ arr”转换为int数组“ intArray”
使用合并排序算法对'intArray'进行排序
将已排序的“ intArray”转换回整数数组“ arr”（用于循环更改） 'arr'中的元素）
创建一个LinkedList'newList'
将“ arr”的元素添加到“ newList”（使用Arrays.asList（arr））

     public static class CollectionsSort {
         public static void main(String[] args) {
               LinkedList<Integer> originalList = new LinkedList<>();
               originalList.add(3);
               originalList.add(2);
               originalList.add(1);

               Integer[] arr = list.toArray(new Integer[list.size()]);
               int[] intArray = new int[arr.length];
               for (int i = 0; i < intArray.length; i++) {
                   intArray[i] = arr[i].intValue();
               }
               mergesort(intArray);
               for (int i = 0; i < arr.length; i++) {
                   arr[i] = new Integer(intArray[i]); 
               }
               LinkedList<Integer> newList = new LinkedList(Arrays.asList(arr));
               Iterator it = newList.iterator();
               while(it.hasNext()) {
                  System.out.print((int)(it.next()) + " ");
               }
         }

         public static int[] mergesort(int[] arr) {
               int low = 0;
               int high = arr.length-1;
               mergesort(arr, low, high);
               return arr;
         }

         public static void mergesort(int[] arr, int low, int high) {
               if (low == high) {
                   return;
               } else {
                   int middle = low + (high-low)/2;
                   mergesort(arr, low, middle);
                   mergesort(arr, middle+1, high);
                   merge(arr, low, middle, high);
               }
         }

         public static void merge(int[] arr, int low, int mid, int high) {
               int[] left = new int[mid-low+2];
               for (int i = low; i <= mid; i++) {
                   left[i-low] = arr[i];
               }
               left[mid-low+1] = Integer.MAX_VALUE;
               int[] right = new int[high-mid+1];
               for(int i = mid+1; i <= high; i++) {
                   right[i-mid-1] = arr[i];
               }
               right[high-mid] = Integer.MAX_VALUE;
               int i = 0, j = 0;
               for(int k = low; k <= high; k++) {
                   if(left[i] <= right[j]) {
                      arr[k] = left[i];
                      i++;
                   } else {
                      arr[k] = right[j];
                      j++;
                   }
               }
         }
     }

Answer 2

示例示例代码（包括main（）中的测试代码），用于Java LinkedList的自底向上合并排序，该排序使用列表的小数组（32）（与自顶向下将列表拆分和推入堆栈的方法相反））。由于Java LinkedList不具有与std :: list :: splice（）等效的C ++，该C ++等效于移动列表中的节点（或从列表到列表），因此将创建和删除节点和列表，从而增加了相当数量的高架。

package llsort;
import java.util.LinkedList;
import java.util.ListIterator;
import java.util.Random;

public class llsort {

    public static LinkedList<Integer> Merge(LinkedList<Integer> ll0, LinkedList<Integer> ll1){
        LinkedList<Integer> ll = new LinkedList<>();
        if(ll0.isEmpty())               // empty list check
            return (ll1);
        if(ll1.isEmpty())
            return (ll0);
        ListIterator <Integer> ll0i = ll0.listIterator(0);
        ListIterator <Integer> ll1i = ll1.listIterator(0);
        Integer e0;
        Integer e1;
        e0 = ll0i.next();               // merge lists
        e1 = ll1i.next();
        while(true){
            if(e0 <= e1){
                ll.add(e0);
                if(ll0i.hasNext()){
                    e0 = ll0i.next();
                    continue;
                }
                ll.add(e1);
                while(ll1i.hasNext())
                    ll.add(ll1i.next());
                break;
            }else{
                ll.add(e1);
                if(ll1i.hasNext()){
                    e1 = ll1i.next();
                    continue;
                }
                ll.add(e0);
                while(ll0i.hasNext())
                    ll.add(ll0i.next());
                break;
            }
        }
        return ll;
    }

    public static LinkedList<Integer> MergeSort(LinkedList<Integer> src){
        final int NUMLIST = 32; 
        LinkedList<Integer>[] all = new LinkedList[NUMLIST];
        LinkedList<Integer> ll;
        int i;
        // merge nodes into array
        ll = new LinkedList();
        while(!src.isEmpty()){
            ll.add(src.peek());
            src.remove();
            for(i = 0; i < NUMLIST && all[i]!= null; i++){
                ll = Merge(ll, all[i]);
                all[i] = null;
            }
            if(i == NUMLIST)
                i--;
            all[i] = ll;
            ll = new LinkedList();
        }
        // merge array into list
        ll = new LinkedList();
        for(i = 0; i < NUMLIST; i++)
            if(all[i] != null)   
                ll = Merge(ll, all[i]);
        return ll;        
    }

    public static void main(String[] args) {
        final int NUMELEM = 2*1024*1024; 
        LinkedList<Integer> ll = new LinkedList<>();
        Random r = new Random();
        for(int i = 0; i < NUMELEM; i++)
            ll.addLast(r.nextInt());
        long bgn, end;
        bgn = System.currentTimeMillis();
        ll = MergeSort(ll);
        end = System.currentTimeMillis();
        System.out.println("milliseconds " + (end-bgn));
        // check sort
        while(true){
            int i = ll.peek();
            ll.remove();
            if(ll.isEmpty())
                break;
            if(i > ll.peek()){
                System.out.println("error");
                break;
            }
        }
    }
}

使用Java的标准LinkedList搜索Mergesort算法

2 个答案: