标签: bubble-sort

我想知道冒泡排序的最佳情况是什么？例如,可能存在这样的情况,其中可能没有交换最后2次传球.我正在使用C语言编写程序.假设我有一个包含5个元素的数组,并且我将元素作为1 2 5 4 3,那么在最后2个传递中没有变化？

我和朋友讨论过以下两种算法的真实冒泡类型,以及哪一种更好,没有提到哪一种是我的,我只是想听听你对这两个算法的两个问题的答案(用C++)

1 - 哪一个是真正的冒泡排序？
2哪个更好？

这是两种算法:

// Number one :
void BubbleSort(int Arr[], int size)
{   for (int i=0;i<size-1;i++)
        for (int j=i+1;j<size;j++)
            if (Arr[i]>Arr[j])
            {   int temp = Arr[i];
                Arr[i] = Arr[j];
                Arr[j] = temp;
}           }

// Number two : 
void BubbleSort(int Arr[], int size)
{   for (int i=0;i<size-1;i++)
        for (int j=0;j<size-1;j++)
            if (Arr[j]>Arr[j+1])
            {   int temp = Arr[j];
                Arr[j] = Arr[j+1];
                Arr[j+1] = temp;
}           }

我在C中使用OpenMP 实现了并行冒泡排序算法(Odd-Even转置排序).然而,在我测试之后,它比串行版本慢了(大约10%),尽管我有一个4核处理器(2个真正的x 2,因为英特尔超线程).我已经检查了核心是否实际使用,我可以在运行程序时以100%的比例看到它们.因此我认为我在实现算法时犯了一个错误.

我使用linux与内核2.6.38-8-generic.

这是我编译的方式:

gcc -o bubble-sort bubble-sort.c -Wall -fopenmp 要么

gcc -o bubble-sort bubble-sort.c -Wall -fopenmp 对于串行版本

这就是我的运行方式:

./bubble-sort < in_10000 > out_10000

#include <omp.h>
#include <stdio.h>
#include <time.h>
#include <stdlib.h>

