Stack Uygulamaları - Implementations

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

#define MAX 100

typedef struct {
    int items[MAX];   // sabit boyutlu dizi
    int top;           // tepedeki elemanın indeksi
} Stack;

/* ── Temel Operasyonlar ── */

void stackOlustur(Stack* s) { s->top = -1; }
int  isEmpty(Stack* s) { return s->top == -1; }
int  isFull(Stack* s)  { return s->top == MAX - 1; }
int  size(Stack* s)    { return s->top + 1; }

void push(Stack* s, int val) {
    if (isFull(s)) {
        fprintf(stderr, "Stack Overflow!\n");
        return;
    }
    s->items[++s->top] = val;
}

int pop(Stack* s) {
    if (isEmpty(s)) {
        fprintf(stderr, "Stack Underflow!\n");
        return -1;
    }
    return s->items[s->top--];
}

int peek(Stack* s) {
    if (isEmpty(s)) {
        fprintf(stderr, "Stack boş!\n");
        return -1;
    }
    return s->items[s->top];
}

void stackYazdir(Stack* s) {
    printf("[");
    for (int i = s->top; i >= 0; i--)
        printf("%d%s", s->items[i], i > 0 ? ", " : "");
    printf("] (top→bottom, boyut=%d)\n", size(s));
}

#define BASLANGIC_KAP 4

typedef struct {
    int* items;       // heap'te dinamik dizi
    int top;
    int kapasite;
} DStack;

void dstackOlustur(DStack* s) {
    s->items = (int*)malloc(BASLANGIC_KAP * sizeof(int));
    if (!s->items) { perror("malloc"); exit(1); }
    s->top = -1;
    s->kapasite = BASLANGIC_KAP;
}

/* ── Büyütme ── */
static void buyut(DStack* s) {
    int yeniKap = s->kapasite * 2;
    int* yeni = (int*)realloc(s->items, yeniKap * sizeof(int));
    if (!yeni) { perror("realloc"); exit(1); }
    s->items = yeni;
    s->kapasite = yeniKap;
}

/* ── Küçültme (opsiyonel) ── */
static void kucult(DStack* s) {
    if (s->kapasite <= BASLANGIC_KAP) return;
    if (s->top + 1 > s->kapasite / 4) return;
    s->kapasite /= 2;
    s->items = (int*)realloc(s->items, s->kapasite * sizeof(int));
}

void dpush(DStack* s, int val) {
    if (s->top == s->kapasite - 1) buyut(s);
    s->items[++s->top] = val;
}

int dpop(DStack* s) {
    if (s->top == -1) { fprintf(stderr, "Underflow!\n"); return -1; }
    int val = s->items[s->top--];
    kucult(s);
    return val;
}

int dpeek(DStack* s) {
    if (s->top == -1) { fprintf(stderr, "Boş!\n"); return -1; }
    return s->items[s->top];
}

void dstackSerbest(DStack* s) {
    free(s->items);
    s->items = NULL; s->top = -1; s->kapasite = 0;
}

typedef struct {
    void** items;     // void* dizisi: her slot bir pointer tutar
    int top;
    int kapasite;
} GenericStack;

void gsOlustur(GenericStack* s, int kap) {
    s->items = (void**)malloc(kap * sizeof(void*));
    s->top = -1;
    s->kapasite = kap;
}

void gsPush(GenericStack* s, void* veri) {
    if (s->top == s->kapasite - 1) {
        s->kapasite *= 2;
        s->items = (void**)realloc(s->items,
                   s->kapasite * sizeof(void*));
    }
    s->items[++s->top] = veri;
}

void* gsPop(GenericStack* s) {
    if (s->top == -1) return NULL;
    return s->items[s->top--];
}

// Kullanım:
GenericStack gs;
gsOlustur(&gs, 4);

int a = 42; float b = 3.14; char* c = "Merhaba";

gsPush(&gs, &a);   // int pointer push
gsPush(&gs, &b);   // float pointer push
gsPush(&gs, c);    // string pointer push

char*  str = (char*)gsPop(&gs);   // "Merhaba"
float* fp  = (float*)gsPop(&gs);  // → 3.14

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

/* ═══ Sabit Dizi Stack ═══ */
#define MAX 5

typedef struct {
    int items[MAX];
    int top;
} Stack;

void stackOlustur(Stack* s) { s->top = -1; }
int  isEmpty(Stack* s)      { return s->top == -1; }
int  isFull(Stack* s)       { return s->top == MAX - 1; }

void push(Stack* s, int val) {
    if (isFull(s)) { printf("  ⚠ Overflow!\n"); return; }
    s->items[++s->top] = val;
    printf("  push(%d) → top=%d\n", val, s->top);
}

int pop(Stack* s) {
    if (isEmpty(s)) { printf("  ⚠ Underflow!\n"); return -1; }
    int val = s->items[s->top--];
    printf("  pop() → %d, top=%d\n", val, s->top);
    return val;
}

/* ═══ Dinamik Dizi Stack ═══ */
typedef struct {
    int* items;
    int top, kapasite;
} DStack;

void dOlustur(DStack* s, int kap) {
    s->items = (int*)malloc(kap * sizeof(int));
    s->top = -1; s->kapasite = kap;
}

void dPush(DStack* s, int val) {
    if (s->top == s->kapasite - 1) {
        s->kapasite *= 2;
        s->items = (int*)realloc(s->items,
                   s->kapasite * sizeof(int));
        printf("  ↑ kapasite → %d\n", s->kapasite);
    }
    s->items[++s->top] = val;
    printf("  dPush(%d) → top=%d\n", val, s->top);
}

int main() {
    /* ── Sabit dizi demo ── */
    printf("=== Sabit Dizi Stack (MAX=%d) ===\n", MAX);
    Stack s;
    stackOlustur(&s);
    for (int i = 1; i <= 6; i++)
        push(&s, i * 10);   // 6. → overflow
    printf("\n");
    while (!isEmpty(&s)) pop(&s);
    pop(&s);   // underflow

    /* ── Dinamik dizi demo ── */
    printf("\n=== Dinamik Dizi Stack (başlangıç=2) ===\n");
    DStack ds;
    dOlustur(&ds, 2);
    for (int i = 1; i <= 10; i++)
        dPush(&ds, i * 10);
    printf("  Son kapasite: %d\n", ds.kapasite);
    free(ds.items);

    return 0;
}

=== Sabit Dizi Stack (MAX=5) ===
  push(10) → top=0
  push(20) → top=1
  push(30) → top=2
  push(40) → top=3
  push(50) → top=4
  ⚠ Overflow!

  pop() → 50, top=3
  pop() → 40, top=2
  pop() → 30, top=1
  pop() → 20, top=0
  pop() → 10, top=-1
  ⚠ Underflow!

=== Dinamik Dizi Stack (başlangıç=2) ===
  dPush(10) → top=0
  dPush(20) → top=1
  ↑ kapasite → 4
  dPush(30) → top=2
  dPush(40) → top=3
  ↑ kapasite → 8
  dPush(50) → top=4
  dPush(60) → top=5
  dPush(70) → top=6
  dPush(80) → top=7
  ↑ kapasite → 16
  dPush(90) → top=8
  dPush(100) → top=9
  Son kapasite: 16