Semplice bubble sort C#

int[] arr = {800,11,50,771,649,770,240, 9}; 

int temp = 0; 

for (int write = 0; write < arr.Length; write++) 
{ 
    for (int sort = 0; sort < arr.Length - 1; sort++) 
    { 
     if (arr[sort] > arr[sort + 1]) 
     { 
      temp = arr[sort + 1]; 
      arr[sort + 1] = arr[sort]; 
      arr[sort] = temp; 
     }  
    } 
    Console.Write("{0} ", arr[write]); 
}

Tutto ciò che sto tentando di fare è un semplice bubble sort con questo array. Mi piacerebbe capire perché l'ordinamento è rovinato. Nel esempio, qui è quando la matrice è {800,11,50,771,649,770,240, 9}:Semplice bubble sort C#

Ecco ciò che viene visualizzato: 11, 50, 649, 9, 649, 770, 771, 800

Sto pensando che potrei mancare qualcosa nel confronto.

fonte

2013-02-08 Karim O.

Sei ciclo esterno va dall'inizio alla fine, dovrebbe essere fine per iniziare! inoltre il tuo ciclo interno dovrebbe essere limitato al valore di scrittura. – Polity

@Polity: non credo sia corretto. Come le risposte mostrano, il ciclo esterno è corretto così com'è. Hai ragione riguardo al ciclo interno però. –

Spero che questo sia solo un esercizio di apprendimento delle manipolazioni di array? Non riesco a pensare a nessuna applicazione in cui un Bubble Sort sarebbe la strategia di ordinamento "ottimale". Se è solo per dimostrazione/esercizio mentale, allora va bene, ma se stai usando questa è un'applicazione del mondo reale, forse dovresti guardare qualche altro algoritmo di "ordinamento". – Th3Minstr3l

No, l'algoritmo funziona ma l'operazione Write è fuori posto all'interno del ciclo esterno.

int[] arr = { 800, 11, 50, 771, 649, 770, 240, 9 }; 

int temp = 0; 

for (int write = 0; write < arr.Length; write++) { 
    for (int sort = 0; sort < arr.Length - 1; sort++) { 
     if (arr[sort] > arr[sort + 1]) { 
      temp = arr[sort + 1]; 
      arr[sort + 1] = arr[sort]; 
      arr[sort] = temp; 
     } 
    } 
} 

for (int i = 0; i < arr.Length; i++) 
    Console.Write(arr[i] + " "); 

Console.ReadKey();

fonte

2013-02-08 07:59:28 Matten

A chi ha suggerito la mia scrittura è fuori luogo, grazie! Questo è ciò che stava causando le cose a farsi rovinare. Ora funziona –

Il Console.Write("{0} ", arr[write]); è troppo presto. Si stanno stampando i valori mentre l'ordinamento è ancora in corso. Ad esempio, stai stampando 9 come indice 3 nell'array, eppure nella successiva iterazione del ciclo lo 9 si è spostato sull'indice 2 e 240 si è spostato sull'indice 3 ... tuttavia il tuo ciclo esterno si è spostato inoltra quindi stampa 649 la seconda volta e 240 non viene mai stampato.

fonte

2013-02-08 08:07:37 McAden

Questo non è proprio vero, sta stampando l'ultimo valore scritto. Ciò significa che dopo la correzione, il risultato verrà stampato in ordine discendente (anche se ordinato). – Polity

@Polity - 'Stampa l'ultimo valore scritto. - Penso che tu abbia frainteso un 'Bubble Sort'.Sta chiaramente trasmettendo i valori alla console prima che l'algoritmo abbia terminato l'ordinamento. Non c'è nulla di sbagliato nella logica di ordinamento sopra, a condizione che volesse semplicemente implementare un bubble sort. - http://en.wikipedia.org/wiki/Bubble_sort – McAden

Questo funziona per me

public static int[] SortArray(int[] array) 
{ 
    int length = array.Length; 

    int temp = array[0]; 

    for (int i = 0; i < length; i++) 
    { 
     for (int j = i+1; j < length; j++) 
     { 
      if (array[i] > array[j]) 
      { 
       temp = array[i]; 

       array[i] = array[j]; 

       array[j] = temp; 
      } 
     } 
    } 

    return array;   
}

