Question

我正在使用以下内容实现一个Dobly Linked List： import java.util.LinkedList; ，带有冒号排序作为赋值。在对排序和链表进行研究之后，我了解到我不应该使用索引对链表进行冒泡排序，因为链表中不存在indeces，或者成功实现它太麻烦了。

所以，看了之后，我写了下面的代码，但我仍然不确定我是否走在正确的道路上。

我需要一些帮助来理解带有dobly链表的冒泡排序实现背后的逻辑。

另外，我需要一些保证，我是否能够有效地走上正确的道路，或者我是否完全错误地参与了这项编码工作。

 //This for loop sorts the smaller part of the bubble sort.
for(int i = 0; i < cars.size() - 1; i++)
    {        //This part creates the second "larger" part of the bubble sort.
        for(int j = i + 1; j < cars.size(); j++)
        {


//Did I do this part correctly?  This is where the swap and sort of the bubble sort        takes //place.
//Obviously, I am using the comparable interface, since I am using the compareTo method.
//

//with the bubblesort, all elements must be greater than zero because for the bubble          //sort, 0 is the smallest element in a set of integers.


            if(cars.get(i).getName().compareTo(cars.get(j).getName()) > 0)
            {
                CarName cari = cars.get(i);
                CarName CarNamej = cars.get(j);
                cars.remove(i);
                cars.add(i, carj);
                cars.remove(j);
                cars.add(j, cari);
                }
            }
        }
    }

我使用它在main方法中输出此方法以输出排序结果：

bubbleSort(cars);

我是否正确，或者我在所有代码中做了一些完全错误的事情？

Answer 1

看起来你并没有走上正确的道路。您需要完全消除索引的使用，而是使用节点引用。首先开发代码，仅在给定元素的引用时从列表中删除元素。然后开发代码以在列表中已经存在的元素之前将元素插入到列表中，仅给出对这两个元素的引用。然后，您可以在这两种方法之上构建排序算法。

例如，以下是删除元素的方法：

void remove(Element element) {
    element.previous().setNext(element.next());
    element.next().setPrevious(element.previous());
}

您应该了解双向链表如何工作，以了解为什么此代码应该适用于列表中间的元素。根据您对列表的表示方式，您可能需要测试最终条件（element.previous()和/或element.next()为null）。

Answer 2

考虑冒泡排序在常规阵列上的工作方式。一个简单的冒泡排序实现看起来像这样：

   for (int i = array.Length; i > 0; i--)
        {
            for (int j = 0; j < i-1; j++)
            {
                if (array[j] > array[j+1])
                {
                    int tmp = array[j];
                    array[j] = array[j+1];
                    array[j+1]=tmp;
                }
                DisplayElements(array);
            }
        }

不同之处在于，您不必使用temp int，而是必须将引用存储到List中的下一个和上一个Node

Answer 3

在数组或向量中，您可以通过索引访问存储的变量，即项目列表中的位置。

在链接列表中，您可以通过从一个项目跳到下一个项目来获取特定项目。

由于您在代码中使用get(i)，因此当您按列表中的位置编制索引时，显然使用数组或向量。所以，不幸......不幸的是，你的轨道完全错误......

一旦你越来越近，你的代码看起来会更像：

boolean changed = true;
while (changed) {  // keep going until we didn't make any more changes (not
                   // strictly the best condition for bubble sort, but it'll do)

    a = first;                  // grab first element
    b = a.next;                 // grab next element
    changed = false;
    while (b!=last) {           // run through all elements
        if (a.value>b.value) {  // compare the two elements; swap if out of order
            a.prev.next = b;    // update element before a to be followed by b
            b.next.prev = a;    // update element after b to be preceeded by a
            a.prev = b;         // b is now before a
            b.next = a;         // and a is after b
            changed = true;     // we made a change, so we're not done
        } else {
            a = b;              // if we didn't swap them, move to next pair
        }
        b = a.next;             // second half of next pair is next after a
    }
}

这只是为了给你一个粗略的想法。它绝不是完整的或没有bug。例如，如果您位于列表的最开头，则需要在行first中更新a.prev而不是a.prev.next = b。等等......但是嘿......不管怎么说，你不想让别人为你做功课吧？ ;）

基本上，在双向链表中，每个元素都知道如何到达下一个元素（a.next）和前一个元素（a.prev）。冒泡排序是排序这种链表的一个很好的选择，因为它只比较相邻的元素。否则，快速排序或合并排序或其组合可能会快得多，但它们确实需要对链接列表通常不提供的元素进行索引访问。

希望这有帮助。

BTW：Youtube有很多很酷的视频可以很好地解释各种各样的事情。

另一个更严重的问题：http://www.youtube.com/watch?v=P00xJgWzz2c

更不寻常的一个：http://www.youtube.com/watch?v=lyZQPjUT5B4（其中一个用于快速排序的音乐有更好的音乐：）

Answer 4

为什么不转换数组中的链表，对数组进行排序，然后将内容复制回链表。

使用冒泡排序实现双向链表

4 个答案: