Mein BubbleSort in C# - Verbesserungsvorschläge?

kernel64

Hallo, ich habe mich nun von C/C++ & JAVA erstmal abgeschlossen und hab mit C# angefangen. Habe mal die BubbleSort Funktionsweise umgesetzt, schaut bitte ob ich die richtigen Modifizierer usw. verwendet habe und was man verbessern könnte, ich möchte ja aus meinen Fehlern lernen

//BubbleSort.cs

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

namespace Sortier_Algorithmen
{
    class BubbleSort
    {        
        public int[] Sort(int[] liste)
        {
            bool sortiert;
            do
            {
                sortiert = true;
                for (int i = 0; i < liste.Length - 1; i++)
                {
                    if (liste[i] > liste[i + 1])
                    {
                        //Tauschen
                        int temp = liste[i];
                        liste[i] = liste[i + 1];
                        liste[i + 1] = temp;
                        //Nicht sortiert!
                        sortiert = false;
                    }
                }
            } while (!sortiert);

            return liste;
        }
    }
}

//Programm.cs

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

namespace Sortier_Algorithmen
{
    class Program
    {
        static void Main(string[] args)
        {
            int[] liste = { 3, 7, 1, 9, 2, 5, 2};

            //BubbleSort
            BubbleSort BSort = new BubbleSort();
            int[] result = BSort.Sort(liste);
            //Print Funktion - Objektname und Listen Ausgabe
            Print(BSort, result);

            //QuickSort
            //...

            Console.ReadKey();

        }

        static void Print(Object name, int[] liste)
        {
            Console.WriteLine(name);
            for (int i = 0; i < liste.Length; i++)
            {
                Console.Write(liste[i] + " ");                
            }
            Console.WriteLine();
        }
    }
}

Du brauchst bei Sort keinen expliziten Rückgabewert, da das Array sowieso by reference übergeben wird.

result und liste sind Referenzen auf das gleiche Objekt.

Ansonsten schauts gut aus. Vielleicht noch die nicht benutzten usings wegmachen,
den namespace lieber ohne Unterstrich benennen, sind so kosmetische Maßnahmen.

kernel64

Vielen Dank, hab mich schon einwenig eingelesen, doch das dauert bis man alles verstanden hat. Sowie ich verstanden habe sind Referenzen sowas wie Zeiger bei C auf ein Objekt oder?
In einer Funktion wird eine Variable deklariert, dabei wird die Variable einer anderen Funktion übergeben, diese nennt man Referenz auf das Ursprungsobjekt wie bei BSort.Sort(liste);

witte

Schau' Dir mal als Alternative folgenden Code an:

class Sort
    {        

        public static void BubbleSort<T>(ref IList<T> liste) where T: IComparable<T>
        {
            bool sortiert;
            do
            {
                sortiert = true;
                for (int i = 0; i < liste.Count - 1; i++)
                {
                    if (liste[i].CompareTo(liste[i + 1]) > 0)
                    {
                        //Tauschen
                        T temp = liste[i];
                        liste[i] = liste[i + 1];
                        liste[i + 1] = temp;
                        //Nicht sortiert!
                        sortiert = false;
                    }
                }
            } while (!sortiert);
        }
    }

int[] liste = { 3, 7, 1, 9, 2, 5, 2};
            IList<int> r = liste;
            Sort.BubbleSort<int>(ref r);

Ich weiss nicht, ob es schneller ist. Er hat drei andere wesentliche Änderungen:
- wenn die Klasse keinen internen Status speichern muss, kann die Methode auch statisch sein.
- die generische Form BubbleSort<T> where T: IComparable<T> ermöglicht Dir alle Typen zu sortieren, die IComparable<T> implementieren (Double, DateTime, ...)
- die generische Form IList<T> kann auch andere Kollektionen als nur Arrays sortieren.

Konrad Rudolph

witte schrieb:

[… Code …]

Mehrere Anmerkungen:

1. 'ref' ist hier nutzlos und irreführend.

2. Die Zuweisung von 'liste' an ein 'IList<int>'-Objekt vor der Übergabe ist überflüssig.

3. Beim Aufruf muss und sollte der Typ nicht explizit mit angegeben werden:

Sort.BubbleSort(liste);
// statt
Sort.BubbleSort<int>(liste);

4. Wofür ist die Klasse gut? Wofür die statische Methode? => Warum nicht eine Extension-Methode?

5. Schneller ist es nicht.

Knuddlbaer

Wofür ist die Klasse gut? Wofür die statische Methode? => Warum nicht eine Extension-Methode?

Nun, das Projekt könnte durchaus noch auf C# 2.0 setzen oder sich damit übersetzen lassen.

Konrad Rudolph

Knuddlbaer schrieb:

Wofür ist die Klasse gut? Wofür die statische Methode? => Warum nicht eine Extension-Methode?

Nun, das Projekt könnte durchaus noch auf C# 2.0 setzen oder sich damit übersetzen lassen.

Ei sicher, aber in einem Forum sollte man doch, wenn nicht spezifische Gründe dagegen sprechen, sicherlich die state-of-the-art-Lösung abgeben, oder?

Und unmotivierte, statische Methoden in irgendwelchen Helper-Modulen sind sowieso alles andere als schön.

witte

Ich habe Konrads Vorschläge mal eingearbeitet. Das würde dann so aussehen:

public static class Sort
    {        

        public static void BubbleSort<T>(this IList<T> liste) where T: IComparable<T>
        {
            bool sortiert;
            do
            {
                sortiert = true;
                for (int i = 0; i < liste.Count - 1; i++)
                {
                    if (liste[i].CompareTo(liste[i + 1]) > 0)
                    {
                        //Tauschen
                        T temp = liste[i];
                        liste[i] = liste[i + 1];
                        liste[i + 1] = temp;
                        //Nicht sortiert!
                        sortiert = false;
                    }
                }
            } while (!sortiert);
        }
    }

int[] liste = { 3, 7, 1, 9, 2, 5, 2};
            liste.BubbleSort();