C# Sıralama Algoritmaları Google'da Ara Büyüt Küçült

Genişlet
27 Şubat 2010 – 00:20

C# ta dizilerde sıralama işlemi için bazı yöntemler vardır bunlar Bubble Sort(Kabarcık Sıralaması),Quick Sort(Hızlı Sıralama) ve Insertion Sort(Eklemeli Sıralama)

Bubble Sort(Kabarcık Sıralaması)
Kabarcık sıralaması dizinin başından başlar ve dizi elemanlarını sırayla seçer. Seçilen dizi elemanı kendinden sonra gelen elemandan büyükse bu iki elemanın yerleri değiştirilir.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public void bubble_sort(int[] dizi)
    {
      for (int i = 0; i < dizi.Length - 1; i++)
      {
        for (int j = 1; j < dizi.Length - i; j++)
        {
          if (dizi[j] < dizi[j - 1])
          {
            int gecici = dizi[j - 1];
            dizi[j - 1] = dizi[j];
            dizi[j] = gecici;
          }
        }
      }
    }

    /*Bubble Sort Kullanımı*/
    int[] dizi = { 15,8,16,1,5,9,8,78,55 };
    bubble_sort(dizi);

Quick Sort(Hızlı Sıralama)
Hızlı sıralama algoritması, sıralanacak bir sayı dizisini daha küçük iki parçaya ayırıp oluşan bu küçük parçaların kendi içinde sıralanması mantığıyla çalışır.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
 public void  QuickSort(int[] dizi, int baslangic, int  bitis)
        {
            int i;
            if (baslangic < bitis)
            {
                i = partition(dizi, baslangic, bitis);
                QuickSort(dizi, baslangic, i - 1);
                QuickSort(dizi, i + 1, bitis);
            }
 
        }
        public int partition(int[] A, int baslangic, int bitis)
        {
            int gecici;
            int x = A[bitis];
            int i = baslangic - 1;
 
            for (int j = baslangic; j <= bitis - 1; j++)
            {
                if (A[j] <= x)
                {
                    i++;
                    gecici = A[i];
                    A[i] = A[j];
                    A[j] = gecici;
                }
            }
            gecici = A[i + 1];
            A[i + 1] = A[bitis];
            A[bitis] = gecici;
            return i + 1;
        }

Insertion Sort(Eklemeli Sıralama)
Eklemeli Sıralama (İngilizcesi: Insertion Sort), bilgisayar bilimlerinde kullanılan ve sıralı diziyi her adımda öğe öğe oluşturan bir sıralama algoritmasıdır. Büyük dizilerle çalışıldığında hızlı sıralama, birleştirmeli sıralama ve yığın sıralaması gibi daha gelişmiş sıralama algoritmalarından daha verimsiz çalışır.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public static int [] eklemeliSiralama(int[] dizi) {
 
      int gecici, eklenen;
 
      for ( int adım = 1; adım < dizi.Length; adım++) {
 
            eklenen = dizi[adım]; //dizinin ilk elemanını al
            gecici = adım; //indeks değerini gecici değişkeninde sakla
 
            while (gecici > 0 && dizi[gecici - 1] > eklenen) {
        //Eğer adım sayısı >0 ve dizinin n-1. elemanın değeri eklenen
        //Eklenen değerden büyükse
                  dizi[gecici] = dizi[gecici - 1]; //n-1. elemanı sona kaydır
              gecici--; //indeks değerini 1 azalt..
 
            }
 
            dizi[gecici] = eklenen; //Yeri değiştirilen elemanı diziye geçir..
    Console.Write("Sıralanmakta olan dizi :{0}",diziyiYazdır(dizi)+"\n");
      }
    return dizi;
}//**
Etiketler Etiketler: ”, , , , , ,

Benzer Yazılar

Yorum Yap

Isim : (gerekli)
E-mail : (gerekli)
Yorumunuz: