One Engineer

Linked List Node Silme

Önceki yazılarımızda linked list ve linked list'te düğüm ekleme konularına değindik. Bu yazımızın konusu da linked list'ten node(düğüm) silme olacaktır.

Linked list'den düğüm silmek için aşağıdaki adımları takip edeceğiz:

Silinecek düğümden önceki düğümü bulun
Önceki düğümün next'ini değiştirin
Silinecek düğüm için free fonksiyonu ile belleği boşalt

Linked list'in her düğümü(node) malloc() kullanılarak dinamik olarak tahsis edildiğinden, silinecek olan düğüm için ayrılan belleği boşaltmak için free() fonksiyonu kullanılır.

Kod:

#include <stdio.h>
#include <stdlib.h>

// linked list düğümü
struct Node{
   int data;
   struct Node* next;
};

// linked list düğüm ekleme
void push(struct Node** head_ref,int new_data){
    struct Node* new_node = (struct Node*) malloc(sizeof (struct Node));
    new_node->data = new_data;
    new_node->next = (*head_ref);
    (*head_ref) = new_node;
}

// linked list düğüm silme
void deleteNode(struct Node** head_ref,int key){
    struct  Node *temp = *head_ref,*prev;
    // Eğer ilk düğüm silinecek olan key'i tutuyorsa
    if(temp != NULL && temp->data == key){
        *head_ref = temp->next;
        free(temp);
        return;
    }
    // silinecek olan düğüm aranır
    while (temp != NULL && temp->data != key){
        prev=temp;
        temp=temp->next;
    }
    // Eğer linked list'de key yoksa
    if (temp == NULL){
        return;
    }
    // düğümün linked list'teki bağlantısını kaldır
    prev->next = temp->next;
    free(temp); // free memory
}

void printList(struct Node* node){
    while (node!=NULL){
        printf("%d ",node->data);
        node = node->next;
    }
}
int main() {
    // boş linked list başlatılır
    struct Node* head = NULL;
    //linked list'e düğüm eklenir
    push(&head,3);
    push(&head,6);
    push(&head,4);
    push(&head,2);
    printf("Linked list:\n ");
    printList(head);
    // linked list'ten düğüm silinir
    deleteNode(&head,4);
    printf("\n4 silindikten sonra linked list: \n");
    printList(head);
    return 0;
}

Çıktı:

Linked list:

2 4 6 3

4 silindikten sonra linked list:

2 6 3

GitHub: https://github.com/sumeyyevarmis/linked-list-delete-node-n-c

C programlama ile ilgili olan diğer konulara aşağıdaki linkten ulaşabilirsiniz:

https://oneegineer.blogspot.com/p/c-dersleri_9.html

Kaynaklar:

https://www.geeksforgeeks.org/c-program-for-deleting-a-node-in-a-linked-list/

https://www.geeksforgeeks.org/linked-list-set-3-deleting-node/

https://www.programiz.com/dsa/linked-list-operations

https://www.log2base2.com/data-structures/linked-list/deleting-a-node-in-linked-list.html

Bu örnekte C programlama dilinde, kullanıcıdan alınan sayının tek sayımı yoksa çift sayı mı olduğunu bulan programı yazdık:

Kod: https://github.com/sumeyyevarmis/c-tek-cift-sayi

#include <stdio.h>

void tekcift(int x){

if(x%2==0){

printf("Cift");

}

else

printf("Tek");

}

int main() {

int sayi;

printf("Sayi giriniz: ");

scanf("%d",&sayi);

tekcift(sayi);

return 0;

}

---------

#include <stdio.h>

int main() {

int sayi;

printf("Sayi giriniz: ");

scanf("%d",&sayi);

if(sayi%2==0){

printf("Cift");

}

else

printf("Tek");

return 0;

}

Linked List Node Ekleme

Bir önceki yazımızda linked list oluşturmayı öğrendik. Bu yazıda linked list'e node(düğüm) ekleme işlemine değineceğiz.

Bir linked list'e düğm eklemenin 3 yöntemi vardır:

Linked List'in başına
Linked List'in sonuna
Linked List'de belirli bir düğümden sonra

1. Linked List'in Başına Node (düğüm) Ekleme

