Duplikate nicht aufscheinen lassen - C

[0664jester]

danke.

ich hab den char pointer eine fixe länge gegeben:
char name[100];

 

[0664jester]

typedef struct llnode
{
  char *name;
  struct llnode *next;
 // struct node *prev;  
} llnode;
  
struct llnode *head = NULL;  //initialiere den head
 
 
void addFront(char *prasemi)
{
  struct llnode *tempnode1;
  tempnode1 = (struct llnode*)malloc(sizeof(struct llnode));
  strcpy(tempnode1 -> name, prasemi);

  
  
  if(head == NULL) 
  {
    head = tempnode1;
    head -> next = NULL;
  }
  else
 {
    while(memcmp(head, tempnode1, sizeof(&tempnode1) < 0 ))
    {
      head = tempnode1 -> next;
      if(memcmp(head, head -> next, sizeof(&tempnode1)) > 0 )
      {
        head = tempnode1 -> next;
      }
    }
  }
  
}

nach dem else in der while schleife habe ich irgendeinen wurm drinnen...
Kann mich jemand auf die sprünge helfen?

 

[Cromon]

Hallo 0664jester

Das hier ist weiter nicht legal:

  tempnode1 = (struct llnode*)malloc(sizeof(struct llnode));
  strcpy(tempnode1 -> name, prasemi);

String wird ins Nirvana kopiert. Verwende strdup und anschliessed free oder mache den Member name von einer statischen Grösse und stelle bei strcpy sicher, dass nicht mehr kopiert wird.

Was deine while-Schleife machen soll verstehe ich überhaupt nicht. Du vergleichst den Speicher des neu allozierten Nodes mit head, was bringt das? Das wird unter diesen Bedingungen immer verschieden sein, da next bei tempnode1 einen random (inkorrekten) Wert hat und name hat auch einen zufälligen inkorrekten Wert.

Innerhalb der Schleife verwendest du tempnode1->next für Head. Dies macht überhaupt keinen Sinn, next hat einen komplett zufälligen Wert, da du ja deinen allozierten Speicher nicht initialisierst, das dürfte also bereits im Ersten Schleifendurchgang einen Crash ergeben.

Was du (so vermute ich) machen willst ist folgendes:

struct llnode* tempnode1, *itr;
tempnode1 = (struct llnode*) malloc(sizeof(struct llnode));
tempnode1->name = strdup(prasemi);
tempnode1->next = NULL;

if(head == NULL) {
    head = tempnode1;
} else {
    itr = head;

    while(itr->next != NULL) {
        itr = itr->next;
    }

    itr->next = tempnode1;
}

Grüsse
Cromon

 

[0664jester]

danke für die hilfe

void anHaengen(char *prasemi)
{
  llnode *zeiger; //Zeiger für den Zugriff auf einzelne Elmente
  
  if(head == NULL) //gibt es schon ein Element in der Liste?
  {
     if((head = malloc(sizeof(struct llnode))) == NULL) 
     {
       printf("Kein Speicherplatz vorhanden fuer anfang\n");
       return;
     }
   strcpy(head->name, strdup(prasemi));  //Wenn nein
   head->next = NULL; 
  }
  else
  {
    zeiger = head;
    while(zeiger->next != NULL)
    {
      zeiger = zeiger->next;
      if((zeiger->next = malloc(sizeof(struct llnode))) == NULL) 
      {
        printf("Kein Speicherplatz für das letzte Element\n");
        return;
      }
      zeiger=zeiger->next;
      strcpy(zeiger->name,strdup(prasemi));
      zeiger->next=NULL;
    }
  }
}
//------------------------------------------------------------------------------
 
void sortList(char *prasemi)
{
    llnode *zeiger;
    llnode *zeiger1;
    
    if(head == NULL) //ist es das erste Element in der Liste?
    {
      anHaengen(prasemi);
    }
    else // Suche solange bis es gefunden wird
    {
      zeiger = head;
      while(zeiger != NULL && (strcmp(zeiger->name, strdup(prasemi))<0)) //abdef
      {
        zeiger = zeiger->next; //zeiger ist geht bis  vor d
      }
      if(zeiger == NULL) // wenn null ist dann hinten anhängen
      {
        anHaengen(prasemi);
      }
      else if(zeiger == head) //unser Elment das kleinste ist - vor head einfügen
      {
        zeiger = malloc(sizeof(struct llnode));
        if(NULL == head)
        {
          printf("Kein Speicher\n");
          return;
        }
        strcpy(head->name,strdup(prasemi));
        head->next=zeiger;
      }
      else //Element ist irgendwo in der Mitte
      {
        zeiger1 = head;
        while(zeiger1->next != zeiger)//suchen das Element das nicht vor Zeiger steht
        {
          zeiger1=zeiger1->next;
        }
        zeiger = malloc(sizeof(struct llnode));
        if(NULL==zeiger)
        {
          printf("Kein Speicher\n");
          return;
        }
      strcpy(zeiger->name,strdup(prasemi));
      zeiger->next = zeiger1->next;
      zeiger1->next = zeiger;
      }
  }
}

//------------------------------------------------------------------------------ 
void printList()
{
    struct llnode *currentnode;
    currentnode = head;
 
    while(currentnode != NULL)
    {
        printf("%s\n", currentnode->name);
        currentnode = currentnode->next;
    }
}

Output:
Amber Sally Hopkins
Grady Miller
Julian Reynolds
Roy Floyd
Tamara Robertson
CD6

Leider fehlt Kenneth Schneider und das CD6 sollte auch nicht sein...

 

[Cromon]

Hallo 0664jester

strcpy(head->name, strdup(prasemi));  //Wenn nein

Weitherin hat der neu allozierte Node kein Speicherplatz in name (ausser Name hat eine statische Grösse). Zudem hast du ein Speicherleck, der Zeiger, der von strdup zurückgegeben wird muss wieder freigegeben werden mit free.

    while(zeiger->next != NULL)
    {
      zeiger = zeiger->next;
      if((zeiger->next = malloc(sizeof(struct llnode))) == NULL)

Du hängst hier an jedes Element deinen Node an und erzeugst damit Speicherlecks und eine komplett falsche Liste.

Viele Grüsse
Cromon

 

[0664jester]

char name[100]; sieht so aus bei mir

llnode habe ich so abgehändert...

 if((head = (struct llnode*) malloc(sizeof(struct llnode))) == NULL) 
     {
       printf("Kein Speicherplatz vorhanden fuer anfang\n");
       return;

ich werde nochmal überprüfuen, wenn die liste leer, ob dort ein fehler eingeschlichen hat, weil da der erste nahme fehlt...

 

[Cromon]

Hallo 0664jester

Wie gesagt, der von dir gepostete Code weiter oben macht etwas ganz anderes als du möchtest.

Viele Grüsse
Cromon