Thread: pointer of pointer of a structure data type unexpected variation

Well, given that you execute

Code:

pcodewords[0]=NodeConstruct(cw,n);

and then

Code:

pcodewords[0]=NodeConstruct(cw0,n);

it's not too surprising that pcodewords[0] has changed. You're assigning it to a whole new node, as far as I can tell.

BTW, [code] [/code] tags are only supposed to go around your code, not the rest of your message too. Also, instead of long-winded explanations about what various variables are, it's much easier for us if you simply show the declarations of the variables and their types (if they're structures or what not).

Here's how you allocate pcodewords.

Code:

  Node **pcodewords;
  pcodewords=malloc(sizeof *pcodewords);
  pcodewords[0]=NULL;

Okay, so after this pcodewords is an array of Node*s with one element, and that element is set to NULL. Fair enough so far.

But then you do this:

Code:

  for(int i=0;i<combination(n,w);i++)

  {
    int *p=GetCodeWord(pcodewords[i]);
    // ...

In other words, you read from pcodewords[i]. But that will only work if pcodewords[i] exists, which it won't unless i==0! So I think that instead of allocating one element, you meant to use something like this:

Code:

  Node **pcodewords;
  pcodewords=malloc(sizeof *pcodewords * combination(n, w));

That would give you enough pcodewords[i]'s to prevent seg faults. But then there's still the issue of pcodewords[i] not being initialized! You only do this in the do-while loop after this for loop. I suspect this for loop was debugging code. So get rid of it.

So . . . yeah. If you allocated enough memory to begin with, and don't access pcodewords[i] until it's been initialized, then you should be all right. My modified code is as follows, with modifications in colour.

Code:

#include<stdlib.h>


#include "node.h"
#include "functions.h"



int main()

{ 

  int n,d,w;

//inputs from user

  printf("Enter n,d,and w:\nn=");

  scanf("%d",&n);

  printf("d=");

  scanf("%d",&d);

  printf("w=");

  scanf("%d",&w);

  printf("n=%d, d=%d, w=%d\n",n,d,w);

//generate the codewords
  Node **pcodewords;
  pcodewords=malloc(sizeof *pcodewords * combinations(n,w));
  pcodewords[0]=NULL;

  int cw[n],cw0[n];

  //The initial codeword is 00000....111111

  for(int i=0;i<n-w;++i)

    cw[i]=cw0[i]=0;

  for(int i=n-w;i<n;++i)

    cw[i]=cw0[i]=1;

  pcodewords[0]=NodeConstruct(cw,n);

 //printing the codewords for checking
  /*for(int i=0;i<combination(n,w);i++)

  {
    int *p=GetCodeWord(pcodewords[i]);

    for(int j=0;j<n;j++)

      printf("%d", *(p+j));

    printf("\n");

  }*/
  int *cexist,i=1;

  do

  {

    cexist=nextcw(cw,n);

    if(cexist)

      pcodewords[i]=NodeConstruct(cexist,n);
    ++i;
  }while(cexist);

  
  //printing the codewords for checking
  for(int i=0;i<combination(n,w);i++)

  {
    int *p=GetCodeWord(pcodewords[i]);

    for(int j=0;j<n;j++)

      printf("%d", *(p+j));

    printf("\n");

  }
}

I haven't seen the rest of your code, but you should be careful about GetCodeWord's return value. If it's an ordinary array, then you'll be accessing invalid memory. If it's a static array, good for you. If it's dynamically allocated, you might consider freeing it at some point.

Hello DWK, You really got my problem and gave me a proper solution. It means a lot for me . Anyway, 10q and Long life for you and yours!

BTW, could you suggest me an algorithm to use to implement the following problem with c:

eg. For n=6, number of ones(w)=3, the following binary words can be obtained in lexicographic order
000111
001011
001101
001110
010011
010101
010110
011001
011010
011100
100011
100101
100110
101001
101010
101100
110001
110010
110100
111000

What I want to do is to find all the possible solutions ,with maximum number of words, fulfilling
a minimum distance condition, eg d=3.

I am really stacked so plz forward me your suggestion asa possible 10q!

First note that the idea I've presented below assumes that you don't have to store each number as you generate it. It just prints the solutions as they are found. If you do need to store the generated bitstrings, it's easy enough to pass a pointer to the stack of words found so far to the function along with the number of words you've added.

Personally, I'd be inclined to try a recursive solution to this problem. Here's some code which generates all the binary numbers of length 6. Note that the numbers will always be in lexicographical order, since it recurses first on '0' and then on '1'.

Code:

#include <stdio.h>

void binary_numbers(char *buffer, int digit, int length) {
    if(digit + 1 >= length) {
        buffer[digit] = 0;  /* add terminating NULL character to the string */
        
        printf("%s\n", buffer);
        return;
    }
    
    buffer[digit] = '0';
    binary_numbers(buffer, digit + 1, length);
    
    buffer[digit] = '1';
    binary_numbers(buffer, digit + 1, length);
}

int main() {
    char buffer[6] = {0};
    binary_numbers(buffer, 0, sizeof(buffer)/sizeof(*buffer));
    
    return 0;
}

What the code does is basically add onto the end of the buffer, adding zeros and ones in sequence. It's reasonably efficient; it does require on the order of 2^n recursive calls, but the recursive depth will never be more than n (or n+1? whatever), since it recurses for every letter in the buffer.

Anyway, you can easily adopt that code so that it only prints those numbers with three 1's in them, for example; perhaps by counting the number of ones you print. That's pretty inefficient, though, if the number of digits is large and the number of 1's is small.

So a better idea is to only generate numbers with the correct number of 1's. The code would operate pretty much the same as before, except that you'd have to detect if you were getting near the end and hadn't added enough 1's yet. In other words, if you need N more 1's and there are only M characters left, if N == M then you'd better use a 1 and not a 0.

If you don't like the recursive solution . . . well, like with all recursive functions, you could write an iterative (loop-based) solution to this problem too. I think it would be a lot more complicated, though. Why don't you see if you can figure out the recursive version . . . .

Oh, I see. Sorry, I misunderstood you. I think I need more clarification, however: if you are looking for solutions with size 4, and there are 5 codewords which meet the d>3 criteria, does that mean that this solution is not a size 4 solution, or does it mean that you can get 5 size 4 solutions out of this size 5 solution by taking subsets of size 4? In other words, are you looking for solutions with a maximal size of 4 or solutions with a size of exactly 4?

I can't think of an easy way to solve this problem besides the reasonably obvious solution of checking every codeword against every other codeword. For example: pick the first word and compare it against every other word. If d>3, increment the "matching" count for both the first word and also the word it matched. At the end, if the count is >= 4 (or == 4, depending on your problem), then you've found a solution set. You'd probably also want to record the matching words as you find them so that you can print them in an efficient manner.

Something like that should work. Unless I'm overlooking something.

Anyway, this is all pretty complicated; is this actually what your program is trying to do, or is this a mean towards an end?

I have already implemented hamming distance checking function for two codewords.

If you stored those numbers in ints instead of in strings you could use the C XOR operator (^) combined with left shift and AND to do this checking very quickly. Just a thought.

Or you could use a combination-generating algorithm to generate all the possible combos of 3 out of 6 (123, 124, 125, 126, 134, .....) and use that to place the 0's in your string.

Yeah, that would probably be an even better idea . . .