C Bağlı Liste(Linked List) Algoritmasına Veri Ekleme Nasıl Yapılır?

Arawn920 · 19 Ocak 2021

Kod:

#include<stdio.h>
#include<stdlib.h>
#define boyut 8
int veriSutundaSayiAra(int aranan){
   
    int matris[boyut]={85,3,98,153,9,1,45,23};
    printf("\n");
    for(int i=0;i<boyut;i++){
        printf("%5d",matris[i]);
        if(aranan==matris[i]){
           
            return i;
        }
    }
}
int main (){
    int hedef[boyut]={1,3,9,23,45,85,98,153};
    int listeBasi=1;
    int listeBasAdres=6;
    int veriBag[boyut];
    //veriBag[0]=ListeBasAdres;
    int veriAdres;
    int arananDeger;
   
    for(int i=0;i<boyut-1;i++){
        int hedefDiziElemani=hedef[i+1];
        veriAdres=veriSutundaSayiAra(hedefDiziElemani);
        veriBag[i]=veriAdres+1;
       
    }
   
    printf("\nBag :\n");
    for(int i=0;i<boyut;i++){
        printf("%5d",veriBag[i]);

  }
}

Bağlı liste algoritmasına fonksiyon ile veri ekleme ve çıkarma yapmak istiyorum. Nasıl yapabilirim? Struct yapısı ile internette bulabiliyorum ama öyle istemiyorum. Nedense hocamız benim öğrettiklerimin dışında kabul etmiyorum diyor. Yani bilgiye kolay ulaşabildiği bu dönem de bunu söylemek

. Neyse sınava hazırlık için yardımcı olur musunuz?

esrarkesfil · 22 Ocak 2021

Bağlı listeyi hocanız dizi ile kodlamayı mı öğretti?

Arawn920 · 22 Ocak 2021

esrarkesfil dedi:
Bağlı listeyi hocanız dizi ile kodlamayı mı öğretti?

Onu bile tam öğretmedi hocam

. Kaba kodu verdi, bizim doldurmamızı istedi.

LayThese · 22 Ocak 2021

Daha önce şöyle bir kodla uğraşmıştım sorunuz olursa yanıtlamaya çalışırım. Github hesabımda ismim yazmasaydı link olarak atacaktım kusura bakmayın.

Single Linked List Örneği:

C:

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <time.h>
#include <stdbool.h>

typedef struct LINKED_LIST
{
    int data;
   struct LINKED_LIST * next;
}node;

typedef time_t taym;
typedef int counter;
typedef unsigned int uint;

void addtolast(node *b , int c);
void display(node *r);
void addtofirst(node *n , int a);
void addtoposition(node *n , unsigned int a , int data);
void deleteatposition(node *n , unsigned int a);
void mergelists(node *n , node *r);
void search(node *a , int b);
void quicksort(node *a , uint b);
void mergesort(node *a);
void bubblesort(node *a , uint b);
void shellsort(node *a , uint b , uint counter);
void swap(node *a , node *b);
bool IsEven(uint a);
void Sum(node *a);
void yinangsort(node *a , uint b);
void selectionsort(node *a);
bool IsSorted(node *a);

int main()
{
    taym t;
    srand((unsigned) time(&t)) ; /* RNG */

    node * root;
    node * root2;
    node * root3;

    root = (node*)malloc(sizeof(node));
    root2 = (node*)malloc(sizeof(node));
    root3 = (node*)malloc(sizeof(node));

    node * iter = root;
    node * iter2 = root2;
    node * iter3 = root3;

     uint counter = 1;

    while(counter <= rand() %1000)
    {
iter -> next =(node*)malloc(sizeof(node));
iter2 -> next =(node*)malloc(sizeof(node));
iter3 -> next =(node*)malloc(sizeof(node));

        iter -> data = rand() %1000;
        iter2 -> data = rand() %1000;
        iter3 -> data = rand() %1000;

        iter = iter -> next;
        iter2 = iter2 -> next;
        iter3 = iter3 -> next;

        counter++;
    }
   /*
    addtoposition(root , 5 , 1111);
    addtofirst(root , 1111);
    addtolast(root , 1111);
    deleteatposition(root , 3);
    search(root , 1111);
    */

    display(root);
    puts(" \n AFTER SHELLSORT \n ");
    shellsort(root , 1 , counter);
    display(root);

    puts(" \n ------------- \n ");

    display(root2);
    puts(" \n AFTER BUBBLESORT \n ");
    bubblesort(root2 , counter);
    display(root2);

    puts(" \n ------------- \n ");

    display(root3);
    puts("\n After Selectionsort \n");
    selectionsort(root3);
    display(root3);

    Sum(root);
    Sum(root2);
    Sum(root3);

    IsSorted(root);
    IsSorted(root2);
    IsSorted(root3);
}

