Recent Changes - Search:

Oktatás

* Programozás 1
  + feladatsor
  + GitHub oldal

* Szkriptnyelvek
  + feladatsor
  + quick link

Teaching

* Programming 1 (BI)
  ◇ exercises
  ◇ quick link

* Scripting Languages
  ◇ exercises
  ◇ quick link

teaching assets


Félévek

* aktuális (2023/24/2)
* archívum


Linkek

* kalendárium
   - munkaszüneti napok '20
* tételsorok
* jegyzetek
* szakdolgozat / PhD
* ösztöndíjak
* certificates
* C lang.
* C++
* C#
* Clojure
* D lang.
* Java
* Nim
* Scala


[ edit | logout ]
[ sandbox | passwd ]

C /

sor megvalósítása szétszórt ábrázolással

#############################

Sort szintén nagyon egyszerűen tudunk láncolt listával megvalósítani. Érdemes két mutatót használni: a fejmutató a sor első elemére, míg a vége mutató a sor utolsó elemére mutat.

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

typedef struct listaelem
{
    int adat;
    struct listaelem *kov;
} LISTAELEM;

LISTAELEM *fej = NULL;
LISTAELEM *vege = NULL;

/* ************************************* */

// üres-e a sor
int empty() {
    return (fej == NULL);
}

// elem betétele
void push(int szam)
{
    LISTAELEM *uj = (LISTAELEM *)malloc(sizeof(LISTAELEM));
    uj->adat = szam;
    uj->kov = NULL;

    if (fej == NULL) {    // üres a sor, ez lesz az első elem
        fej = uj;
        vege = uj;
    }
    else                  // nem üres, van benne legalább egy elem
    {
        vege->kov = uj;
        vege = uj;
    }
}

// visszaadja a sor elején lévő elem értékét ÉS ki is veszi ezt az elemet a sorból
int pop()
{
    // ha üres a sor
    if (empty()) {
        // a feladattól függ, hogy egy ilyen esetet hogyan kezelünk le
        fprintf(stderr, "Hiba: üres a sor!");
        return -1;
    }
    // else, nem üres

    int eredmeny = fej->adat;

    // 1-elemű a sor
    if (fej == vege)
    {
        free(fej);
        fej = NULL;
        vege = NULL;
    }
    else    // legalább 2-elemű
    {
        LISTAELEM *akt = fej;
        fej = fej->kov;
        free(akt);
    }

    return eredmeny;
}

int main()
{
    int tomb[] = {1, 8, 5, 9, 2, 3, 4, 9};
    int meret = sizeof(tomb) / sizeof(int);
    int i;

    /* tömb elemei */
    printf("beszúrandó elemek: ");
    for (i = 0; i < meret; ++i)
    {
        printf("%d ", tomb[i]);
    }
    printf("\n");

    /* elemek beszúrása a sorba */
    for (i = 0; i < meret; ++i) {
        push(tomb[i]);
    }

    /* kivétel a sorból */
    puts("a sor elemei:");
    while (!empty())              // amíg nem üres, addig veszegetünk ki
    {
        printf("%d\n", pop());    // elem kivétele
    }

    printf("fejmutató: %p\n", fej);
    printf("vége mutató: %p\n", vege);

    return 0;
}

A fenti program a köv. kimenetet produkálja:

beszúrandó elemek: 1 8 5 9 2 3 4 9 
a sor elemei:
1
8
5
9
2
3
4
9
fejmutató: (nil)
vége mutató: (nil)

A végén az összes elemet kivettük, így a két mutató értéke NIL lett; újra lettek inicializálva.

Cloud City

  

Blogjaim, hobbi projektjeim

* The Ubuntu Incident
* Python Adventures
* @GitHub
* heroku
* extra
* haladó Python
* YouTube listák


Debrecen | la France


[ edit ]

Edit - History - Print *** Report - Recent Changes - Search
Page last modified on 2015 May 09, 11:13