Einfache Blasensortierung 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]); 
}

Alles was ich versuche zu tun ist eine einfache Blasensortierung mit diesem Array. Ich möchte herausfinden, warum die Sortierung vermasselt ist. Im Beispiel hier ist, wenn das Array {800,11,50,771,649,770,240, 9} ist:Einfache Blasensortierung C#

Hier ist, was angezeigt wird: 11, 50, 649, 9, 649, 770, 771, 800

Ich denke, ich könnte etwas im Vergleich fehlen.

Quelle

2013-02-08 Karim O.

Sie äußerte Schleife vom Anfang bis zum Ende geht ist, soll Ende, um zu starten! Auch deine innere Schleife sollte auf den Wert von write beschränkt sein. – Polity

@Polity: Ich glaube nicht, dass das korrekt ist. Wie Antworten zeigen, ist die äußere Schleife korrekt wie sie ist. Du hast aber recht mit der inneren Schleife. –

Ich hoffe, das ist nur eine Übung beim Lernen von Array-Manipulationen? Ich kann mir keine Anwendung vorstellen, bei der eine Bubble Sort die "optimale" Sortierstrategie wäre. Wenn es nur zur Demonstration/mentalen Übung ist, dann gut, aber wenn Sie dies verwenden, ist eine reale Anwendung, vielleicht sollten Sie sich einige andere Sortieralgorithmen ansehen. – Th3Minstr3l

Nein, Ihr Algorithmus funktioniert, aber Ihre Write Operation ist innerhalb der äußeren Schleife verlegt.

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();

Quelle

2013-02-08 07:59:28 Matten

Wer auch immer mein Schreiben vorgeschlagen hat, ist fehl am Platz, danke! Das war es, was dazu führte, dass die Dinge vermasselt wurden. Jetzt funktioniert es –

Ihre Console.Write("{0} ", arr[write]); ist zu früh. Sie drucken die Werte , während die Sortierung noch läuft. Beispiel: Sie geben 9 als Index 3 im Array aus, aber bei der nächsten Iteration der Schleife ist die 9 in den Index 2 verschoben und 240 ist in den Index 3 verschoben ... Sie sind noch in der äußeren Schleife vorwärts, so druckt es 649 das zweite Mal und 240 wird nie gedruckt.

Quelle

2013-02-08 08:07:37 McAden

Das ist nicht wirklich wahr, Er druckt den letzten geschriebenen Wert aus. Dies bedeutet, dass nach dem Fix das Ergebnis in einer absteigenden Reihenfolge gedruckt wird (obwohl sortiert). – Polity

@Polity - 'Er druckt den letzten geschriebenen Wert aus. - Ich glaube, Sie haben ein 'Bubble Sort' falsch verstanden.Er gibt Werte eindeutig an die Konsole aus, bevor der Algorithmus das Sortieren beendet hat. Es ist nichts falsch mit der obigen Sortierlogik, vorausgesetzt, dass er einfach eine Blasensortierung implementieren wollte. - http://en.wikipedia.org/wiki/Bubble_sort – McAden

Dies funktioniert für mich

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;   
}

Quelle

2013-04-22 10:14:34 azuneca

Hatte fast die gleiche Lösung: int [] unsortiert = new int [] { 3,4,13,1,18,22,2,100,11 }; // Blasensortierung for (int i = 0; i

Es ist nicht [Bubble sort] (https://en.wikipedia.org/wiki/Sorting_algorithm#Bubble_sort). Aus wikipedia: "Der Algorithmus beginnt am Anfang des Datensatzes. Er vergleicht die ersten beiden Elemente, und wenn der erste größer als der zweite ist, tauscht er sie. ** Dies macht dies weiterhin für jedes Paar von benachbarten Elementen zum Ende des Datensatzes. ** Es beginnt dann wieder mit den ersten beiden Elementen, Wiederholung, bis keine Swaps im letzten Durchgang aufgetreten sind. " – MiniMax

mich jemand dieses Beispiel als Teil eines Bewerbungstest verwenden sah. Meine Rückmeldung an ihn war, dass es keine Flucht aus der äußeren Schleife gibt, wenn das Array größtenteils sortiert ist.

überlegen, was in diesem Fall passieren würde:

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

hier etwas, was mehr Sinn macht:

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] + " ");

Quelle

2013-06-12 15:36:22 Dima

Ich stimme deinem Feedback zu, aber das ist keine "traditionelle" Blasensorte mit der Flucht aus der äußeren Schleife. –

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();

Quelle

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; 
     } 
    } 
}

Quelle

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); 
    }

Quelle

2014-05-06 22:55:38 edison2001ren

Vielleicht schreiben Sie auch eine kurze Erklärung. – Numbers

nur ein weiteres Beispiel, aber mit einem outter WÄHREND Schleife anstelle von 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++; 
      } 
     } 
    }

Quelle

2014-07-24 15:26:13 RolandoCC

Diese While-Schleife Beispiel ist langsamer als die Standard-BubbleSort und die frühen Escape-BubbleSort-Algorithmen oben mit zufälligen unsortierten Daten ... – 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();

Quelle

2014-09-20 18:55:36

das ist falsch, der obige Code, den Sie gezeigt haben, ist Auswahl sortieren- nicht Blase sortieren .. in Blase sortieren Sie Bewegen Sie sich, indem Sie benachbarte Elemente vergleichen. Bitte aktualisieren Sie sie. für (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; 
    }

Quelle

2014-10-14 16:38:37 Nikoo

Bitte nicht nur Code eingeben. Erkläre, was du uns zeigst. – Andrew

+10

Klarer und selbstdokumentierender Code benötigt keine Kommentare. – 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(); 
     } 
    } }

Quelle

2016-09-07 12:18:06

Es ist falsch - Sie zeigen Auswahl sortieren hier. Sie vergleichen das erste Element I = 0 mit jedem Element von j = I + 1 das ist Auswahlsortierung und nicht Blasensortierung. Bei Blasensortierung wird für jeden Durchgang das erste Element j = mit j + 1 verglichen und wenn nicht in der Reihenfolge ist vertauscht, dies wird für jeden Durchlauf auf i getan. Bitte überprüfe die for-Schleife deiner und die erste Antwort von 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]); 
     }  
    }

Quelle

2017-10-11 21:40:22 mpaul

Einfache Blasensortierung C#

Antwort

Verwandte Themen