fonte

2013-04-22 10:14:34 azuneca

Aveva quasi la stessa soluzione: int [] unsorted = new int [] { 3,4,13,1,18,22,2,100,11 }; // Bubble sort for (int i = 0; i

Non è [Bubble sort] (https://en.wikipedia.org/wiki/Sorting_algorithm#Bubble_sort). Da wikipedia: "L'algoritmo inizia all'inizio del set di dati, confronta i primi due elementi e se il primo è maggiore del secondo, li scambia. ** Continua a farlo per ogni coppia di elementi adiacenti al fine del set di dati. ** Quindi si riavvia con i primi due elementi, ripetendo fino a quando non si sono verificati swap sull'ultimo passaggio. " – MiniMax

ho visto usare qualcun questo esempio come parte di un test di domanda di lavoro. Il mio feedback per lui è stato che manca una fuga dal ciclo esterno quando l'array è per lo più ordinato.

considerare che cosa accadrebbe in questo caso:

int[] arr = {1,2,3,4,5,6,7,8};

qui è qualcosa che ha più senso:

int[] arr = {1,2,3,4,5,6,7,8}; 

int temp = 0; 
int loopCount=0; 
bool doBreak=true; 

for (int write = 0; write < arr.Length; write++) 
{ 
    doBreak=true; 
    for (int sort = 0; sort < arr.Length - 1; sort++) 
    { 
     if (arr[sort] > arr[sort + 1]) 
     { 
      temp = arr[sort + 1]; 
      arr[sort + 1] = arr[sort]; 
      arr[sort] = temp; 
      doBreak=false; 
     } 
     loopCount++; 
    } 
    if(doBreak){ break; /*early escape*/ } 
} 

Console.WriteLine(loopCount); 
for (int i = 0; i < arr.Length; i++) Console.Write(arr[i] + " ");

fonte

2013-06-12 15:36:22 Dima

Sono d'accordo con il tuo feedback, ma quello non è un tipo di bolla "tradizionale" con la fuga dal ciclo esterno. –

int[] arr = { 800, 11, 50, 771, 649, 770, 240, 9 }; 

int temp = 0; 

for (int write = 0; write < arr.Length; write++) 
{ 
    for (int sort = 0; sort < arr.Length - 1 - write ; sort++) 
    { 
     if (arr[sort] > arr[sort + 1]) 
     { 
      temp = arr[sort + 1]; 
      arr[sort + 1] = arr[sort]; 
      arr[sort] = temp; 
     } 
    } 
} 

for (int i = 0; i < arr.Length; i++) Console.Write(arr[i] + " "); 

Console.ReadKey();

fonte

2013-12-01 19:23:54

int[] array = new int[10] { 13, 2, 5, 8, 23, 90, 41, 4, 77, 61 }; 

for (int i = 10; i > 0; i--) 
{ 
    for (int j = 0; j < 9; j++) 
    { 
     if (array[j] > array[j + 1]) 
     { 
      int temp = array[j]; 
      array[j] = array[j + 1]; 
      array[j + 1] = temp; 
     } 
    } 
}

fonte

2014-01-09 20:53:45

static bool BubbleSort(ref List<int> myList, int number) 
    { 
     if (number == 1) 
      return true; 
     for (int i = 0; i < number; i++) 
     { 
      if ((i + 1 < number) && (myList[i] > myList[i + 1])) 
      { 
       int temp = myList[i]; 
       myList[i] = myList[i + 1]; 
       myList[i + 1] = temp; 
      } 
      else 
       continue; 
     } 
     return BubbleSort(ref myList, number - 1); 
    }

fonte

2014-05-06 22:55:38 edison2001ren

Forse scrivere anche una breve spiegazione. – Numbers

Solo un altro esempio, ma con una MENTRE outter loop invece di un FOR:

public static void Bubble() 
    { 
     int[] data = { 5, 4, 3, 2, 1 }; 
     bool newLoopNeeded = false; 
     int temp; 
     int loop = 0; 

     while (!newLoopNeeded) 
     { 
      newLoopNeeded = true; 
      for (int i = 0; i < data.Length - 1; i++) 
      { 
       if (data[i + 1] < data[i]) 
       { 
        temp = data[i]; 
        data[i] = data[i + 1]; 
        data[i + 1] = temp; 
        newLoopNeeded = false; 
       } 
       loop++; 
      } 
     } 
    }

fonte

2014-07-24 15:26:13 RolandoCC

Questo esempio di ciclo while è più lento sia degli algoritmi BubbleSort predefiniti sia degli algoritmi di escape precedenti di BubbleSort con dati non ordinati casuali ... – ManIkWeet

-1

int[] arr = { 800, 11, 50, 771, 649, 770, 240, 9 }; 
for (int i = 0; i < arr.Length; i++) 
{ 
    for (int j = i; j < arr.Length ; j++) 
    { 
     if (arr[j] < arr[i]) 
     { 
      int temp = arr[i]; 
      arr[i] = arr[j]; 
      arr[j] = temp; 
     } 
    } 
} 
Console.ReadLine();

fonte

2014-09-20 18:55:36

questo è errato, il codice precedente che hai mostrato è sort sort-- non bubble sort .. in bubble sort tu muovere paragonando elementi adiacenti .. per favore aggiornalo. for (int i = 0; i arr [j + i ]) { int temp = arr [j + 1]; arr [j + 1] = arr [j]; arr [j] = temp; } } } –

