4. Text in Date soriteren ??

Text in Date soriteren ??

  • ?

    Hallo zusammen,
    Folgendes Problem, hab jetzt ne Programm geschrieben, dass Text in eine Datei schreibt. so sieht das bis jetzt aus:

    //#'''''''''''''''''''''''''''''''''''''''''''''''''''#//
//#    Liste erstellen und in Datei schreiben         #//
//#         Copyright by Matthias Plock               #//
//#                                                   #//
//#'''''''''''''''''''''''''''''''''''''''''''''''''''#//
#include <conio.h>
#include <stdio.h>
#include <stdlib.h>
#define BUF 255

FILE *fptr;
char data[BUF];
char data2[30];

void loeschen()
{
	printf("\n\nListe wird geloescht\n");
	fptr = fopen("liste.txt", "w"); // open and clear
	printf("\n\nListe terminiert\n\n");

   fclose(fptr);

}

void eingabe()
{
printf("\n\nDaten eingeben: ");

fptr = fopen("liste.txt", "a+"); // open and clear

gets(data);

fprintf(fptr,"%s\n", data);
  fclose(fptr);
}

void ausgabe()
{
int i=0;

printf("\n\nListe\n");

fptr = fopen("liste.txt", "r"); // open and clear

while(fgets(data,20,fptr) != NULL)
{
i++;
printf("#%3.i %s", i, data);
}
printf("\nDas Ende der Liste wurde erreicht, Press <any> key\n\n");
getch();
fclose(fptr);

}

void sortieren()
{
	int anz,k,i;
	fptr = fopen("liste.txt", "r");

   i=0;
   for(i=0; i<n-1; i++)
		while(fgets(data2, BUF ,fptr) != NULL)

   return NULL;
   i++;

   printf("\n%s", data);

   fclose(fptr);
	getch();
}

main()
{
	int nummer=0;
   printf("Datei ... Liste\n");
   printf("===============\n");
   do
   {
   printf("\n <1> Daten eingeben\n <2> Daten Ausgeben\n <3> Liste Loeschen\n <4> Liste Sortieren \n <5> Ende");

   nummer = getch();
   switch(nummer)
   {
   	case '1': eingabe();
      break;
   	case '2': ausgabe();
      break;
      case '3': loeschen();
      break;
		case '4': sortieren();
      break;
   	case '5': goto label1;
      default: printf("\nFalsche Eingabe");
   }

   }
     while(nummer !=3);

   getch();
   label1:0;
}

    ich möchte nun den Text in der Datei sortieren, kann mir da jemand helfen ?

    ______________
    MfG chaosLT 😃

    0
  • ?

    Keine Ahnung. Echtnicht!Echt nicht!
    Kevin Mitnick™

    0
  • L

    Hi

    chaosLT schrieb:

    ich möchte nun den Text in der Datei sortieren, kann mir da jemand helfen ?

    hast leider nicht geschrieben wie Du es sortiert haben möchtest 😕
    Falls du es Alphabetisch und der Länge nach sortieren möchtest empfehle ich Binäre Bäume.

    Etwa so:
    http://www.lucom-gmbh.de/web/side139.html&sid=2fe421f2fa2f9f631a42b05e90436360

    lies dir weiter unten alles über Bäume vor 🙂

    Beispielimplementierung: Einfügen in einen Baum und Ausgabe des Baums:

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

#define MAXLEN 80

struct tnode              /* Binaerbaum */
  {
  char word[MAXLEN];      /* Text */
  int count;              /* Zaehler */
  struct tnode *left;     /* linker Nachfolger */
  struct tnode *right;    /* rechter Nachfolger */
  };

struct tnode *talloc(void);
  /* Platz fuer einen tnode besorgen */

struct tnode *insert_tree(struct tnode *p,char *w);
  /* w bei oder nach p einfuegen */

void treeprint(struct tnode *p);
  /* Baum p rekursiv ausgeben */

int main(void)  
  {
  struct tnode *root;
  char word[MAXLEN];

  root = NULL;
  while ((gets(word)) != NULL)  /* Baum einlesen */
    root = insert_tree(root,word);

  printf("\n");
  treeprint(root);              /* Baum ausgeben */

  return(0);  
  }

struct tnode *talloc(void)
  /* Platz fuer einen tnode besorgen */
  {
  return((struct tnode *) malloc(sizeof(struct tnode)));
  }

struct tnode *insert_tree(struct tnode *p,char *w)
  /* w bei oder nach p einfuegen */
  {
  struct tnode *talloc();
  int cond;
  if (p == NULL) 
    {                           /* ein neues Wort */
    p = talloc();   /* einen neuen Knoten anlegen */
    strcpy(p->word, w);
    p->count = 1;
    p->left = NULL;
    p->right = NULL;
    } 
  else
    { 
    cond = strcmp(w, p->word);   /* Vergleich w mit Knoten */
    if (cond == 0)
      p->count++;               /* Wort w schon vorhanden */
    else if (cond < 0)         /* w ist kleiner, links darunter */
      p->left = insert_tree(p->left,w);
    else                        /* w ist groesser, rechts darunter */
      p->right = insert_tree(p->right,w);
    }
  return(p);
  }

