Java 使用合并排序对双链接列表进行排序
我在互联网上找到了这段代码,它是针对数组的,我想把它改成双链表(而不是索引,我们应该使用指针)你能帮我怎么改变合并方法吗(我自己改变了排序方法)这也不是我的家庭工作,我喜欢使用链表Java 使用合并排序对双链接列表进行排序,java,algorithm,sorting,linked-list,mergesort,Java,Algorithm,Sorting,Linked List,Mergesort,我在互联网上找到了这段代码,它是针对数组的,我想把它改成双链表(而不是索引,我们应该使用指针)你能帮我怎么改变合并方法吗(我自己改变了排序方法)这也不是我的家庭工作,我喜欢使用链表 public class MergeSort { private DoublyLinkedList LocalDoublyLinkedList; public MergeSort(DoublyLinkedList list) { LocalDoublyLinkedList = list; } publ
public class MergeSort {
private DoublyLinkedList LocalDoublyLinkedList;
public MergeSort(DoublyLinkedList list) {
LocalDoublyLinkedList = list;
}
public void sort() {
if (LocalDoublyLinkedList.size() <= 1) {
return;
}
DoublyLinkedList listOne = new DoublyLinkedList();
DoublyLinkedList listTwo = new DoublyLinkedList();
for (int x = 0; x < (LocalDoublyLinkedList.size() / 2); x++) {
listOne.add(x, LocalDoublyLinkedList.getValue(x));
}
for (int x = (LocalDoublyLinkedList.size() / 2) + 1; x < LocalDoublyLinkedList.size`(); x++) {`
listTwo.add(x, LocalDoublyLinkedList.getValue(x));
}
//Split the DoublyLinkedList again
MergeSort sort1 = new MergeSort(listOne);
MergeSort sort2 = new MergeSort(listTwo);
sort1.sort();
sort2.sort();
merge(listOne, listTwo);
}
private void merge(DoublyLinkedList a, DoublyLinkedList b) {
int x = 0;
int y = 0;
int z = 0;
while (x < first.length && y < second.length) {
if (first[x] < second[y]) {
a[z] = first[x];
x++;
} else {
a[z] = second[y];
y++;
}
z++;
}
//copy remaining elements to the tail of a[];
for (int i = x; i < first.length; i++) {
a[z] = first[i];
z++;
}
for (int i = y; i < second.length; i++) {
a[z] = second[i];
z++;
}
}
}
公共类合并排序{
私有双链接列表本地双链接列表;
公共合并排序(双链接列表){
LocalDoublyLinkedList=列表;
}
公共无效排序(){
if(LocalDoublyLinkedList.size()这取决于DoublyLinkedList是什么-它是一个具体的用户定义类型,还是一个链接列表类型的别名
在第一种情况下,应该在其中定义索引get/set方法和/或迭代器,这使得任务变得简单
在后一种情况下,为什么不使用标准
在列表
界面中,操作可以如下实现:
<T> List<T> merge(List<T> first, List<T> second, List<T> merged) {
if (first.isEmpty())
merged.adAll(second);
else if (second.isEmpty())
merged.adAll(first);
else {
Iterator<T> firstIter = first.iterator();
Iterator<T> secondIter = second.iterator();
T firstElem = firstIter.next();
T secondElem = secondIter.next();
do {
if (firstElem < secondElem) {
merged.add(firstElem);
firstElem = firstIter.hasNext() ? firstIter.next() : null;
} else {
merged.add(secondElem);
secondElem = secondIter.hasNext() ? secondIter.next() : null;
}
} while (firstIter.hasNext() && secondIter.hasNext());
//copy remaining elements to the tail of merged
if (firstElem != null)
merged.add(firstElem);
if (secondElem != null)
merged.add(secondElem);
while (firstIter.hasNext()) {
merged.add(firstIter.next());
}
while (secondIter.hasNext()) {
merged.add(secondIter.next());
}
}
}
while (i < in.size/2){
listOne.addLast( in.remove(in.first()) );
i++
}
while(!in.isEmptly){
listTwo.addLast( in.remove(in.first()) );
}
列表合并(列表第一,列表第二,列表合并){
if(first.isEmpty())
阿达尔(第二);
else if(second.isEmpty())
阿达尔(第一);
否则{
迭代器firstIter=first.Iterator();
迭代器secondIter=second.Iterator();
T firstElem=firstIter.next();
T secondElem=secondIter.next();
做{
如果(第一个元素<第二个元素){
合并。添加(firstElem);
firstElem=firstIter.hasNext()?firstIter.next():null;
}否则{
合并。添加(第二元素);
secondElem=secondIter.hasNext()?secondIter.next():null;
}
}while(firstIter.hasNext()&&secondIter.hasNext());
//将其余图元复制到合并的尾部
if(firstElem!=null)
合并。添加(firstElem);
if(secondElem!=null)
合并。添加(第二元素);
while(firstIter.hasNext()){
merged.add(firstIter.next());
}
while(secondIter.hasNext()){
merged.add(secondIter.next());
}
}
}
这个实现比使用数组要繁琐一些,主要是因为迭代器被“消耗”通过next
操作,因此必须记录每个列表中的当前项。使用get
,代码会更简单,与数组解决方案非常类似,但是对于大列表,它会慢得多,正如@sepp2k指出的
还有几个注意事项:
- Java的传统是使用小写变量名,因此
localDoublyLinkedList
- Java没有指针,只有引用
合并排序需要经常拆分列表。迭代到LinkedList的中间不是可以对其执行的最昂贵的操作吗(好吧,缺少排序)?我可以看到合并步骤工作得很好(您在两个链接列表上向前迭代),但我不确定在没有O(1)拆分操作的情况下,这个实现是否值得费心
改善效果追踪
正如我所指出的,当您在合并阶段已经在做O(n)件事情时,O(n)拆分操作并不会增加太多的复杂性。然而,您仍然会像现在这样在进行迭代时遇到麻烦(不使用迭代器
,而是在随机访问特性较差的列表上使用get
)
<>我在调试其他问题时感到厌烦,所以写了我认为是这个算法的一个很好的java实现。我逐字地跟随维基百科的伪代码,并在一些泛型和打印语句中喷洒。如果你有任何问题或顾虑,只要问一下。< /P>
import java.util.List;
import java.util.LinkedList;
/**
* This class implements the mergesort operation, trying to stay
* as close as possible to the implementation described on the
* Wikipedia page for the algorithm. It is meant to work well
* even on lists with non-constant random-access performance (i.e.
* LinkedList), but assumes that {@code size()} and {@code get(0)}
* are both constant-time.
*
* @author jasonmp85
* @see <a href="http://en.wikipedia.org/wiki/Merge_sort">Merge sort</a>
*/
public class MergeSort {
/**
* Keeps track of the call depth for printing purposes
*/
private static int depth = 0;
/**
* Creates a list of 10 random Longs and sorts it
* using {@link #sort(List)}.
*
* Prints out the original list and the result.
*
*/
public static void main(String[] args) {
LinkedList<Long> list = new LinkedList<Long>();
for(int i = 0; i < 10; i++) {
list.add((long)(Math.random() * 100));
}
System.out.println("ORIGINAL LIST\n" +
"=================\n" +
list + "\n");
List<Long> sorted = sort(list);
System.out.println("\nFINAL LIST\n" +
"=================\n" +
sorted + "\n");
}
/**
* Performs a merge sort of the items in {@code list} and returns a
* new List.
*
* Does not make any calls to {@code List.get()} or {@code List.set()}.
*
* Prints out the steps, indented based on call depth.
*
* @param list the list to sort
*/
public static <T extends Comparable<T>> List<T> sort(List<T> list) {
depth++;
String tabs = getTabs();
System.out.println(tabs + "Sorting: " + list);
if(list.size() <= 1) {
depth--;
return list;
}
List<T> left = new LinkedList<T>();
List<T> right = new LinkedList<T>();
List<T> result = new LinkedList<T>();
int middle = list.size() / 2;
int added = 0;
for(T item: list) {
if(added++ < middle)
left.add(item);
else
right.add(item);
}
left = sort(left);
right = sort(right);
result = merge(left, right);
System.out.println(tabs + "Sorted to: " + result);
depth--;
return result;
}
/**
* Performs the oh-so-important merge step. Merges {@code left}
* and {@code right} into a new list, which is returned.
*
* @param left the left list
* @param right the right list
* @return a sorted version of the two lists' items
*/
private static <T extends Comparable<T>> List<T> merge(List<T> left,
List<T> right) {
String tabs = getTabs();
System.out.println(tabs + "Merging: " + left + " & " + right);
List<T> result = new LinkedList<T>();
while(left.size() > 0 && right.size() > 0) {
if(left.get(0).compareTo(right.get(0)) < 0)
result.add(left.remove(0));
else
result.add(right.remove(0));
}
if(left.size() > 0)
result.addAll(left);
else
result.addAll(right);
return result;
}
/**
* Returns a number of tabs based on the current call depth.
*
*/
private static String getTabs() {
StringBuffer sb = new StringBuffer("");
for(int i = 0; i < depth; i++)
sb.append('\t');
return sb.toString();
}
}
import java.util.List;
导入java.util.LinkedList;
/**
*此类实现mergesort操作,试图保持
*尽可能接近上描述的实现
*Wikipedia页面的算法。这是为了工作良好
*即使在具有非恒定随机访问性能的列表上(即。
*LinkedList),但假定{@code size()}和{@code get(0)}
*它们都是固定时间。
*
*@author jasonmp85
*@见
*/
公共类合并排序{
/**
*跟踪呼叫深度以便于打印
*/
私有静态int深度=0;
/**
*创建一个包含10个随机长度的列表并对其进行排序
*使用{@link#sort(List)}。
*
*打印出原始列表和结果。
*
*/
公共静态void main(字符串[]args){
LinkedList=新建LinkedList();
对于(int i=0;i<10;i++){
添加((长)(Math.random()*100));
}
System.out.println(“原始列表\n”+
“=========================\n”+
列表+“\n”);
列表排序=排序(列表);
System.out.println(“\n最终列表\n”+
“=========================\n”+
已排序+“\n”);
}
/**
*对{@code list}中的项执行合并排序,并返回
*新名单。
*
*不调用{@code List.get()}或{@code List.set()}。
*
*打印步骤,根据调用深度缩进。
*
*@param列出要排序的列表
*/
公共静态列表排序(列表){
深度++;
String tabs=getTabs();
系统输出打印项次(制表符+排序:+列表);
首先,如果(list.size(),则在处理链接列表时不能使用索引。请执行以下操作:
<T> List<T> merge(List<T> first, List<T> second, List<T> merged) {
if (first.isEmpty())
merged.adAll(second);
else if (second.isEmpty())
merged.adAll(first);
else {
Iterator<T> firstIter = first.iterator();
Iterator<T> secondIter = second.iterator();
T firstElem = firstIter.next();
T secondElem = secondIter.next();
do {
if (firstElem < secondElem) {
merged.add(firstElem);
firstElem = firstIter.hasNext() ? firstIter.next() : null;
} else {
merged.add(secondElem);
secondElem = secondIter.hasNext() ? secondIter.next() : null;
}
} while (firstIter.hasNext() && secondIter.hasNext());
//copy remaining elements to the tail of merged
if (firstElem != null)
merged.add(firstElem);
if (secondElem != null)
merged.add(secondElem);
while (firstIter.hasNext()) {
merged.add(firstIter.next());
}
while (secondIter.hasNext()) {
merged.add(secondIter.next());
}
}
}
while (i < in.size/2){
listOne.addLast( in.remove(in.first()) );
i++
}
while(!in.isEmptly){
listTwo.addLast( in.remove(in.first()) );
}
这样的话仍然是O(n log n)我昨天遇到了这个问题。下面是一些想法
排序双链接列表
不同于排序数组
,因为不能对列表中的任意项进行基于索引的引用。相反,您需要在每个递归步骤中记住这些项,然后将它们传递给合并函数。对于每个递归步骤,您只需要记住e每个列表的第一项各占一半。如果你不记得这些项,你很快就会得到索引,b
public ListElement mergesort(ListElement first, int length) {
if(length > 1) {
ListElement second = first;
for(int i=0; i<length/2; i++) {
second = second.next;
}
first = mergesort(first, length/2);
second = mergesort(second, (length+1)/2);
return merge(first, second, length);
} else {
return first;
}
}
public ListElement merge(ListElement first, ListElement second, int length) {
ListElement result = first.prev; //remember the beginning of the new list will begin after its merged
int right = 0;
for(int i=0; i<length; i++) {
if(first.getKey() <= second.getKey()) {
if(first.next == second) break; //end of first list and all items in the second list are already sorted, thus break
first = first.next;
} else {
if(right==(length+1)/2)
break; //we have merged all elements of the right list into the first list, thus break
if(second == result) result = result.prev; //special case that we are mergin the last element then the result element moves one step back.
ListElement nextSecond = second.next;
//remove second
second.prev.next = second.next;
second.next.prev = second.prev;
//insert second behind first.prev
second.prev = first.prev;
first.prev.next = second;
//insert second before first
second.next = first;
first.prev = second;
//move on to the next item in the second list
second = nextSecond;
right++;
}
}
return result.next; //return the beginning of the merged list
}
1.000.000 Items: 466ms
8.300.000 Items: 5144ms
1.000.000 Items: 696ms
8.300.000 Items: 8131ms