Eklenen yeni düğüm linked list'in başına eklenir ve yeni eklenen düğüm linked list'in head(başı) olur. Örneğin linked list'in elemanları 1, 2, 3 vardır. Bu linked list'in başına 0'ı eklersek; 0, 1, 2, 3 olur. Liste'nin başına düğüm ekleyen fonksiyon push() olarak adlandıralım. push() fonksiyonu parametre olarak linked list'in head(baş) pointer'ını ve yeni düğüm değerini almalıdır. Çünkü, push() fonksiyonu yeni düğümü head ile değiştirmelidir.

#include <stdio.h>
#include <stdlib.h>
// bir linked list düğümü
struct Node{
    int data;
    struct Node* next;
};

// bu fonksiyon, verilen düğümden başlayarak linked list'in içeriğini yazdırır
void printList(struct Node* n){
    while(n != NULL){
        printf(" %d",n->data);
        n = n->next;
    }
}

void push(struct Node** head_ref,int new_data){
    // yeni düğümü allocade etmek
    struct Node* new_node = (struct Node*) malloc(sizeof (struct Node));
    // yeni değeri al
    new_node->data = new_data;
    // yeni düğümü head yapmak
    new_node->next = (*head_ref);
    // yeni düğüme point etmek için head;
    (*head_ref) = new_node;
}

int main() {
    struct Node* head = NULL;
    struct Node* second = NULL;
    struct Node* third = NULL;

    // yığında 3 düğüm ayırmak
    head = (struct Node*) malloc(sizeof (struct Node));
    second = (struct Node*) malloc(sizeof (struct Node));
    third =(struct Node*) malloc(sizeof (struct Node));

    head->data = 1; // ilk düğüme değer atandı
    head->next =second; // ilk düğümü, ikinci düğüme bağladık

    second->data = 2; // ikinci düğüme değer atandı
    second->next = third; // ikinci düğümü, üçüncü düğüme bağladık

    third->data =3; // üçüncü düğüme değer atandı
    third->next = NULL;

    // fonksiyonu çağıralım
    push(&head,0);
    printList(head);

    return 0;
}

Çıktı:

0 1 2 3

2. Linked List'de Belirli Bir Node(düğüm) Sonra Node(düğüm) Ekleme

Bize bir düğüm için pointer verilir ve yeni düğüm, verilen düğümden sonra eklenir. Örneğin linked list'in elemanları 1, 2, 3 vardır. Linked list'te 2'den sonra 5 değerini ekleriz ve sonuç 1, 2, 5, 3 olur. Belirli bir düğümden sonra düğüm eklemek için:

İlk olarak verilen düğümün NULL olup olmadığı kontrol edilir
Yeni düğüm atanır
Veriler yeni düğüme atanır
Yeni düğümün next'ini sonraki düğüme point etmelidir. Önceki düğümün nexti'i yeni düğüme point etmelidir.

#include <stdio.h>
#include <stdlib.h>
// bir linked list düğümü
struct Node{
    int data;
    struct Node* next;
};

// bu fonksiyon, verilen düğümden başlayarak linked list'in içeriğini yazdırır
void printList(struct Node* n){
    while(n != NULL){
        printf(" %d",n->data);
        n = n->next;
    }
}

// bir düğümden sonra düğüm ekleme
void insertAfter(struct Node* prev_node, int new_data){
    // verilen düğüm kontrol edilir
    if(prev_node == NULL){
        printf("Verilen node NULL olamaz");
        return;
    }
    // yeni düğüm allocate edilir
    struct Node* new_node = (struct Node*) malloc(sizeof (struct Node));
    // yeni değer alınır
    new_node->data=new_data;
    // yeni düğümün next'i, önceki düğümün next'i yapılır
    new_node->next = prev_node->next;
    // önceli düğümün next'i, yeni düğüm yapılır
    prev_node->next= new_node;
}
int main() {
    struct Node* head = NULL;
    struct Node* second = NULL;
    struct Node* third = NULL;

    // yığında 3 düğüm ayırmak
    head = (struct Node*) malloc(sizeof (struct Node));
    second = (struct Node*) malloc(sizeof (struct Node));
    third =(struct Node*) malloc(sizeof (struct Node));

    head->data = 1; // ilk düğüme değer atandı
    head->next =second; // ilk düğümü, ikinci düğüme bağladık

    second->data = 2; // ikinci düğüme değer atandı
    second->next = third; // ikinci düğümü, üçüncü düğüme bağladık

    third->data =3; // üçüncü düğüme değer atandı
    third->next = NULL;

    // fonksiyonu çağıralım
    insertAfter(head->next,5);
    printList(head);

    return 0;
}

Çıktı:

1 2 5 3

3. Linked List'in Sonuna Node Ekleme

Yeni düğüm, linked list'in sonuna eklenir. Örneğin linked list'in elemanları 1, 2, 3 vardır. Bu linked list'i sonuna 4 ekleriz ve sonuç 1, 2, 3, 4 olur.

#include <stdio.h>
#include <stdlib.h>
// bir linked list düğümü
struct Node{
    int data;
    struct Node* next;
};

// bu fonksiyon, verilen düğümden başlayarak linked list'in içeriğini yazdırır
void printList(struct Node* n){
    while(n != NULL){
        printf(" %d",n->data);
        n = n->next;
    }
}
// sona düğüm eklemek
void append(struct Node** head_ref, int new_data){
    // yeni düğüm allocate edilir
    struct Node* new_node = (struct Node*) malloc(sizeof (struct Node));
    struct Node *last = *head_ref;

    // yeni değer alınır
    new_node->data = new_data;
    // bu düğüm son düğüm olduğu için, next'i NULL yapılır
    new_node->next = NULL;
    // Eğer linked list boş ise yeni düğüm head yapılır
    if(*head_ref == NULL){
        *head_ref = new_node;
        return;
    }
    // Linked list boş değilse son düğüme geçiş yapılır
    while (last->next != NULL){
        last = last->next;
    }
    // son düğümün next'i yeni düğüm yapılır
    last->next = new_node;
    return;
}

int main() {
    struct Node* head = NULL;
    struct Node* second = NULL;
    struct Node* third = NULL;

    // yığında 3 düğüm ayırmak
    head = (struct Node*) malloc(sizeof (struct Node));
    second = (struct Node*) malloc(sizeof (struct Node));
    third =(struct Node*) malloc(sizeof (struct Node));

    head->data = 1; // ilk düğüme değer atandı
    head->next =second; // ilk düğümü, ikinci düğüme bağladık

    second->data = 2; // ikinci düğüme değer atandı
    second->next = third; // ikinci düğümü, üçüncü düğüme bağladık

    third->data =3; // üçüncü düğüme değer atandı
    third->next = NULL;

    // fonksiyonu çağıralım
    append(&head,4);
    printList(head);

    return 0;
}

Çıktı:

1 2 3 4

GitHub link: https://github.com/sumeyyevarmis/linked-list-add-node-in-c

C programlama ile ilgili olan diğer konulara aşağıdaki linkten ulaşabilirsiniz:

https://oneegineer.blogspot.com/p/c-dersleri_9.html

Kaynaklar

https://www.codesdope.com/blog/article/inserting-a-new-node-in-a-linked-list-in-c/

https://www.geeksforgeeks.org/linked-list-set-2-inserting-a-node/

https://www.programiz.com/dsa/linked-list-operations

Linked Lists (Bağlı listeler), uygulanması için pointer (işaretçi) kullanan dinamik veri yapısının en iyi ve en basit örneğidir ve yazılım dünyasında önemli yeri olan veri yapılarından biridir. Dizilerde olduğu başta kaç tane elemanın olduğunu belirtmek gerekmemektedir. Dizilerde yapılan eleman ekleme, silme işlemleri ve araya eleman ekleme işlemleri yapılabilir.

Ancak, pointer'ları anlamak linked list nasıl çalıştığını anlamak için çok önemlidir. Pointer konusu ile ilgili kafanızda soru işaretleri varsa pointer ile ilgili yazımızı inceleyebilirsiniz.

Linked list'ler, dizideki herhangi bir noktadan gerektiği büyüyüp küçülebilen bir dizi işlevi görür.

Linked list'lerin dizilere göre bazı avantajları vardır:

1- Dizilerde eleman ekleme, silme gibi işlemler linked list'lere göre performans açısından daha maliyetlidir. Linked list'lerde ise bu işlem sadece basit bir pointer işlemi ile yapılır ve kaydırma işlemlerine ihtiyaç kalmaz. Bu sayede performanstan kazanç sağlanır.

2- Linked list'ler dinamik veri yapılarıdır. Dizi tanımlaması yapılırken en başta veri boyutunu belirtmemiz gerekirken, linked list'lerde ise bu boyutu eleman ekleme ile artırabilir, eleman silme işlemleri ile boyutu küçültebiliriz.

Linked list'lerin dezavantajları:

1- Rastgele erişim yoktur. Dizideki n'inci öğeye, o öğeye kadar tüm öğeler üzerinde yineleme yapılmadan ulaşmak imkansızdır. Bu, listenin en başından başlamamız ve istenen öğeye ulaşana kadar listede kaç kez ilerlediğinizi saymanız gerektiği anlamına gelir.

2- Linked list'ler sadece veriyi değil, veri ile birlikte bir sonraki düğüme işaret eden pointer'ları da tuttuğu için dizilere göre hafızada daha fazla yer kaplar

Linked List (Bağlı Listeler) Nedir?

Bağlı liste, her node (düğüm) bir değer ve bir işaretçi içeren, dinamik olarak ayrılmış düğümler kümesidir. Pointer her zaman listenin bir sonraki üyesini işaret eder. Pointer NULL ise, listedeki son düğümdür.

Kısaca şöyle diyebiliriz; bağlı liste içerisinde bellek üzerinde tanımlanan elemanlar pointer yardımı ile birbirini takıp eden vagonlar gibi çalışır. Kendinden sonraki gelecek olan düğümün adresini tutar. Bu sayede, her düğüm kendinden sonraki gelecek olan düğümün yerini bilir. Bu özellikleri sayesinde, bellekte sıralanış şekli açısından esneklik sağlar.

Linked List Türleri

Simple Linked List: Bu tür linked list'de, listeyi yalnızca bir yönde hareket edebilir veya hareket ettirebilirsiniz.

Doubly Linked List: Bu tür linked list'de, listeyi her iki yönde de hareket ettirebilir veya çaprazlanabilir(ileri ve geri).

Circular Linked List: Bu tür linked list'de, bağlantılı listenin son düğümü, bir sonraki işaretçisinde bağlantılı listenin ilk/baş düğümünün bağlantısını içerir ve ilk/baş düğüm, bağlı listenin son düğümünün bağlantısını kendi içinde içerir.

Linked List'lerin Temsili

Linked list, linked list'in ilk düğümüne bir işaretçi ile temsil edilir. İlk düğüm, linked list'in başı olarak adlandırılır. Linked list boşsa, başlığın değeri NULL'u gösterir.

Listedeki her düğüm en az iki bölümden oluşur:

Bir veri öğesi(tamsayı, diziler veya herhangi bir veri türü).
Bir sonraki düğüme işaretçi(veya referans)(bu düğümü diğerine bağlar) veya başka bir düğüm adresi.

C'de yapıları(structures) kullanarak bir düğümü temsil edebiliriz. Aşağıda tamsayı verileriyle bağlantılı bir liste düğümü örneği verilmiştir.

// bir linked list düğümü
struct Node{
    int data;
    struct Node* next;
};

3 düğümlü basit bit linked list'in oluşturulması:

#include <stdio.h>
#include <stdlib.h>
// bir linked list düğümü
struct Node{
    int data;
    struct Node* next;
};


