Anzeige

VBA
Programmierer
gesucht?
 
Anzeige
VBA Programmierer gesucht?
 

Einfache C/C++ Beispiele für Einsteiger

Einfache Übung zur verketteten Liste

Stichwörter: Arrays, Pointer, Structs, verkettete Liste, Felder

Es sollen folgende Funktionen zur Verwendung einer verketteten Liste realisiert werden:
      - Ausgeben der Liste
      - Elemente vorne anfügen
      - Elemente hinten anhängen
      - Elemente zählen
      - Erstes Element löschen
      - Letztes Element löschen
      - Wert suchen und Adresse zurückgeben
      - Wert in der Liste auf Null setzen

// ************************************************************************************************
// Autor/en: http://www.online-vba.de - Marc Wershoven
// Verwendung der Quelltexte auf eigene Gefahr!
// Es gelten die Nutzungsbedingungen von www.Online-VBA.de!
// Original-Quelltext: www.online-vba.de/cpp_vkliste.php
// ************************************************************************************************

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

// *************** PROTOTYPEN ***************
void gebeaus(struct vk * p);
void haengevornean(struct vk ** p, int);
void haengehintenan(struct vk **, int);
int elementezaehlen(struct vk * p);
void loeschevorne(struct vk ** p);
void loeschehinten(struct vk ** p);
struct vk * suchewert(struct vk * p, int zahl);
int loeschewert(struct vk * p, int zahl);
struct vk
{
     int wert;
     struct vk *nf; //Nachfolgeradresse
};
// ******************************************

void main()
{
     int suchwert;
     //Anlegen des Startpointers
     struct vk *start=(struct vk *)malloc(sizeof(struct vk));
     struct vk *kopie;
     start->nf =NULL;
     start->wert=0;
     printf("Liste wurde initialisiert mit 1 Element.\n");
     //Ausgabe aller Kettenelemente
     gebeaus(start);
     //1 Element vorne einfügen
     printf("An die Liste wird 1 Element vorne angehangen.\n");
     haengevornean(&start,1);
     gebeaus(start);
     //1 Element hinten anhaengen
     printf("An die Liste werden 4 Element hinten angehangen.\n");
     kopie=start; //Sichern des Originalpointers
     haengehintenan(&kopie,2);
     gebeaus(start);
     //1 Element hinten anhaengen
     kopie=start; //Sichern des Originalpointers
     haengehintenan(&kopie,7);
     gebeaus(start);
     //1 Element hinten anhaengen
     kopie=start; //Sichern des Originalpointers
     haengehintenan(&kopie,12);
     gebeaus(start);
     //1 Element hinten anhaengen
     kopie=start; //Sichern des Originalpointers
     haengehintenan(&kopie,100);
     gebeaus(start);
     //Zählen der vorhandenen Elemente in der Liste
     printf("Anzahl der Elemente in der Liste: %i\n",elementezaehlen(start));
     //1. Element löschen
     loeschevorne(&start);
     printf("Loeschung des 1.Elements.\n");
     gebeaus(start);
     //letztes Element löschen
     kopie=start; //Sichern des Originalpointers
     loeschehinten(&kopie);
     printf("Loeschung des letzten Elements.\n");
     gebeaus(start);
     //Suche einen Wert
     suchwert=7;
     printf("S: %i E: %p W: %i\n",suchwert,suchewert(start,suchwert),*suchewert(start,suchwert));
     //Suche einen Wert
     suchwert=12;
     printf("Suche %i und ersetze durch 0. Erg: %i (1=geloescht).\n",suchwert,loeschewert(start,suchwert));
     gebeaus(start);
}

void gebeaus(struct vk * p)
{
     printf("Listeninhalt: ");
     if(p==NULL)
         printf("...\n");
     else
     {
         while(p!=NULL)
         {
             printf("%5i",p->wert);
             p=p->nf;
         }
     }
     printf("\n");
}

void haengevornean(struct vk ** p, int zahl)
{
     struct vk * kopie = *p; //Sicherung Startadresse 1.Element
     *p =(struct vk *)malloc(sizeof(struct vk)); //Neues Element einfügen
     (*p)->wert=zahl; //Wertzuweisung
     (*p)->nf=kopie; //Adresszuweisung
}

void haengehintenan(struct vk ** p, int zahl)
{
     while(!(*p)->nf ==NULL)
         *p=(*p)->nf;
     (*p)->nf =(struct vk *)malloc(sizeof(struct vk));
     (*p)=(*p)->nf;
     (*p)->wert =zahl;
     (*p)->nf =NULL;
}

int elementezaehlen(struct vk * p)
{
     int zaehler=0;
     if(p==NULL)
         return 0;
     else
     {
         while(p!=NULL)
         {
             zaehler++;
             p=p->nf;
         }
     }
     return zaehler;
}

void loeschevorne(struct vk ** p)
{
     (*p)=(*p)->nf; //überschreiben der Adresse des 1.Elements mit der des 2.
}

void loeschehinten(struct vk ** p)
{
     while(!(*p)->nf->nf ==NULL)
         *p=(*p)->nf;
     (*p)->nf=NULL;
}

struct vk * suchewert(struct vk * p, int zahl)
{
     int zaehler=0;
     if(p==NULL)
         return NULL;
     else
     {
         while(p!=NULL)
         {
             zaehler++;
             p=p->nf;
             if (p->wert == zahl)
                 return p;
         }
     }
     return NULL;
}

int loeschewert(struct vk * p, int zahl)
{
     int zaehler=0;
     if(p==NULL)
         return 0;
     else
     {
         while(p!=NULL)
         {
             zaehler++;
             p=p->nf;
             if (p->wert == zahl)
             {
                 p->wert =0;
                 return 1;
             }
         }
     }
     return 0;
}



Autor: Marc Wershoven (2001)

Zum Seitenanfang