Frage bei der Listen einfügen;

[fanbjs]

Hi Leute

Ich brauche Hilfe!!!

Ich hab eine Liste {1, 3, 6, 5, 8, 9, 7, 9}

Ich muss ein bestimmnten Element mitten in die Liste einfügen;

Zm Beipiel:
1: 00000001;
2: 00000010;

Criterium:
Der eingefügte Element muss mit dem gesuchten Element nur ein Bit Unterschied haben, dann muss Ich der Element nach dem gesuchtem Element einfügen;

Wo kann Ich bei in Programm (Einfügen in die Liste), diese Bedingung einfügen ?

Im Voraus Vielen Dank

lena

[MFK]

Wenn es dir darum geht, festzustellen, wie viele Bits unterschiedlich sind: Bitweise Exklusiv-Oder-verknüpfen (^) und die Bits des Ergebnisses zählen.

[fanbjs]

Vielen Dank für deinen Antwort, dass kann Ich festellen.

mein Problem ist, wie Ich nach dieser Bedingung in die Liste einfügen kann;

Wie funktioniert das?

Im Voraus Vielen Dank
Lena

[MFK]

fanbjs schrieb:

mein Problem ist, wie Ich nach dieser Bedingung in die Liste einfügen kann;

Das kommt darauf an, wie die Liste aufgebaut ist.

[fanbjs]

Hi

meine Liste ist doppelt verkettete Liste;
Ich kann auch die ganze Methode schreiben:

[cpp]static void CreateListOne(freq_t *val, int i, int m);
static int Compare(freq_t *val, int i, int m);

void Insert(freq_t *val, int i, int m)
{
	if(Set[m].Tables[i].init==NULL)
      CreateListOne(val, i, m);
  else {
		Set[m].Tables[i].pointer=Set[m].Tables[i].init;
		while(Set[m].Tables[i].pointer != NULL)
			Set[m].Tables[i].pointer=Set[m].Tables[i].pointer->next;
    if(Set[m].Tables[i].pointer==NULL)
			CreateListOne(val, i ,m);
    else if(Set[m].Tables[i].pointer == Set[m].Tables[i].init) {
			Set[m].Tables[i].init=(freq_t*)malloc(sizeof(freq_t));
      if(NULL == Set[m].Tables[i].init)
			{
				fprintf(stderr, "Kein Speicherplatz vorhanden!!!\n");
        return;
      }

			Set[m].Tables[i].init->instr =  val->instr;
      Set[m].Tables[i].init->frequency =  val->frequency; 
      Set[m].Tables[i].init->pos = val->pos; 
      Set[m].Tables[i].init->next=Set[1].Tables[i].pointer;
			Set[m].Tables[i].prev->next=NULL;

	 }else {
      Set[m].Tables[i].pointer1=Set[1].Tables[i].init;
      while(Set[m].Tables[i].pointer1->next!= Set[m].Tables[i].pointer)
			Set[m].Tables[i].pointer1=Set[m].Tables[i].pointer1->next;
      Set[m].Tables[i].pointer=(freq_t *)malloc(sizeof(freq_t));
      if(NULL == Set[m].Tables[i].pointer) {
        fprintf(stderr, "Kein Speicherplatz vorhanden!!!\n");
        return;
      }
      Set[m].Tables[i].pointer->instr =  val->instr;
      Set[m].Tables[i].pointer->frequency =  val->frequency; 
      Set[m].Tables[i].pointer->pos = val->pos; 
      Set[m].Tables[i].pointer->next=Set[1].Tables[i].pointer1->next;
			Set[m].Tables[i].pointer->prev=Set[1].Tables[i].pointer1;
			Set[m].Tables[i].pointer1->next->prev=Set[1].Tables[i].pointer;
	 }

	} 

}

static int bit (int wert, int pos);

int Distance (long value1, long value2){
	int i =0;
  int res = 0;
  int test ;

 	long dx = value1;
	long dy = value2;

	test = (dx ^ dy);
	for ( i =0; i < blocksize; i++){
		if (bit(test, i)==1) res++;
	}
   return res;
}