void treeprint(struct tnode *p)
  /* Baum p rekursiv ausgeben */
  {
  if (p != NULL) 
    {
    treeprint(p->left);
    printf("%s (%4d)\n", p->word, p->count);
    treeprint(p->right);
    }
  }

Ein weiteres Beispiel: Das folgende Programm liest aus der Quellatei die Wörter und gibt sie lexikographisch sortiert mit Häufigkeitsangabe in die Zieldatei aus.

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

#define MAX_WORT 200

struct tnode 
  {
  char *wort;
  int zahl;
  struct tnode *links;
  struct tnode *rechts;
  };

typedef struct tnode knoten;

FILE *quelle, *ziel;

FILE *eopen(char *file,char *mode);
int lieswort(char *w, int lim);
knoten *suche(knoten *p, char *w);
inorder(knoten *p);
char *merke_wort(char *s);

int main(int argc, char *argv[]) 
  {   
  knoten *unterbaum, *suche();
  char progname[500];
  char wort [MAX_WORT];
  int c;
  progname = argv[0];
  if (argc != 3) 
    {
    fprintf(stderr,"Syntax: %s Quelldatei Zieldatei\n",progname);
    exit(1);
    }
  quelle = eopen(argv[1],"r");       
  unterbaum = NULL;
  while ((c = lieswort(wort, MAX_WORT)) != -1)
    if (c == 1)
      unterbaum = suche(unterbaum, wort);
  fclose(quelle);
  ziel = eopen(argv[2],"w");
  inorder(unterbaum);
  fclose(ziel);
  return 0;
  }

int lieswort(char *w, int lim) 
  /* lieswort  liest aus einer Datei ein Wort der Laenge lim in den
  ** Speicher, auf den w zeigt, und gibt 1 zurueck, falls es
  ** wirklich Alphazeichen gelesen hat, jedoch -1 im Fall zu
  ** grosser Wortlaenge. Falls Nicht-Alpha-Zeichen gelesen werden,
  ** wird 0 zurueckgegeben.
  */
  {   
  int c;

  while (!isalpha(c = getc(quelle))) 
    if (c == EOF) return -1;
  *w++ = c; 
  lim--;    

  while (isalpha(c = getc(quelle))  && (lim > 0)) 
    {    
    *w++ = c; lim--;   
    }
  if (lim == 0) 
    {     
    printf("%s: Error: Wort zu lang ", progname); 
    return -1; 
    }
  else 
    *w = '\0';
  if (lim < MAX_WORT) return 1; 
  else return 0;
  }

FILE *eopen(char *file,char *mode) 
  {
  FILE *fp, *fopen();

  if ( (fp = fopen(file, mode)) != NULL )
     return fp;
  fprintf(stderr, 
          "%s: Datei %s kann im Modus %s nicht geoeffnet werden\n",
          progname, file, mode);
  exit(1);
  }

knoten *suche(knoten *p, char *w)
  /* suche  durchsucht den Baum auf das Vorkommen des Wortes w,
  ** traegt es gegebenenfalls lexikographisch richtig ein bzw. erhoeht
  ** dessen Zahl und gibt den Pointer auf seinen Knoten zurueck.
  */
  {    
  int  cond;

  if (p == NULL) 
    {
    p = (knoten *) malloc(sizeof(knoten));
    p->wort = merke_wort(w);
    p->zahl = 1;
    p->links = p->rechts = NULL;
    }
  else if ((cond = strcmp(w, p->wort)) == 0)
    p->zahl++;
  else if (cond < 0)
    p->links = suche(p->links, w);
  else p->rechts = suche(p->rechts, w);
  return p ;
  }

inorder(knoten *p) 
  /* inorder  gibt den Unterbaum, auf den p zeigt, in Inorder aus.
  */
  {    
  if (p != NULL)
    {  
    inorder(p->links);
    fprintf( ziel, "%4d %s\n", p->zahl, p->wort);
    inorder(p->rechts);
    }
  }

char *merke_wort(char *s) 
  /*  merke_wort  speichert das Wort, auf dessen ersten Charakter s zeigt,
  **  und gibt einen Zeiger auf dessen neue Lokation an.
  */
  {   
  char *p;
  if ((p = (char *)malloc( strlen(s)+1 )) != NULL)
    strcpy(p, s);
  return p ;
  }

    mfg

    0
  • ?

    würds gerne zeilenweise alphabetisch sortieren,
    btw. das mit den bäumen sieht verdammt kompliiert aus 😞
    _________________
    greets chaosLT

    0
Anmelden zum Antworten