public static void BubbleSort(int[] a) 
    { 

     for (int i = 1; i <= a.Length - 1; ++i) 

      for (int j = 0; j < a.Length - i; ++j) 

       if (a[j] > a[j + 1]) 


        Swap(ref a[j], ref a[j + 1]); 

    } 

    public static void Swap(ref int x, ref int y) 
    { 
     int temp = x; 
     x = y; 
     y = temp; 
    }

fonte

2014-10-14 16:38:37 Nikoo

Si prega di non inserire solo il codice. Spiega cosa ci stai mostrando. – Andrew

+10

Il codice chiaro e autodocumentato non ha bisogno di commenti. – birdus

-1

using System; 
using System.Collections.Generic; 
using System.Linq; 
using System.Text; 
using System.Threading.Tasks; 

namespace Practice { 
    class Program 
    { 
     static void Main(string[] args) 
     { 
      Console.WriteLine("Enter the size"); 
      int n = Convert.ToInt32(Console.ReadLine()); 
      int[] mynum = new int[n]; 
      Console.WriteLine("Enter the Numbers"); 
      for (int p = 0; p < n;p++) 
      { 
       mynum[p] = Convert.ToInt32(Console.ReadLine()); 

      } 
      Console.WriteLine("The number are"); 
       foreach(int p in mynum) 
       { 
        Console.WriteLine(p); 
       } 
       for (int i = 0; i < n;i++) 
       { 
        for(int j=i+1;j<n;j++) 
        { 
         if(mynum[i]>mynum[j]) 
         { 
          int x = mynum[j]; 
          mynum[j] = mynum[i]; 
          mynum[i] = x; 
         } 
        } 
       } 
       Console.WriteLine("Sortrd data is-"); 
      foreach(int p in mynum) 
      { 
       Console.WriteLine(p); 
      } 
        Console.ReadLine(); 
     } 
    } }

fonte

2016-09-07 12:18:06

È sbagliato - stai visualizzando la selezione qui. Stai confrontando il primo elemento I = 0 con ogni elemento di j = I + 1 questo è l'ordinamento di selezione e non il bubble sort .. nell'ordinamento a bolle per ogni passaggio il primo elemento j = viene confrontato con j + 1 e se non nell'ordine è scambiato, questo sarà fatto per ogni passaggio su i. Si prega di controllare il ciclo for della tua e la prima risposta da matten –

-1

public void BubbleSortNum() 
    { 
     int[] a = {10,5,30,25,40,20}; 
     int length = a.Length; 
     int temp = 0; 
     for (int i = 0; i <length; i++) 
     {    
      for(int j=i;j<length; j++) 
      { 
       if (a[i]>a[j]) 
       { 
        temp = a[j]; 
        a[j] = a[i]; 
        a[i] = temp; 
       }  
      } 
      Console.WriteLine(a[i]); 
     }  
    }

fonte

2017-10-11 21:40:22 mpaul

Semplice bubble sort C#

risposta

Problemi correlati