static int bit (int wert, int pos){

  wert >>= pos;
  return (wert & 1);
}  

void CreateListOne(freq_t *val, int i, int m){

	int k;
	if(Set[m].Tables[i].init == NULL) 
	{

		if((Set[m].Tables[i].init = ( freq_t *) malloc(sizeof( freq_t))) == NULL)
    {
			fprintf(stderr, "No mamory is for init\n");
			return;
		}

				Set[m].Tables[i].init->instr = val->instr;
				Set[m].Tables[i].init->frequency =val->frequency;
        Set[m].Tables[i].init->pos =val->pos;
				Set[m].Tables[i].init->select =val->select;

				for ( k =1; k <= blocksize; k++)
				{ 
					Set[m].Tables[i].init->str[blocksize-k]= val->str[blocksize-k];
					Set[m].Tables[i].init->posstr[blocksize-k]= val->posstr[blocksize-k];
				}

				Set[m].Tables[i].init->next = NULL;
				Set[m].Tables[i].last = Set[m].Tables[i].init;
				Set[m].Tables[i].last->prev =NULL;
				Set[m].Tables[i].entries = Set[1].Tables[i].entries+1;

	}else{
		Set[m].Tables[i].pointer=Set[m].Tables[i].init; 
    while(Set[m].Tables[i].pointer->next != NULL)
			Set[m].Tables[i].pointer = Set[m].Tables[i].pointer->next;
			if((Set[m].Tables[i].pointer->next =(freq_t *)
					malloc(sizeof(freq_t))) == NULL) 
			{
					fprintf(stderr,"Kein Speicherplatz für das letzte Element\n");
					return;
      }

			Set[m].Tables[i].pointer1=Set[m].Tables[i].pointer;
      Set[m].Tables[i].pointer=Set[m].Tables[i].pointer->next; 
      Set[m].Tables[i].pointer->instr = val->instr;
      Set[m].Tables[i].pointer->frequency =val->frequency;
      Set[m].Tables[i].pointer->pos =val->pos;
			Set[m].Tables[i].pointer->next=NULL;
			Set[m].Tables[i].last =	Set[m].Tables[i].pointer;
			Set[m].Tables[i].pointer->prev =Set[m].Tables[i].pointer1;
			Set[m].Tables[i].pointer1->next= Set[m].Tables[i].pointer;

	}

}

[MFK]

Ich vertehe nicht ganz den Zusammenhang zwischen

Set[m].Tables[i]
Set[m].Tables[i].init
Set[m].Tables[i].pointer
Set[m].Tables[i].pointer1

Die scheinen alle prev- und next-Member zu besitzen. Ich habe den Eindruck, dass du die Laufvariable für Suchschleife (pointer1) mit in die Struktur gepackt hast. Wozu?

Und ehrlich gesagt habe ich keine besondere Lust, mir derart übel formatierten Code genauer anzusehen. Bring doch erst mal die Einrückung in Ordnung, damit man erkennen kann, was wohin gehört.

[fanbjs]

Vielen Dank für deine Hilfe.

Ich habe pointer1 uas der Structur rausgenommenund hoffentlich richtig eingerückt

static void CreateListOne(freq_t *val, int i, int m);
static int Distance(freq_t *val1,freq_t *val2, int i, int m);
static int bit (int wert, int pos);

freq_t *pointer1;

