Stack Uygulamaları Applications

#include <stdio.h>
#include <string.h>

#define MAX 256

typedef struct {
    char items[MAX];
    int  top;
} CharStack;

void olustur(CharStack* s)      { s->top = -1; }
int  isEmpty(CharStack* s)      { return s->top == -1; }
void push(CharStack* s, char c) { s->items[++s->top] = c; }
char pop(CharStack* s)           { return s->items[s->top--]; }

/* ── Açma parantezi mi? ── */
int acmaMi(char c) {
    return c == '(' || c == '[' || c == '{';
}

/* ── Kapama parantezi mi? ── */
int kapamaMi(char c) {
    return c == ')' || c == ']' || c == '}';
}

/* ── Eşleşme kontrolü ── */
int eslesiyorMu(char acma, char kapama) {
    return (acma == '(' && kapama == ')') ||
           (acma == '[' && kapama == ']') ||
           (acma == '{' && kapama == '}');
}

/* ════════════════════════════════
   ANA FONKSİYON: Parantez Dengeli mi?
   ════════════════════════════════ */
int dengeliMi(const char* ifade) {
    CharStack s;
    olustur(&s);

    for (int i = 0; ifade[i] != '\0'; i++) {
        char c = ifade[i];

        if (acmaMi(c)) {
            push(&s, c);           // Kural 2: açma → push
        }
        else if (kapamaMi(c)) {
            // Kural 3a: stack boşsa → fazla kapama
            if (isEmpty(&s)) {
                printf("  Hata: pozisyon %d — '%c' için eşleşme yok\n",
                       i, c);
                return 0;
            }

            char acma = pop(&s);
            // Kural 3b: tip uyuşmazlığı
            if (!eslesiyorMu(acma, c)) {
                printf("  Hata: pozisyon %d — '%c' ile '%c' eşleşmiyor\n",
                       i, acma, c);
                return 0;
            }
        }
        // Kural 4: parantez değilse → atla
    }

    // Kural 5: string bitti, stack boş mu?
    if (!isEmpty(&s)) {
        printf("  Hata: %d adet kapanmamış parantez\n", s.top + 1);
        return 0;
    }

    return 1;  // Dengeli ✓
}

int main() {
    const char* testler[] = {
        "{[()]}",                  // dengeli
        "a*(b+c)-{d/[e+f]}",       // dengeli (parantez dışı karakterler)
        "((()))",                   // dengeli
        "",                         // dengeli (boş string)
        "{[(])}",                   // dengesiz: tip uyuşmazlığı
        ")(",                       // dengesiz: fazla kapama
        "(()",                      // dengesiz: kapanmamış
        "([{((()))}])",             // dengeli (derin iç içe)
    };
    int n = sizeof(testler) / sizeof(testler[0]);

    for (int i = 0; i < n; i++) {
        printf("Test: \"%s\"\n", testler[i]);
        if (dengeliMi(testler[i]))
            printf("  ✓ Dengeli\n\n");
        else
            printf("  ✗ Dengesiz\n\n");
    }
    return 0;
}

Test: "{[()]}"
  ✓ Dengeli

Test: "a*(b+c)-{d/[e+f]}"
  ✓ Dengeli

Test: "((()))"
  ✓ Dengeli

Test: ""
  ✓ Dengeli

Test: "{[(])}"
  Hata: pozisyon 3 — '(' ile ']' eşleşmiyor
  ✗ Dengesiz

Test: ")("
  Hata: pozisyon 0 — ')' için eşleşme yok
  ✗ Dengesiz

Test: "(()"
  Hata: 1 adet kapanmamış parantez
  ✗ Dengesiz

Test: "([{((()))}])"
  ✓ Dengeli

#include <stdio.h>
#include <string.h>
#include <ctype.h>

#define MAX 256

/* ── Stack ── */
typedef struct { char items[MAX]; int top; } CharStack;
void olustur(CharStack* s)       { s->top = -1; }
int  isEmpty(CharStack* s)       { return s->top == -1; }
void push(CharStack* s, char c)  { s->items[++s->top] = c; }
char pop(CharStack* s)            { return s->items[s->top--]; }
char peek(CharStack* s)           { return s->items[s->top]; }

/* ── Öncelik ── */
int oncelik(char op) {
    switch (op) {
        case '+': case '-': return 1;
        case '*': case '/': return 2;
        case '^':           return 3;
        default:            return 0;
    }
}

/* ── Sağ ilişkilendirmeli mi? ── */
int sagIliskilendirme(char op) {
    return op == '^';
}

/* ════════════════════════════════
   INFIX → POSTFIX  (Shunting Yard)
   ════════════════════════════════ */
