Veri yapıları ve algoritmalar dersi kaynak kodlar

25.09.2024

Binary search (ikili arama) algoritması için derste yazdığımız kaynak kod.

#include <iostream>
using namespace std;

int ikiliArama(int dizi[], int sol, int sag, int aranan)
{
    if (sag>=sol)
    {
        int orta = sol + (sag - sol)/2;
        if (dizi[orta]==aranan)
        {
            return orta;
        }
        if (dizi[orta]>aranan)
        {
            return ikiliArama(dizi, sol, orta-1, aranan);
        }
        else
        {
            return ikiliArama(dizi, orta+1, sag, aranan);
        }
    }
    else
    {
        return -1;
    }
}

int main()
{
    int elemansayisi = 10;
    int yeni[elemansayisi] = {2, 3, 6, 8, 12, 50, 60, 72, 88, 99}; 

    cout<<ikiliArama(yeni, 0, elemansayisi, 72);
    
    return 0;
}

02.10.2024

Sıralama algoritmaları

#include<iostream>
using namespace std;
// Kabarcık sıralama *************************************************************************
void bubbleSort(int dizi[], int n) 
{ 
    int i, j; 
    for (i = 0; i < n; i++)     
      for (j = 0; j < n-1; j++) 
    	    if (dizi[j] > dizi[j+1]) 
       	    {
        		int temp = dizi[j];
        		dizi[j] = dizi[j+1];
        		dizi[j+1] = temp;
      }
      
} 

// Yerleştirmeli sıralama *************************************************************************
void insertionSort(int dizi[], int n)
{
  int i, j, anahtar;
  for(i = 1; i<n; i++)
  {
    anahtar = dizi[i];
    j = i-1;
    while(j>=0 && dizi[j]>anahtar)
    {
      dizi[j+1] = dizi[j];
      j = j-1;
    }	
    dizi[j+1] = anahtar;
  }
}

// Seçmeli sıralama *************************************************************************
void selectionSort(int arr[], int n)
{
  int enkucuk, yedek;
    for (int i = 0; i < n-1; i++)
  {
    	enkucuk = i;
    	for (int j = i+1; j < n; j++)
    	{
        	if (arr[j]<arr[enkucuk])
        	{
            	enkucuk = j;
        	}
    	}

    	if (enkucuk != i)
    	{
        	yedek = arr[i];
        	arr[i] = arr[enkucuk];
        	arr[enkucuk] = yedek;
    	}               
  }
}

// Kabuk sıralama *************************************************************************
void shellSort(int dizi[], int n) 
{
  for (int a = n / 2; a > 0; a /= 2) 
  {
  for (int i = a; i < n; i += 1) 
  {
      int temp = dizi[i];
      int j;
      for (j = i; j >= a && dizi[j - a] > temp; j -= a) {
        dizi[j] = dizi[j - a];
      }
      dizi[j] = temp;
    }
  }
}

// Hızlı sıralama *************************************************************************
int bolumlendir (int dizi[], int kucuk, int buyuk)
{
    int pivot = dizi[buyuk]; // pivot
    int i = (kucuk - 1); // Index of smaller element and indicates the right position of pivot found so far
 
    for (int j = kucuk; j <= buyuk - 1; j++)
    {
        // If current element is smaller than the pivot
        if (dizi[j] < pivot)
        {
            i++; // increment index of smaller element
            int temp = dizi[i];
            dizi[i] = dizi[j];
            dizi[j] = temp; 
        }
    }
    int temp = dizi[i+1];
    dizi[i+1] = dizi[buyuk];
    dizi[buyuk] = temp;
    return (i + 1);
}

void quickSort(int dizi[], int kucuk, int buyuk)
{
    if (kucuk < buyuk)
    {
        int pi = bolumlendir(dizi, kucuk, buyuk);
        quickSort(dizi, kucuk, pi - 1);
        quickSort(dizi, pi + 1, buyuk);
    }
}

//*******************************************************************************
main()
{
  int dizi[5] = {10, 6, 8, 11, 2};
  
  bubbleSort(dizi, 5);
  insertionSort(dizi, 5);
  selectionSort(dizi, 5);
  shellSort(dizi,5);
  quickSort(dizi, 0, 4);
  
  for(int i = 0; i<5; i++)
    cout<<dizi[i]<<"  ";
}