链表上的冒泡排序实现

我必须在链表而不是数组上实现BubbleSort算法。我是java的新手，所以我真的不知道如何把它写进代码。但我还是尝试了一下，结果如下:

SinglyNode.java

public class SinglyNode
{
public Object names;
public SinglyNode next;
public SinglyNode (Object name1)
{
    names = name1;
}
public SinglyNode (Object name2, SinglyNode next1)
{
    names = name2;
    next = next1;
}
Object getObject()
{
    return names;
}
SinglyNode getNext()
{
    return next;
}
void displayLink()
{
    System.out.print("{" + names + "}");
}
}

LinkList.java我认为我的问题是在这里的方法。我不知道如何实现BubbleSort，以便它按升序对对象名称进行排序。

public class LinkList
{
SinglyNode first;
public boolean isEmpty()
{
    return (first == null);
}
void insertFirst(Object name1)
{
    SinglyNode newNode1 = new SinglyNode(name1);
    newNode1.next = first;
    first = newNode1;
}
SinglyNode delete(Object name2)
{
    SinglyNode temp = first;
    first = first.next;
    return temp;
}
void display()
{
    System.out.print("LIST: n");
    SinglyNode current = first;
    while(current != null)
    {
        current.displayLink(); // print data
        current = current.next; // move to next link
    }
    System.out.println("n");
}
//////////////////////////////////////////////////////    
void bubbleSort()
{ 
    Object n = first;
    Object temp = first;
    if (na.compareTo(first) < first.compareTo(na))
    {
        temp = na.compareTo(first);
    } else {
        temp = first.compareTo(na);
    }
    System.out.println(temp);
}
private void swap(Object one, Object two)
{ 
    Object temp = one.names;
    one.names = two.names;
    two.names = temp; 
}
}

SinglyLinkList.java

public class SinglyLinkList
{
public static void main (String args[])
{
    LinkList list = new LinkList();
    list.insertFirst("Squirtle");
    list.insertFirst("Bulbasaur");
    list.insertFirst("Charmander");
    list.insertFirst("Pichu");
    list.insertFirst("Ghastly");
    list.insertFirst("Mewtwo");
    list.insertFirst("Dialga");
    list.display();
    list.bubbleSort();
    list.display();
}
}

在您的列表中，它将有助于有一个大小字段，以存储列表中元素的数量。还要创建类SinglyNode implement Comparable，以便compareTo方法按照您的意愿行事。在Single LinkedList中，两个元素的就地交换实际上非常复杂，而且性能非常差!

public void bubbleSort
{
  for (int i = 0; i < size; i++)
  {
    for (int j = i; j < size; j++)
    {
       if (elementAt(j).compareTo(elementAt(j+1)) > 0)
       {
          swap(j, j + 1);
       }
    }
  }
}
public SinglyNode elementAt(int index)
{
   SinglyNode temp = first;
   for (int i = 0, i < index; i++)
   {
      temp = temp.getNext();
   }
   return temp;
}
public void swap(int firstIndex, int secondIndex)
{
   SinglyNode secondNext = elementAt(secondIndex).getNext();       
   SinglyNode second = elementAt(secondIndex);
   SinglyNode first = elementAt(first);
   SinglyNode firstPrevious = elementAt(first - 1);

   firstPrevious.setNext(second);
   first.setNext(secondNext);
   second.setNext(first);
}

您需要在SinglyNode中实现Comparable接口，并在实现中使用字符串比较方法。比如:

public void compareTo(SinglyNode node){
    return this.names.toString.compareTo(node.getNames().toString());
}

或者最好是this.names.compareTo(node.getNames());

但是，对于那些通配符对象，我将使用Comparable接口，而不是仅仅使用Object类。

由于这是家庭作业，我将给出一个提示，而不是直接解决。冒泡排序可以抽象为这两个操作:对集合进行迭代和交换元素。对于数组或链表，这些操作的实现方式不同，但算法是相同的。你在display中有迭代，现在你需要实现交换然后做(非常抽象的伪代码:

)

iterate {
 iterate {
  if el.Compare(elNext) > 0 {
    swap(el, el.Next);
  }
 }
}

1)你需要实现Comparable

2)您还需要在bubblesort中使用swap方法。目前你没有使用这个，它只会比较两个对象，而不会在实际列表中交换它们。

使用可比

教程

示例链表冒泡排序，它不使用elementAt()函数模拟随机访问，而是通过节点之间的链接进行操作，因此时间复杂度为O(n^2)而不是更糟。"end"用于跟踪列表末尾排序节点的起始位置。我使用了问题中的示例代码，没有费心将类更改为comparable，而是使用toString()代替比较。我使用了一个虚拟节点来简化代码。

void bubbleSort()
{ 
    if(first == null)
        return;
    SinglyNode dmy = new SinglyNode("dummy");  // dummy node
    dmy.next = first;
    // end == null or first sorted node at end of list
    SinglyNode end = null;
    int swap;
    do{
        swap = 0;
        SinglyNode prv = dmy;           // previous node
        while(true){
            SinglyNode cur = prv.next;  // current node
            SinglyNode nxt = cur.next;  // next node
            if(nxt == end){             // if at end node
                end = cur;              //  update end = cur
                break;                  //  and break
            }
            // if out of order, swap nodes
            if(cur.names.toString().compareTo(nxt.names.toString()) > 0){
                cur.next = nxt.next;
                nxt.next = cur;
                prv.next = nxt;
                swap = 1;
            }
            prv = prv.next;             // advance to next node
        }
    }while(swap != 0);                  // repeat untl no swaps
    first = dmy.next;                   // update first
}

对于冒泡排序，两个循环必须从0开始。该算法的某些版本从外部循环所在的位置开始内循环。这样做会导致某些数据出现问题。

如果……您有一个包含以下内容的数组，您希望对其进行排序:

23日,1,2,3,4,5

如果两个循环都从0开始，则排序数组将为:1,2,3,3,4,5,23

但是如果内部循环从j=i开始，则排序数组将是23,1,2,3,3,4,5。这是因为在把23放到正确的位置之后，内部循环从第一个元素(将是3)开始继续前进，并且再也不知道该把3放在哪里了

相关内容

最新更新

热门标签：