void infixToPostfix(const char* infix, char* postfix) {
    CharStack s;
    olustur(&s);
    int j = 0;  // postfix indeksi

    for (int i = 0; infix[i] != '\0'; i++) {
        char c = infix[i];

        // Boşlukları atla
        if (c == ' ') continue;

        // Kural 1: Operand → çıktıya
        if (isalnum(c)) {
            postfix[j++] = c;
        }
        // Kural 2: ( → push
        else if (c == '(') {
            push(&s, c);
        }
        // Kural 3: ) → ( bulana kadar pop
        else if (c == ')') {
            while (!isEmpty(&s) && peek(&s) != '(')
                postfix[j++] = pop(&s);
            if (!isEmpty(&s)) pop(&s);  // ( 'yi at
        }
        // Kural 4: Operatör
        else {
            while (!isEmpty(&s) && peek(&s) != '(' &&
                   (oncelik(peek(&s)) > oncelik(c) ||
                    (oncelik(peek(&s)) == oncelik(c) &&
                     !sagIliskilendirme(c))))
            {
                postfix[j++] = pop(&s);
            }
            push(&s, c);
        }
    }

    // Kural 5: Kalan operatörleri boşalt
    while (!isEmpty(&s))
        postfix[j++] = pop(&s);

    postfix[j] = '\0';
}

int main() {
    const char* testler[] = {
        "a+b*c",
        "(a+b)*c",
        "(a+b)*c-d/e",
        "a^b^c",
        "a+b*(c^d-e)^(f+g*h)-i",
    };
    int n = sizeof(testler) / sizeof(testler[0]);

    for (int i = 0; i < n; i++) {
        char sonuc[MAX];
        infixToPostfix(testler[i], sonuc);
        printf("Infix:   %s\n", testler[i]);
        printf("Postfix: %s\n\n", sonuc);
    }
    return 0;
}

Infix:   a+b*c
Postfix: abc*+

Infix:   (a+b)*c
Postfix: ab+c*

Infix:   (a+b)*c-d/e
Postfix: ab+c*de/-

Infix:   a^b^c
Postfix: abc^^

Infix:   a+b*(c^d-e)^(f+g*h)-i
Postfix: abcd^e-fgh*+^*+i-

/* ── String'i ters çevir ── */
void tersCevir(char* str) {
    int n = strlen(str);
    for (int i = 0; i < n / 2; i++) {
        char tmp = str[i];
        str[i] = str[n - 1 - i];
        str[n - 1 - i] = tmp;
    }
}

/* ── Parantezleri takas et ── */
void parantezTakas(char* str) {
    for (int i = 0; str[i]; i++) {
        if      (str[i] == '(') str[i] = ')';
        else if (str[i] == ')') str[i] = '(';
    }
}

/* ════════════════════════════════
   INFIX → PREFIX
   ════════════════════════════════ */
void infixToPrefix(const char* infix, char* prefix) {
    char temp[MAX];
    strcpy(temp, infix);

    // 1. Ters çevir
    tersCevir(temp);

    // 2. Parantezleri takas et
    parantezTakas(temp);

    // 3. Shunting Yard uygula (postfix'e dönüştür)
    char postfix[MAX];
    infixToPostfix(temp, postfix);

    // 4. Sonucu ters çevir → prefix
    tersCevir(postfix);
    strcpy(prefix, postfix);
}

// Kullanım:
char sonuc[MAX];
infixToPrefix("(a+b)*c", sonuc);
printf("%s\n", sonuc);   // *+abc

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

#define MAX 256

/* ── Stack (double) ── */
typedef struct { double items[MAX]; int top; } NumStack;
void   nOlustur(NumStack* s)          { s->top = -1; }
int    nIsEmpty(NumStack* s)          { return s->top == -1; }
void   nPush(NumStack* s, double v)  { s->items[++s->top] = v; }
double nPop(NumStack* s)             { return s->items[s->top--]; }

/* ── Operatör mü? ── */
int operatorMu(char c) {
    return c == '+' || c == '-' || c == '*' || c == '/' || c == '^';
}

/* ── İşlemi uygula ── */
double hesapla(double a, double b, char op) {
    switch (op) {
        case '+': return a + b;
        case '-': return a - b;
        case '*': return a * b;
        case '/':
            if (b == 0) { fprintf(stderr, "Sıfıra bölme!\n"); exit(1); }
            return a / b;
        case '^': return pow(a, b);
        default:  return 0;
    }
}

/* ════════════════════════════════
   POSTFİX DEĞERLENDİRME
   ════════════════════════════════ */