bool IsSorted(node *a)
{
    node *iter = (node*)malloc(sizeof(node));

    node *sonra = (node*)malloc(sizeof(node));

    iter = a;
    sonra = a;
    sonra = sonra -> next;

    while(sonra -> next != NULL)
    {
        if(iter -> data > sonra -> data)
        {
            printf("\nNot Sorted iter:%d sonra:%d",iter->data,sonra->data);
            return 0;
        }

        else
        {
            sonra = sonra -> next;
            iter = iter -> next;
        }
    }
    puts("\nSorted");
    return 1;
}


void selectionsort(node *a)
{
    taym simdi = clock();

    double time_spent;

    node *iter;
    iter = (node*)malloc(sizeof(node));

    node *min;
    min = (node*)malloc(sizeof(node));

    iter = a;

    while(a -> next != NULL)
    {
        if(iter -> next == NULL)
        {
            swap(a,min);
            a = a -> next;
            iter = a;
        }

       else if(iter -> data < min -> data)
        {
            swap(min,iter);
            iter = iter -> next;
        }

       else
        {
            if(iter -> next == NULL)
            {
                break;
            }
            else
            {

            iter = iter -> next;
            }
        }
            }
    taym sonra = clock();

    time_spent = (double) (sonra - simdi) / CLOCKS_PER_SEC;

    printf("\n It took %f seconds \n\n" , time_spent);
}

void Sum(node *a)
{
    node *iter;
    iter = (node*)malloc(sizeof(node));
    iter = a;
    int sum = 0;

   while(iter != NULL)
    {
        sum = sum + iter -> data;
        iter = iter -> next;
    }

    printf("\n Sum is : %d \n" , sum);
}

void display(node *r)
{
   unsigned int ctr = 1;

    while(r -> next != NULL)
{
      printf(" %d-) %d\n" , ctr , r -> data);
        ++ctr;
      r = r -> next;
}
}

void addtofirst(node *n , int a)
{
node *temp = (node*)malloc(sizeof(node));
    temp = n;
    temp -> next = n -> next;
    temp -> data = a;
}

void addtolast(node *b , int c)
{
node *temp = (node*)malloc(sizeof(node));


    bool complete = false;

    while( complete == false)
    {
        if(b -> next == NULL)
        {
            b -> data = rand () %1000;
            b -> next =(node*)malloc(sizeof(node));
            temp -> next = b -> next;
            b -> next = temp;
            temp -> data = c;
            complete = true;
        }

        else
        {
            b = b -> next;
        }
    }

}

void swap(struct LINKED_LIST  *a , struct LINKED_LIST *b)
{
    struct LINKED_LIST *c;
    struct LINKED_LIST *d;

    c = (node*)malloc(sizeof(node));
    d = (node*)malloc(sizeof(node));

    c -> data = a -> data;
    d -> data = b -> data;

    a -> data = d -> data;
    b -> data = c -> data;
}
void addtoposition(node *n , unsigned int a , int data)
{
node *temp = (node*)malloc(sizeof(node));
  uint ctr = 1;
bool complete = false;

while(complete == false)
    {
        if(ctr == a)
        {
            temp -> next = n -> next;
            n -> next = temp;
            temp -> data = data;
            complete = true;
        }

        else
        {
            ++ctr;
            n = n -> next;
        }
    }
    }

void deleteatposition(node *n , unsigned int a)
{
unsigned int ctr = 1;
bool complete = false;

     while(complete == false)
        {
            if(ctr == a)
            {
           n -> data = 0;
            printf("\n %d. deðer baþarýyla silindi\n" , a);
           n -> next = n -> next -> next;
           complete = true;
            }

            else
            {
                ctr++;
                n = n -> next;
            }
        }

}

void mergelists(node *n , node *r)
{
    bool atlast = false;

while (atlast == false)
    {
        if (n -> next == NULL)
        {
            n -> next = (node*)malloc(sizeof(node));
            n -> next = r;
        }

        else
        {
            n = n -> next;
        }
    }
}

void search(node *a , int b )
    {
        node *iter = a;
        int c = 0;

        while(iter -> next != NULL)

        {
            if( b == iter -> data)
        {
            c++;
            iter = iter -> next;
        }

        else
        {
            iter = iter -> next;
        }
            }


    if(c == 0)
    {
        puts("\nNOT FOUND\n");
    }

    else
    {
    printf("\nThe value %d have been found %d times in this list\n" , b , c);
}
}

bool IsEven(uint a)
{
    if(a % 2 == 0)
    {
        return false;
    }

    else
    {
        return true;
    }
}


void bubblesort(node *a , uint b )
  {
    taym simdi = clock();
    double time_spent;

       node *prev;
       node *current;

    current = (node*)malloc(sizeof(node));
    prev = (node*)malloc(sizeof(node));

    prev = a;
    current = a -> next;

    uint ctr1 = b;

      while(ctr1 != 0)
    {
        if(current -> next == NULL)
        {
            ctr1--;
            prev = a;
            current = a -> next;
        }

        else if(prev -> data > current -> data)
        {
            swap(prev , current);
            prev = prev -> next;
            current = current -> next;
        }

        else
        {
            prev = prev -> next;
            current = current -> next;
        }
    }

    taym sonra = clock();

    time_spent = (double) (sonra - simdi) / CLOCKS_PER_SEC;

    printf("\n It took %f seconds \n\n" , time_spent);
  }
/*
void quicksort(node *a , uint b)
    {

    float time_spent;
    taym once = clock();

    node *pivot;
    pivot = (node*)malloc(sizeof(node));

    node *biter;
    biter = (node*)malloc(sizeof(node));

    node *siter;
    siter = (node*)malloc(sizeof(node));

    uint ctr1;
    uint ctr2;

    pivot = a;

        if(IsEven(b) == true)
    {
        while(pivot -> data  ==! b / 2)
        {
            pivot = pivot -> next;
        }
        ctr1 = b / 2;
        ctr2 = ctr1;
    }
        else
        {
      while(pivot -> data ==! (b+1) / 2)
            {
                pivot = pivot -> next;
            }

        ctr1 = (b + 1) / 2;
        ctr2 = ctr1;
        }

    biter = a;
    siter = pivot;

    taym sonra = clock();
    time_spent = (float)(sonra - once) / CLOCKS_PER_SEC;
    printf("\n %f seconds \n" , time_spent);
    } */

void shellsort(node *a , uint b , uint c)
{
    taym once = clock();
    float time_spent;

    node *before;
    node *current;
    uint ctr1 = 1;

    before = (node*)malloc(sizeof(node));
    current = (node*)malloc(sizeof(node));

    before = a;
    current = a -> next;

    while(current != NULL)
    {
        if(b == 1)
        {
            bubblesort(a , c);
            break;
        }

       else if(ctr1 ==! b)
        {
            ctr1++;
            current = current -> next;
        }

        else if(ctr1 == b)
        {
    if(before -> data > current -> data)
            {
               swap(before , current);
               before = current;
               ctr1 = 1;
            }

            else
            {
                before = current;
                current = current -> next;
                ctr1 = 1;
            }
        }

        else
        {
           current = current -> next;
            ctr1++;
        }
}

    taym sonra = clock();
    time_spent = (float)(sonra - once) / CLOCKS_PER_SEC;
    printf("\n %f seconds \n" , time_spent);
}

Arawn920 · 22 Ocak 2021

LayThese dedi:

Daha önce şöyle bir kodla uğraşmıştım sorunuz olursa yanıtlamaya çalışırım. Github hesabımda ismim yazmasaydı link olarak atacaktım kusura bakmayın.

Single Linked List Örneği:

C:

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <time.h>
#include <stdbool.h>

typedef struct LINKED_LIST
{
    int data;
   struct LINKED_LIST * next;
}node;

typedef time_t taym;
typedef int counter;
typedef unsigned int uint;

void addtolast(node *b , int c);
void display(node *r);
void addtofirst(node *n , int a);
void addtoposition(node *n , unsigned int a , int data);
void deleteatposition(node *n , unsigned int a);
void mergelists(node *n , node *r);
void search(node *a , int b);
void quicksort(node *a , uint b);
void mergesort(node *a);
void bubblesort(node *a , uint b);
void shellsort(node *a , uint b , uint counter);
void swap(node *a , node *b);
bool IsEven(uint a);
void Sum(node *a);
void yinangsort(node *a , uint b);
void selectionsort(node *a);
bool IsSorted(node *a);

int main()
{
    taym t;
    srand((unsigned) time(&t)) ; /* RNG */

    node * root;
    node * root2;
    node * root3;

    root = (node*)malloc(sizeof(node));
    root2 = (node*)malloc(sizeof(node));
    root3 = (node*)malloc(sizeof(node));

    node * iter = root;
    node * iter2 = root2;
    node * iter3 = root3;

     uint counter = 1;

    while(counter <= rand() %1000)
    {
iter -> next =(node*)malloc(sizeof(node));
iter2 -> next =(node*)malloc(sizeof(node));
iter3 -> next =(node*)malloc(sizeof(node));

        iter -> data = rand() %1000;
        iter2 -> data = rand() %1000;
        iter3 -> data = rand() %1000;

        iter = iter -> next;
        iter2 = iter2 -> next;
        iter3 = iter3 -> next;

        counter++;
    }
   /*
    addtoposition(root , 5 , 1111);
    addtofirst(root , 1111);
    addtolast(root , 1111);
    deleteatposition(root , 3);
    search(root , 1111);
    */

    display(root);
    puts(" \n AFTER SHELLSORT \n ");
    shellsort(root , 1 , counter);
    display(root);

    puts(" \n ------------- \n ");

    display(root2);
    puts(" \n AFTER BUBBLESORT \n ");
    bubblesort(root2 , counter);
    display(root2);

    puts(" \n ------------- \n ");

    display(root3);
    puts("\n After Selectionsort \n");
    selectionsort(root3);
    display(root3);

    Sum(root);
    Sum(root2);
    Sum(root3);

    IsSorted(root);
    IsSorted(root2);
    IsSorted(root3);
}

bool IsSorted(node *a)
{
    node *iter = (node*)malloc(sizeof(node));

    node *sonra = (node*)malloc(sizeof(node));

    iter = a;
    sonra = a;
    sonra = sonra -> next;

    while(sonra -> next != NULL)
    {
        if(iter -> data > sonra -> data)
        {
            printf("\nNot Sorted iter:%d sonra:%d",iter->data,sonra->data);
            return 0;
        }

        else
        {
            sonra = sonra -> next;
            iter = iter -> next;
        }
    }
    puts("\nSorted");
    return 1;
}


void selectionsort(node *a)
{
    taym simdi = clock();

    double time_spent;

    node *iter;
    iter = (node*)malloc(sizeof(node));

    node *min;
    min = (node*)malloc(sizeof(node));

    iter = a;

    while(a -> next != NULL)
    {
        if(iter -> next == NULL)
        {
            swap(a,min);
            a = a -> next;
            iter = a;
        }

       else if(iter -> data < min -> data)
        {
            swap(min,iter);
            iter = iter -> next;
        }

       else
        {
            if(iter -> next == NULL)
            {
                break;
            }
            else
            {

            iter = iter -> next;
            }
        }
            }
    taym sonra = clock();

    time_spent = (double) (sonra - simdi) / CLOCKS_PER_SEC;

    printf("\n It took %f seconds \n\n" , time_spent);
}

void Sum(node *a)
{
    node *iter;
    iter = (node*)malloc(sizeof(node));
    iter = a;
    int sum = 0;

   while(iter != NULL)
    {
        sum = sum + iter -> data;
        iter = iter -> next;
    }

    printf("\n Sum is : %d \n" , sum);
}

void display(node *r)
{
   unsigned int ctr = 1;

    while(r -> next != NULL)
{
      printf(" %d-) %d\n" , ctr , r -> data);
        ++ctr;
      r = r -> next;
}
}

void addtofirst(node *n , int a)
{
node *temp = (node*)malloc(sizeof(node));
    temp = n;
    temp -> next = n -> next;
    temp -> data = a;
}

void addtolast(node *b , int c)
{
node *temp = (node*)malloc(sizeof(node));


    bool complete = false;

    while( complete == false)
    {
        if(b -> next == NULL)
        {
            b -> data = rand () %1000;
            b -> next =(node*)malloc(sizeof(node));
            temp -> next = b -> next;
            b -> next = temp;
            temp -> data = c;
            complete = true;
        }

        else
        {
            b = b -> next;
        }
    }

}

void swap(struct LINKED_LIST  *a , struct LINKED_LIST *b)
{
    struct LINKED_LIST *c;
    struct LINKED_LIST *d;

    c = (node*)malloc(sizeof(node));
    d = (node*)malloc(sizeof(node));

    c -> data = a -> data;
    d -> data = b -> data;

    a -> data = d -> data;
    b -> data = c -> data;
}
void addtoposition(node *n , unsigned int a , int data)
{
node *temp = (node*)malloc(sizeof(node));
  uint ctr = 1;
bool complete = false;

while(complete == false)
    {
        if(ctr == a)
        {
            temp -> next = n -> next;
            n -> next = temp;
            temp -> data = data;
            complete = true;
        }

        else
        {
            ++ctr;
            n = n -> next;
        }
    }
    }

void deleteatposition(node *n , unsigned int a)
{
unsigned int ctr = 1;
bool complete = false;

     while(complete == false)
        {
            if(ctr == a)
            {
           n -> data = 0;
            printf("\n %d. deðer baþarýyla silindi\n" , a);
           n -> next = n -> next -> next;
           complete = true;
            }

            else
            {
                ctr++;
                n = n -> next;
            }
        }

}

void mergelists(node *n , node *r)
{
    bool atlast = false;

while (atlast == false)
    {
        if (n -> next == NULL)
        {
            n -> next = (node*)malloc(sizeof(node));
            n -> next = r;
        }

        else
        {
            n = n -> next;
        }
    }
}

void search(node *a , int b )
    {
        node *iter = a;
        int c = 0;

        while(iter -> next != NULL)

        {
            if( b == iter -> data)
        {
            c++;
            iter = iter -> next;
        }

        else
        {
            iter = iter -> next;
        }
            }


    if(c == 0)
    {
        puts("\nNOT FOUND\n");
    }

    else
    {
    printf("\nThe value %d have been found %d times in this list\n" , b , c);
}
}

bool IsEven(uint a)
{
    if(a % 2 == 0)
    {
        return false;
    }

    else
    {
        return true;
    }
}


void bubblesort(node *a , uint b )
  {
    taym simdi = clock();
    double time_spent;

       node *prev;
       node *current;

    current = (node*)malloc(sizeof(node));
    prev = (node*)malloc(sizeof(node));

    prev = a;
    current = a -> next;

    uint ctr1 = b;

      while(ctr1 != 0)
    {
        if(current -> next == NULL)
        {
            ctr1--;
            prev = a;
            current = a -> next;
        }

        else if(prev -> data > current -> data)
        {
            swap(prev , current);
            prev = prev -> next;
            current = current -> next;
        }

        else
        {
            prev = prev -> next;
            current = current -> next;
        }
    }

    taym sonra = clock();

    time_spent = (double) (sonra - simdi) / CLOCKS_PER_SEC;

    printf("\n It took %f seconds \n\n" , time_spent);
  }
/*
void quicksort(node *a , uint b)
    {

    float time_spent;
    taym once = clock();

    node *pivot;
    pivot = (node*)malloc(sizeof(node));

    node *biter;
    biter = (node*)malloc(sizeof(node));

    node *siter;
    siter = (node*)malloc(sizeof(node));

    uint ctr1;
    uint ctr2;

    pivot = a;

        if(IsEven(b) == true)
    {
        while(pivot -> data  ==! b / 2)
        {
            pivot = pivot -> next;
        }
        ctr1 = b / 2;
        ctr2 = ctr1;
    }
        else
        {
      while(pivot -> data ==! (b+1) / 2)
            {
                pivot = pivot -> next;
            }

        ctr1 = (b + 1) / 2;
        ctr2 = ctr1;
        }

    biter = a;
    siter = pivot;

    taym sonra = clock();
    time_spent = (float)(sonra - once) / CLOCKS_PER_SEC;
    printf("\n %f seconds \n" , time_spent);
    } */

void shellsort(node *a , uint b , uint c)
{
    taym once = clock();
    float time_spent;

    node *before;
    node *current;
    uint ctr1 = 1;

    before = (node*)malloc(sizeof(node));
    current = (node*)malloc(sizeof(node));

    before = a;
    current = a -> next;

    while(current != NULL)
    {
        if(b == 1)
        {
            bubblesort(a , c);
            break;
        }

       else if(ctr1 ==! b)
        {
            ctr1++;
            current = current -> next;
        }

        else if(ctr1 == b)
        {
    if(before -> data > current -> data)
            {
               swap(before , current);
               before = current;
               ctr1 = 1;
            }

            else
            {
                before = current;
                current = current -> next;
                ctr1 = 1;
            }
        }

        else
        {
           current = current -> next;
            ctr1++;
        }
}

    taym sonra = clock();
    time_spent = (float)(sonra - once) / CLOCKS_PER_SEC;
    printf("\n %f seconds \n" , time_spent);
}

Sağolun, ama hoca struct yapısını kabul etmiyor.

esrarkesfil · 23 Ocak 2021

Kaba kodu bırakma şansınız var mı buraya? Anlamaya çalışalım belki yardımımız dokunabilir. İlk defa duydum diziyle kodlandığını çünkü.

Arawn920 · 23 Ocak 2021

esrarkesfil dedi:
Kaba kodu bırakma şansınız var mı buraya? Anlamaya çalışalım belki yardımımız dokunabilir. İlk defa duydum diziyle kodlandığını çünkü.

[CODE title="kaba kod"]Hedef sıralama: 1 3 9 23 45 85 98 153
Hedef sıralama ve mevcut sıralama elimizde var olduğunu varsayarak;
Liste başı=1 liste_başı_adres=6
Veri_bag= liste_başı_adres;
Döngü (eleman sayısı)
İkinci elemanı al (hedef dizi) [?]
Veri_adresi=Fonksiyon (Veri sütününda sayıyı ara)
Veri_bag[?]=veri_adres
Döngü_sonu

(?) Fonksiyon (?) //Veri sütününda sayıyı ara
Döngü (matris veri sütunu eleman sayısı kadar)
if (Aranan sayi == matris veri sütunundaki sayi)
Return verinin adresi
Döngü sonu
[/CODE]

[CODE title="kaba silme kodu"]int silinecek_eleman;
printf ("\n\nsilinecek elemani girin"), scanf("%d",&silinecek_eleman);
// silinecek elemanı arama
for(n=0;n<8;n++)
if (a[n][1]==silinecek_eleman)
break;

int silinecek_elemanin_adresi = n+1;
int silinecek_elemanin_bag_adresi = a[n][2];
printf ("\nsilinecek elemanin adresi %d silinecek elemanin bag adresi=%d",n+1,silinecek_elemanin_bag_adresi);
// silinecek elemanın bağ listesinde bulunması
for(n=0;n<8;n++)

if (a[n][2]==silinecek_elemanin_adresi)
break;
printf ("\nsilinecek elemanin adresini gosteren elemanin adresi %d, elemanin degeri %d",n+1,a[n][1]);
a[n][2] = silinecek_elemanin_bag_adresi;
a[silinecek_elemanin_adresi-1][2]=-99;
a[silinecek_elemanin_adresi-1][1]=-
[/CODE]

silme koduna bakarak ekleme kodunu yaparsınız dedi.

C Bağlı Liste(Linked List) Algoritmasına Veri Ekleme Nasıl Yapılır?

Ayrıntılı düzenleme

Arawn920

Hectopat

esrarkesfil

Kilopat

Arawn920

Hectopat

LayThese

Kilopat

Arawn920

Hectopat

esrarkesfil

Kilopat

Arawn920

Hectopat

Benzer konular

Yeni konular

Yeni mesajlar

Gizliliğinize önem veriyoruz