int main() {
    struct Node* head = NULL;
    struct Node* second = NULL;
    struct Node* third = NULL;

    // yığında 3 düğüm ayırmak
    head = (struct Node*) malloc(sizeof (struct Node));
    second = (struct Node*) malloc(sizeof (struct Node));
    third =(struct Node*) malloc(sizeof (struct Node));

    /* dinamik olarak 3 blok tahsis edilmiştir
     * Bu üç bloğa head, second ve third olarak işaretçilerimiz var
     *
      head           second           third
        |                |               |
        |                |               |
    +---+-----+     +----+----+     +----+----+
    | #  | #  |     | #  | #  |     |  # |  # |
    +---+-----+     +----+----+     +----+----+
     Herhangi bir rastgele değeri temsil eder.
     Veriler rastgele çünkü henüz bir şey atamadık.
     */

    head->data = 1; // ilk düğüme değer atandı
    head->next =second; // ilk düğümü, ikinci düğüme bağladık

    /* veriler, ilk bloğun data kısmına atanmıştır.
     * ve bloğun sonraki işaretçisi ikinciyi gösterir.
     * yani ikisi de bağlı
      head          second         third
        |              |              |
        |              |              |
    +---+---+     +----+----+     +-----+----+
    | 1  | o----->| #  | #  |     |  #  | #  |
    +---+---+     +----+----+     +-----+----+
     */

    second->data = 2; // ikinci düğüme değer atandı
    second->next = third; // ikinci düğümü, üçüncü düğüme bağladık

    /* veriler, ikinci bloğun data kısmına atanmıştır.
     * ve ikinci bloğun bir işaretçisi üçüncü bloğa işaret eder.
     * yani üç blok da birbirine bağlı.

     head         second         third
        |             |             |
        |             |             |
    +---+---+     +---+---+     +----+----+
    | 1  | o----->| 2 | o-----> |  # |  # |
    +---+---+     +---+---+     +----+----+
     */

    third->data =3; // üçüncü düğüme değer atandı
    third->next = NULL;

    /* veriler, üçüncü bloğun data kısmına atanmıştır.
     * ve üçüncü bloğun bir sonraki işaretçisi,
     * linked list'in burada bittiğini belirtmek için NULL yapılır.
     *
     * Linked list'imiz hazır
        head
             |
             |
        +---+---+     +---+---+       +----+------+
        | 1  | o----->|  2  | o-----> |  3 | NULL |
        +---+---+     +---+---+       +----+------+

        Tüm listeye temsil ulaşmak için yalnızca head'in yeterli olduğunu unutmayın.
        
     */
    return 0;
}

Şimdi oluşturduğumuz listeyi dolaşalım ve her düğümün verilerini ekrana yazdıralım. Geçişler için ve düğüm verilerini yazdıran genel amaçlı bir printList() fonksiyonu yazalım.

#include <stdio.h>
#include <stdlib.h>
// bir linked list düğümü
struct Node{
    int data;
    struct Node* next;
};

// bu fonksiyon, verilen düğümden başlayarak linked list'in içeriğini yazdırır
void printList(struct Node* n){
    while(n != NULL){
        printf(" %d",n->data);
        n = n->next;
    }
}

int main() {
    struct Node* head = NULL;
    struct Node* second = NULL;
    struct Node* third = NULL;

    // yığında 3 düğüm ayırmak
    head = (struct Node*) malloc(sizeof (struct Node));
    second = (struct Node*) malloc(sizeof (struct Node));
    third =(struct Node*) malloc(sizeof (struct Node));

    head->data = 1; // ilk düğüme değer atandı
    head->next =second; // ilk düğümü, ikinci düğüme bağladık

    second->data = 2; // ikinci düğüme değer atandı
    second->next = third; // ikinci düğümü, üçüncü düğüme bağladık

    third->data =3; // üçüncü düğüme değer atandı
    third->next = NULL;

    // fonksiyonu çağıralım
    printList(head);
    
    return 0;
}

Çıktı:

1 2 3

GitHub linki: https://github.com/sumeyyevarmis/linked-list-in-c/blob/main/single-linked-list.c

C programlama ile ilgili olan diğer konulara aşağıdaki linkten ulaşabilirsiniz:

https://oneegineer.blogspot.com/p/c-dersleri_9.html

Kaynaklar:

https://www.learn-c.org/en/Linked_lists

programiz.com/dsa/linked-list

https://www.edureka.co/blog/linked-list-n-c/

https://www.geeksforgeeks.org/linked-list-set-1-introduction/

https://www.studytonight.com/data-structures/linked-list-vs-array

Bilgisayar içerisinde tüm veriler bitler ile temsil edilir. Her bit yalnızca 0 veya 1 değerini alabilir. Çoğu sistemde 8 bit bir baytı oluşturur. Byte, char tipi için standart depolama birimidir. Diğer veri tipleri daha çok sayıda baytlar içinde saklanır. Bit operatörleri operandlarının bitlerini yönetmek için kullanılır. Bit operatörleriyle genellikle işaretsiz tamsayılar (unsigned int) kullanılır. Bit işlemleri doğası gereği makine-bağımlı olduğundan dolayı bu programlar sizin sisteminizde doğru olarak çalışmayabilir.