double postfixDegerlendir(const char* ifade) {
    NumStack s;
    nOlustur(&s);

    for (int i = 0; ifade[i] != '\0'; i++) {
        char c = ifade[i];

        // Boşlukları atla
        if (c == ' ') continue;

        // Sayı → stack'e push
        if (isdigit(c)) {
            double sayi = 0;
            while (isdigit(ifade[i])) {
                sayi = sayi * 10 + (ifade[i] - '0');
                i++;
            }
            i--;  // for döngüsü de artıracak
            nPush(&s, sayi);
        }
        // Operatör → iki operand pop et, hesapla, push et
        else if (operatorMu(c)) {
            double b = nPop(&s);   // ← önce sağ operand
            double a = nPop(&s);   // ← sonra sol operand
            double sonuc = hesapla(a, b, c);
            nPush(&s, sonuc);
        }
    }

    return nPop(&s);  // son eleman = sonuç
}

int main() {
    const char* testler[] = {
        "3 4 + 2 * 7 -",       // (3+4)*2-7 = 7
        "5 1 2 + 4 * + 3 -",   // 5+(1+2)*4-3 = 14
        "2 3 ^ 4 +",            // 2^3+4 = 12
        "15 7 1 1 + - / 3 * 2 1 1 + + -",  // karmaşık = 5
    };
    int n = sizeof(testler) / sizeof(testler[0]);

    for (int i = 0; i < n; i++) {
        double sonuc = postfixDegerlendir(testler[i]);
        printf("Postfix: %-35s → %.2f\n", testler[i], sonuc);
    }
    return 0;
}

Postfix: 3 4 + 2 * 7 -                     → 7.00
Postfix: 5 1 2 + 4 * + 3 -                 → 14.00
Postfix: 2 3 ^ 4 +                         → 12.00
Postfix: 15 7 1 1 + - / 3 * 2 1 1 + + -    → 5.00

#include <stdio.h>
#include <string.h>

#define MAX 100

/* ── Karakter Stack ── */
typedef struct { char items[MAX]; int top; } CStack;
void csOlustur(CStack* s)      { s->top = -1; }
int  csIsEmpty(CStack* s)      { return s->top == -1; }
void csPush(CStack* s, char c) { s->items[++s->top] = c; }
char csPop(CStack* s)           { return s->items[s->top--]; }
void csTemizle(CStack* s)      { s->top = -1; }

/* ── Editör Durumu ── */
typedef struct {
    char   metin[MAX];   // mevcut metin
    int    uzunluk;      // metin uzunluğu
    CStack undo;         // geri alma yığını
    CStack redo;         // yineleme yığını
} Editor;

void editorOlustur(Editor* e) {
    e->metin[0] = '\0';
    e->uzunluk = 0;
    csOlustur(&e->undo);
    csOlustur(&e->redo);
}

/* ── Karakter yaz ── */
void yaz(Editor* e, char c) {
    e->metin[e->uzunluk++] = c;
    e->metin[e->uzunluk] = '\0';
    csPush(&e->undo, c);
    csTemizle(&e->redo);   // yeni dal → redo sıfırla
    printf("  Yaz '%c' → \"%s\"\n", c, e->metin);
}

/* ── Geri al ── */
void geriAl(Editor* e) {
    if (csIsEmpty(&e->undo)) {
        printf("  Undo: geri alınacak işlem yok\n");
        return;
    }
    char c = csPop(&e->undo);
    e->metin[--e->uzunluk] = '\0';
    csPush(&e->redo, c);
    printf("  Undo '%c' → \"%s\"\n", c, e->metin);
}

/* ── Yinele ── */
void yinele(Editor* e) {
    if (csIsEmpty(&e->redo)) {
        printf("  Redo: yinelenecek işlem yok\n");
        return;
    }
    char c = csPop(&e->redo);
    e->metin[e->uzunluk++] = c;
    e->metin[e->uzunluk] = '\0';
    csPush(&e->undo, c);
    printf("  Redo '%c' → \"%s\"\n", c, e->metin);
}

int main() {
    Editor e;
    editorOlustur(&e);

    printf("=== Yazma ===\n");
    yaz(&e, 'M');
    yaz(&e, 'e');
    yaz(&e, 'r');

    printf("\n=== Undo ===\n");
    geriAl(&e);
    geriAl(&e);

    printf("\n=== Redo ===\n");
    yinele(&e);

    printf("\n=== Yeni yazma (redo silinir) ===\n");
    yaz(&e, 's');
    yinele(&e);   // redo boş

    return 0;
}

=== Yazma ===
  Yaz 'M' → "M"
  Yaz 'e' → "Me"
  Yaz 'r' → "Mer"

=== Undo ===
  Undo 'r' → "Me"
  Undo 'e' → "M"

=== Redo ===
  Redo 'e' → "Me"

=== Yeni yazma (redo silinir) ===
  Yaz 's' → "Mes"
  Redo: yinelenecek işlem yok