Thread: C Structures and Linked Lists.

Code:

struct mystruct
{
    signed short int myssint;
};

...stuff...

struct mystruct myInstance, *myPtr;

/* Accessing members directly: */
myInstance.myssint = 10;

/* Accessing members via pointer: */
myPtr = &myInstance;

myPtr->myssint = 11;

Is that what you were looking for?

Quzah.

i am beginning to think that i may need a *prev pointer in the structure to go back one record....

You don't need a previous pointer, but double linked lists are infinitely easier than single linked lists when it comes to node removal, insertion, etc. I always use double linked lists over single.

Quzah.

You probably either need to use a global list pointer, or pass the address of the list pointer (via pointer to a pointer) to your program so you can update the list.

Or you could just append to the list rather than prepend.

I tend to use the following:

Node * newNode( ...data to be in new node );
Node * getNode( ...data to find... );
void addNode( Node *toAdd, Node**list );

[edit]
There are other functions occasionally, but these three are primarily what you'll probably need. Then do something like:

n = newNode( somedata );
addNode( n, &list );

Or you could shorten it:

addNode( newNode( somedata ), &list );
[/edit]

The second argument of addNode is usually left off, because I tend to use global list pointers. (IE: When all I need is a single linked list for small programs, I just use a global pointer because it's easier.)

Quzah.

I considered editing my last post, but a new one is really needed here.

1) Use code tags. Read the nice little sticky post if you don't know how.

2) What the hell are you doing:

Code:

if (*head == (NEWMEM *)0)
{
    printf("\nCreate First Header\n");

    /*A*/
    *head = member;
    member = *head;

    /*B*/
    member->rank = (int)malloc(sizeof(num));
    member->rank = num;

    member->string = (char *)malloc(strlen(string)+1);
    strcpy(member->string, string);
    member->next = (NEWMEM *)0;
    loop = 1;
}

A - Here you're making the node point to itself.

Make pointer A point to pointer B.
Make pointer B point to pointer A, which is pointing to pointer B.

That's what you're doing. That's wrong.

B - What is 'num'? If it's a pointer, why is it a pointer? You don't need a pointer. It shouldn't be a pointer if it's just an integer of some sort. There's no reason for it to be a pointer.

If it's a string, you're doing it wrong and you're creating a memory leak.

[edit]
Prepending a list to a node works like this:

newNode->next = listHeader;
listHeader = newNode;

If you use a double linked list, you want to set the listHeader's 'prev' pointer to point to 'newNode' inserted between the two steps.

This code assumes a global pointer called 'listHeader' and a new node called 'newNode'. If you aren't using a global pointer, pass a pointer to a pointer for your listNode, and dereference properly.

The two steps above need to be done in that order or you'll screw up your list.
[/edit]

Quzah.

Originally posted by bobthebuilder20
part a:
should go to the start of the list.
member= *head;

No. I already said what you should do.

Originally posted by bobthebuilder20

part b:
num is the rank of the list.
the nodes will be placed in ascending order.

if more than one node has the same number, then the node will be placed after the last node with the same number.

is this what i should do for part b?


newmember->rank = (int)malloc(sizeof(num));
newmember->rank = num;

newmember->string = (char *)malloc(strlen(string)+1);
strcpy(newmember->string, string);
newmember->next = head;
head = newmember;

Please show me the structure definition for 'member'. Also show me the prototype for the function you're writing.

Quzah.

Originally posted by bobthebuilder20
hello quzah,

my structure is as follows:

struct list
{
int rank;
char *string;
struct list *prev;
struct list *prev_rank;
struct list *next;
struct list *next_rank;
} LIST;

prototype:


LIST *all_mem(int, char *, LIST **head);



Cheers.

Previously, you had done the following:

Code:

 newmember->rank = (int)malloc(sizeof(num));
newmember->rank = num;

Since in your function, 'rank' is not a pointer, but is a standard member of said structure, you do not allocate space for it. You only allocate space for items you're dynamicly creating. That is to say, if you have a pointer, and you want it to point to something that hasn't been created, you allocate for it.

Since every single list structure you create has an integer set aside called rank, you do not allocate space for it. The structure does that automaticly since rank is not a pointer.

Thus, all you have to do is:

Code:

newmember->rank = num;

For the second answer, I've already given it. Since you're using a pointer to a pointer to update the head of your list, all you do is, in this order:

Code:

newmember->next = *listhead;
*listhead = newmember;

What this does is first, it makes the next member of the new node point to whatever node is the top of the list.

Second, it sets the top of the list to be the new node.

You have to do those two steps in that order. If you don't, this will happen:

Code:

*listhead = newmember;
newmember->next = *list;

This makes the top of the list be the new node. Since you didn't keep track of what used to be the top first, the old list is lost.

Second, it then makes the next member of the new node point back at itself.

That is what you were doing. That is why your list was disapearing.

Quzah.