Bit operatörleri şunlardır: AND(&), OR( | ), EXCLUSIVE OR(^), sola kaydırma(<<), sağa kaydırma(>>) ve tümleyen(~).

AND(&): İki operandın ikisinin de ilgili bitlerinde 1 varsa sonuçtaki bitler 1 yapılır.

OR( | ): İki operandın ilgili bitlerinden en az biri 1 ise sonuçtaki bitler 1 yapılır.

EXCLUSI ve OR (^): Operandların ilgili bitlerinden yalnızca biri 1 ise sonuçtaki bitler 1 yapılır.

Sola kaydırma (<<): İlk operandındaki bitleri ikinci operandında belirtilen sayı kadar sola kaydırır. Sağdan itibaren 0 ile doldurulur.

Sağa kaydırma(>>): İlk operandındaki bitleri ikinci operandında belirtilen sayı kadar sağa kaydırır. Soldan itibaren yapılacak doldurma işlemciye bağlıdır.

Tümleyen (~): Tüm sıfır bitleri 1, tüm 1 bitleri 0 yapar

İşaretsiz (unsigned) Tam Sayıyı Bit olarak Yazdırma

Bit operatörlerini kullanırken, değerleri ikilik sistemde yazdırmak bu operatörlerin etkilerini gösterebilmek için oldukça kullanışlıdır.

Aşağıdaki örnek, unsigned bir tam sayıyı her biri 8 bitten oluşan gruplarla ikilik gösterimde yazdırmaktadır.

#include <stdio.h>

void displayBits(unsigned  int value);

int main(){
    unsigned int x;
    printf("%s","Enter a nonnegative int: ");
    scanf("%u",&x);
    displayBits(x);
}

void displayBits(unsigned  int value){
    unsigned int c; // sayıcı

    //displayMask'ı tanımlama ve 31 biti solo kaydırma
    unsigned int displayMask = 1 << 31;

    printf("%10u = ",value);
    for(c=1;c<=32;++c){
        putchar(value & displayMask ? '1' : '0');
        value <<=1; // 1 ile değeri sola kaydırma

        if(c % 8 == 0) { // 8 bitten sonraki yerin çıkışı
            putchar(' ');
        }
    }
    putchar('\n');
}

Ekran Çıktısı:

Enter a nonnegative int:65000

65000 = 00000000 00000000 11111101 11101000

displayBits fonksiyonu value ve displayMask değişkenlerini birleştirmek için bit AND operatörünü kullanır. Sıklıkla bit AND operatörü maske (belirli bitleri 1 değerine ayarlanmış bir tam sayı değeri) adı verilen bir operant kullanılır. Maskeler diğer bitleri seçerken bazı bitleri değer içinde saklamak için kullanılır. displayBits fonksiyonunda maske değişkeni displayMask şu değere atanmıştır;

1 << 31 (10000000 00000000 00000000 00000000)

Sola kaydırma operatörü, 1 değerini displayMask içindeki en düşük değerlikli (en sağdaki) bitten en yüksek değerlikli (en soldaki) bite doğru kaydırır ve sağdan itibaren bitleri o ile doldurur.

putchar(value & displayMask ? '1' : '0');

değişkenin en solundaki bit değerinin 0 ya da 1 olarak çıkarılmasına karar verir. value ve displayMask "&" kullanılarak birleştirilirse value değişkeninde en soldaki bit dışındaki bitler saklanır çünkü 0 ile biten bitler birbirine geçiş sağlar. Eğer en soldaki bit 1 ise value ve displayMask gerçek bir değer alır ve 1 ekrana yazılır aksi durumda 0 yazılır. Ardından value değişkeni bir sola kaydırılır value <<=1 ile. Atanmamış değişken value'da bu adımlar her bit için tekrarlanır .

Bitsel AND Operatörü (&)

Kullanılan iki operandın bitleri 1 ise, bitsel AND'in çıkışı 1'dir. Operandlardan herhangi biri 0 ise, bitsel AND'in çıkışı 0'dır.

12 ve 25 tamsayılarının bit düzeyinde AND işlemini inceleyelim:

12 = 00001100 (In Binary)
25 = 00011001 (In Binary)

Bit Operation of 12 and 25
  00001100