void Insert(freq_t *val, int i, int m)
{
  if(Set[m].Tables[i].init==NULL)
     CreateListOne(val, i, m);
  else{
     Set[m].Tables[i].pointer=Set[m].Tables[i].init;
     while(Set[m].Tables[i].pointer != NULL)
	Set[m].Tables[i].pointer=Set[m].Tables[i].pointer->next;
     if(Set[m].Tables[i].pointer==NULL)
	CreateListOne(val, i ,m);
     else if(Set[m].Tables[i].pointer == Set[m].Tables[i].init) {
	Set[m].Tables[i].init=(freq_t*)malloc(sizeof(freq_t));
        if(NULL == Set[m].Tables[i].init)
	{
	  fprintf(stderr, "Kein Speicherplatz vorhanden!!!\n");
          return;
        }

        Set[m].Tables[i].init->instr =  val->instr;
        Set[m].Tables[i].init->frequency =  val->frequency; 
        Set[m].Tables[i].init->pos = val->pos; 
        Set[m].Tables[i].init->next=Set[1].Tables[i].pointer;
        Set[m].Tables[i].prev->next=NULL;

    }else{
        pointer1=Set[1].Tables[i].init;
        while(pointer1->next!= Set[m].Tables[i].pointer)
			pointer1=pointer1->next;
           Set[m].Tables[i].pointer=(freq_t *)malloc(sizeof(freq_t));
        if(NULL == Set[m].Tables[i].pointer) {
          fprintf(stderr, "Kein Speicherplatz vorhanden!!!\n");
          return;
        }
        Set[m].Tables[i].pointer->instr =  val->instr;
        Set[m].Tables[i].pointer->frequency =  val->frequency; 
        Set[m].Tables[i].pointer->pos = val->pos; 
        Set[m].Tables[i].pointer->next=pointer1->next;
	Set[m].Tables[i].pointer->prev=pointer1;
	pointer1->next->prev=Set[1].Tables[i].pointer;
    }

 } 

}

void CreateListOne(freq_t *val, int i, int m){
 int k;
 if(Set[m].Tables[i].init == NULL) 
 {
    if((Set[m].Tables[i].init = ( freq_t *) malloc(sizeof( freq_t))) == NULL)
    {
	fprintf(stderr, "No mamory is for init\n");
	return;
    }

    Set[m].Tables[i].init->instr = val->instr;
    Set[m].Tables[i].init->frequency =val->frequency;
    Set[m].Tables[i].init->pos =val->pos;
    Set[m].Tables[i].init->select =val->select;
    for ( k =1; k <= blocksize; k++)
    { 
	Set[m].Tables[i].init->str[blocksize-k]= val->str[blocksize-k];
	Set[m].Tables[i].init->posstr[blocksize-k]= val->posstr[blocksize-k];
    }
    Set[m].Tables[i].init->next = NULL;
    Set[m].Tables[i].last = Set[m].Tables[i].init;
    Set[m].Tables[i].last->prev =NULL;
    Set[m].Tables[i].entries = Set[1].Tables[i].entries+1;
 }else{
    Set[m].Tables[i].pointer=Set[m].Tables[i].init; 
    while(Set[m].Tables[i].pointer->next != NULL)
	Set[m].Tables[i].pointer = Set[m].Tables[i].pointer->next;
    if((Set[m].Tables[i].pointer->next =(freq_t *)
   	malloc(sizeof(freq_t))) == NULL) 
    {
	fprintf(stderr,"Kein Speicherplatz für das letzte Element\n");
					return;
    }

    pointer1=Set[m].Tables[i].pointer;
    Set[m].Tables[i].pointer=Set[m].Tables[i].pointer->next; 
    Set[m].Tables[i].pointer->instr = val->instr;
    Set[m].Tables[i].pointer->frequency =val->frequency;
    Set[m].Tables[i].pointer->pos =val->pos;
    Set[m].Tables[i].pointer->next=NULL;
    Set[m].Tables[i].last =	Set[m].Tables[i].pointer;
    Set[m].Tables[i].pointer->prev =pointer1;
    pointer1->next= Set[m].Tables[i].pointer;
 }				

}

static int Distance(freq_t *val1, freq_t *val2, int i, int m);
    int i =0;
    int res = 0;
    int test ;

    int *dx = val1->instr;
    int *dy = val2->instr;

    test = (dx ^ dy);
    for ( i =0; i < blocksize; i++)
    {
        if (bit(test, i)==1) res++;
    }
   return res;
}

static int bit (int wert, int pos){

  wert >>= pos;
  return (wert & 1);
}