int main()
{
        int i, n, tmp, *x, changes;
        int chunk;
        scanf("%d ", &n);
        chunk = n / 4;
        x = (int*) malloc(n * sizeof(int));
        for(i = 0; i < n; ++i)
            scanf("%d ", &x[i]);
    changes = 1;
    int nr = 0;
    while(changes)
    {
    #pragma …

我有一个冒泡版本:

int i, j;  

for i from n downto 1 
{
    for j from 1 to i-1 
    { 
        if (A[j] > A[j+1])
            swap(A[j], A[j+1]) 
    } 
}

我想使用上面版本的冒泡排序来计算预期的掉期数量.我使用的方法如下所示:

// 0 based index

float ans = 0.0;

for ( int i = 0; i < n-1; i++ )
{
    for ( int j = i+1; j < n; j++ ) {

        ans += getprob( a[i], a[j]); // computes probability that a[i]>a[j].
    }
}

我是正确的方式还是我错过了什么？

我将开始新的问题.我昨天提出了这个问题,想知道我的程序中有什么问题.下面给出了该程序,你们人们指出,以下程序只进行一次排序,并且还需要一个外部循环.那时我很好,好.但是当我查看程序时,我感到困惑,需要问为什么我们需要外部循环以及排序,因为只有一个循环可以进行排序(在我看来).首先看下面的程序然后我在程序结束时提出我的逻辑.

#include <iostream.h>
#include <conio.h>

using namespace std;

main()
{

    int number[10];
    int temp = 0;
    int i = 0;

    cout << "Please enter any ten numbers to sort one by one: "
         << "\n";

    for (i = 0; i < 10; i++)
    {
        cin >> number[i];
    }

    i = 0;

    for (i = 0; i < 9; i++)
    {

        if (number[i] > number[i + 1])
        {
            temp = number[i + 1];
            number[i + 1] = number[i];
            number[i] = temp; …

我的代码有问题,我已经创建了一个单独链接列表类,您可以在其中添加,删除,修改,合并等...但是,我正在尝试一个简单的冒泡排序,并遇到了列表是的问题没有正确排序.这里有一些注意事项:

• 它是链表的自定义实现
• 单链表的节点包含两件事:一个CustomerFile对象,包含客户的所有数据,一个'next'节点指向列表中的下一个项目
• 列表按存储在每个节点的客户文件中的姓氏以升序(AZ)排序
• 添加记录功能将节点插入列表中的正确位置,以便最初不需要对列表进行排序 - 但是如果更改姓氏,作为程序的一部分,则需要再次对列表进行排序
• 我宁愿不创建一个新列表并重新使用该列表上的插入记录来创建一个新列表,因为这是内存密集型的,我的任务是尽可能高效
• 链接列表的结构不能改变 - 它已经决定,我太过分了,无法改变像数组这样的东西
• 该列表有一个头节点,它有下一个项目,但没有尾节点.它有一个指定的NULL下一个指针,用于指示列表的结尾

代码

public static void sortList()
{
    if (isEmpty() == true)
    {
        System.out.println("Cannot sort - the list is empty");
    }
    else if (getHead().getNext() == null)
    {
        System.out.println("List sorted");
    }
    else
    {
        Node current = getHead().getNext();
        CustomerFile tempDat;
        boolean swapDone = true;
        while (swapDone)
        {
            current = getHead().getNext();
            swapDone = false;
            while (current != null)
            {
                if (current.getNext() != null &&
                    current.getData().getSurname().compareTo(
                        current.getNext().getData().getSurname()) >0)
                {
                    tempDat = current.getData();
                    current.setData(current.getNext().getData());
                    current.getNext().setData(tempDat); …

def bubble_sort_by nums
  do_it_again = false
  nums[0...-1].each_with_index do |item, index|
    if yield(nums[index], nums[index + 1]) > 0
      nums[index], nums[index + 1] = nums[index + 1], nums[index]
      do_it_again = true
    end
  end
  bubble_sort_by nums if do_it_again
  nums
end

bubble_sort_by(["hi","hello","hey"]) do |left,right|
  right.length - left.length
end

程序基于块进行冒泡排序。在这种情况下，块按长度排序。所以，我得到一个本地跳转错误。花了我一点，但我想通了。当我递归调用该方法时，我没有给它块。但是我该怎么做呢？

我是编程的新手，我才刚刚开始学习R语言。我正在尝试进行冒泡排序，但是显示以下错误消息。谁能帮我解决问题？

x <-sample(1:100,10)
n <- length(x)
example <- function(x)
{
  for (i in 1:n-1)
  {
   while (x[i] > x[i+1])
      {
      temp <- x[i+1]
      x[i+1] <- x[i]
      x[i] <- temp
      }
  i <- i+1
  }
}

example(x)

while（x [i]> x [i + 1]）中的错误{{参数长度为零

我正在编写冒泡排序代码，作为 Ruby 初学者课程的一部分。我知道这 (array.length - 1).times do |i|是不好的做法，因为我不需要每次都跑到数组的末尾。（在我的例子中，[5,4,3,2,1] 5 在第一次运行时移到最后，在第二次结束时 4 移动到正确的位置，等等，所以没有必要再次检查这些数字）：

def bubble_sort(array)
  (array.length - 1).times do
    (array.length - 1).times do |i|
      array[i], array[i+1] = array[i+1], array[i] if array[i] > array[i+1]
    end 
  end
end

bubble_sort([5,4,3,2,1])

有没有一种巧妙的方法来告诉该方法每次检查少一个数组元素？

我正在写一个递归代码到冒泡排序(通过交换从最小到最大)
我有一个代码只进行一次冒泡排序

(define (bubble-up L)  
   (if (null? (cdr L))  
     L   
  (if (< (car L) (cadr L))  
(cons (car L) (bubble-up (cdr L)))  
(cons (cadr L) (bubble-up (cons (car L) (cddr L))))  
  )
 )  

如果我在这段代码中放入一个列表,它会返回
EX 末尾最大数字的列表..(起泡'(8 9 4 2 6 7)) - >'(8 4 2 6 7 9)

现在我正在尝试编写代码来执行(冒泡L)N次(列表中的整数数)
我有这样的代码:

  (define (bubble-sort-aux N L)   
    (cond ((= N 1) (bubble-up L))  
       (else (bubble-sort-aux (- N 1) L)  
  (bubble-up L))))  
(bubble-sort-aux 6 (list 8 9 4 2 6 7))  -> ' (8 …