& 00011001
  ________
  00001000  = 8 (In decimal)

Örnek:

#include <stdio.h>
int main() {
    int a = 12, b = 25;
    printf("Output = %d", a&b);
    return 0;
}

Çıktı:

Output = 8

Bitsel OR Operatörü (|)

Kullanılan operadlardan en az biri 1 ise, bitsel Or'ın çıkışı 1'dir.

12 = 00001100 (In Binary)
25 = 00011001 (In Binary)

Bitwise OR Operation of 12 and 25
  00001100
| 00011001
  ________
  00011101  = 29 (In decimal)

Örnek:

#include <stdio.h>
int main() {
    int a = 12, b = 25;
    printf("Output = %d", a|b);
    return 0;
}

Çıktı:

Output = 29

Bitsel XOR (exclusive OR) Operatörü (^)

İki operandaki bitler zır ise, bitrsel XOR'un çıkışı 1 olur.

12 = 00001100 (In Binary)
25 = 00011001 (In Binary)

Bitwise XOR Operation of 12 and 25
  00001100
^ 00011001
  ________
  00010101  = 21 (In decimal)

Örnek:

#include <stdio.h>
int main() {
    int a = 12, b = 25;
    printf("Output = %d", a^b);
    return 0;
}

Çıktı:

Output = 21

Shift Operatörleri

C'de iki tane shift operatörü vardır: Right shift ve left shift

Rigth Shift Operatörü(>>)

Sağa kaydırma operatörü, tüm bitleri belirli sayıda belirtilen bit kadar sağa kaydırır.

212 = 11010100 (In binary)
212>>2 = 00110101 (In binary) [Right shift by two bits]
212>>7 = 00000001 (In binary)
212>>8 = 00000000 
212>>0 = 11010100 (No Shift)

Left Shift Opetatörü(<<)

Sola kaydırma operatörü, tüm bitleri belirli sayıda belirtilen bit kadar sola kaydırır. Sola kaydırma operatörü tarafından boşaltılan bit konumları 0 ile doldurulur.

212 = 11010100 (In binary)
212<<1 = 110101000 (In binary) [Left shift by one bit]
212<<0 = 11010100 (Shift by 0)
212<<4 = 110101000000 (In binary) =3392(In decimal)

Örnek

#include <stdio.h>
int main() {
    int num=212, i;
    for (i=0; i<=2; ++i) {
        printf("Right shift by %d: %d\n", i, num>>I);
    }
    printf("\n");

    for (i=0; i<=2; ++i) {
        printf("Left shift by %d: %d\n", i, num<<i);    
    }

    return 0;
}

Çıktı:


Right Shift by 0: 212
Right Shift by 1: 106
Right Shift by 2: 53

Left Shift by 0: 212
Left Shift by 1: 424
Left Shift by 2: 848

C programlama ile ilgili olan diğer konulara aşağıdaki linkten ulaşabilirsiniz:

https://oneegineer.blogspot.com/p/c-dersleri_9.html

Kaynaklar:

https://www.bilgigunlugum.net/prog/cprog/2c_veri

https://www.programmingsimplified.com/c/source-code/c-program-convert-decimal-to-binary

https://www.programiz.com/c-programming/bitwise-operators

https://www.javatpoint.com/bitwise-operator-in-c

Deitel Deitel C/C++

One Engineer

Featured

Linked List Node Silme

Linked List Node Ekleme

1. Linked List'in Başına Node (düğüm) Ekleme

2. Linked List'de Belirli Bir Node(düğüm) Sonra Node(düğüm) Ekleme

3. Linked List'in Sonuna Node Ekleme

Linked List (Bağlı Listeler) Nedir?

Linked List Türleri

Linked List'lerin Temsili

İşaretsiz (unsigned) Tam Sayıyı Bit olarak Yazdırma

Bitsel AND Operatörü (&)

Bitsel OR Operatörü (|)

Bitsel XOR (exclusive OR) Operatörü (^)

Shift Operatörleri

Rigth Shift Operatörü(>>)

Left Shift Opetatörü(<<)

Search This Blog

Sayfalar

Öne Çıkan Yayın

Csharp Class Yapısı Örnek Sorular

Follow Us!

Popular Posts

Kötüye Kullanım Bildir

Follow Us!