Thread: Surprise! linked list program help...

Code:

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

struct listNode {
    char data;
    struct listNode *nextPtr;
};

typedef struct listNode LISTNODE;
typedef LISTNODE *LISTNODEPTR;

void insert(LISTNODEPTR *, char);
char delete_me(LISTNODEPTR *, char);
int isEmpty(LISTNODEPTR);
void printList(LISTNODEPTR);
void instructions(void);

int main(int argc, char* argv[])
{
    LISTNODEPTR startPtr = NULL;

    int choice;
    char item;

    instructions(); /*display the menu*/
    printf("? ");
    scanf("%d", &choice);

    while (choice != 3) {
        switch (choice) {
        case 1:
            printf("Enter a character ");
            scanf("\n%c", &item);
            insert(&startPtr, item);
            printList(startPtr);
            break;
        case 2:
            if (!isEmpty(startPtr)) {
                printf("Enter character to be deleted: ");
                scanf("\n%c", &item);
                if (delete_me(&startPtr, item)) {
                    printf("%c deleted.\n", item);
                    printList(startPtr);
                }
                else
                    printf("%c not found. \n\n", item);
            }
            else
                printf("List is empty.\n\n");
            break;
        default:
            printf("Invalid choice.\n\n");
            instructions();
            break;
        }
        printf("? ");
        scanf("%d", &choice);
    }
    printf("End of run.\n");

    return 0;
}

/*Print the instructions*/
void instructions(void)
{
    printf("Enter your choice:\n"
        "   1 to insert an element into the list.\n"
        "   2 to delete an element from the list.\n"
        "   3 to end.\n");
}

/*Insert a new value into the list in sorted order*/
void insert(LISTNODEPTR *sPtr, char value)
{
    LISTNODEPTR newPtr, previousPtr, currentPtr;
    newPtr = (LISTNODEPTR)malloc(sizeof(LISTNODE));
    if (newPtr != NULL) {
        newPtr->data = value;
        newPtr->nextPtr = NULL;

        previousPtr = NULL;
        currentPtr = *sPtr;
        
        while (currentPtr != NULL && value > currentPtr->data) {
            previousPtr = currentPtr;  /*walk to...*/
            currentPtr = currentPtr->nextPtr;/*...next node*/
        }

        if (previousPtr == NULL) {
            newPtr->nextPtr = *sPtr;
            *sPtr = newPtr;
        }
        else {
            previousPtr->nextPtr = newPtr;
            newPtr->nextPtr = currentPtr;
        }
    }
    else
        printf("%c not inserted. No memory available.\n", value);
}

It's from a textbook I'm using to learn C. The 3 different lines I bolded are where my questions lay. The startPtr is a pointer variable that points to the listNode structure. How come the insert and delete functions use the (&) and the printList function does not? I figured since startPtr is a pointer then the (&) would cause the function to use the address of the pointer variable for insert and delete and without it the printList would receive the address of what the pointer variable points to.

Thanks for help ahead of time!

Thx SlyMaelstrom, did not catch that in the declarations of the functions and the earlier typedef. Not good at putting 2 and 2 together sometimes.

if u have understood all that,
spysmily1 can u now explain me why exactly u need to have a double pointer,whydid the author not use just a pointer?

I'm not for sure why they use a double pointer and not a pointer. That's the kinda thing that's been giving me a hard time with this lesson on linked list.

I'm reviewing the code now that I have my eyes open to the double pointer parameter.

If you or anyone has a clue as to the double pointer I would be very grateful to any replies as to the answer to this question. In fact if someone would like to break down the line by line in the function insert as to what is going on as I am continuously losing my train of thought trying to break this down myself. I can pick out what is happening up until currentPtr=*sPtr; is this assigning the the address that is held by sPtr to currentPtr since sPtr is a pointer to another pointer of struct listNode and the * dereferences it.

first a link list is a chain of nodes,and each node is identified by its address.

*sptr is the address of the first node.(can u get this?)

>currentptr =*sptr

so currentptr gets the value of the address of the first node here.

void insert(LISTNODEPTR *sPtr, char value)
{
LISTNODEPTR newPtr, previousPtr, currentPtr;
newPtr = (LISTNODEPTR)malloc(sizeof(LISTNODE));
if (newPtr != NULL) {
newPtr->data = value;
newPtr->nextPtr = NULL;

previousPtr = NULL;



currentPtr = *sPtr;
>currentptr gets the address of the first node.




while (currentPtr != NULL && value > currentPtr->data) {
previousPtr = currentPtr; /*walk to...*/
currentPtr = currentPtr->nextPtr;/*...next node*/
}
>goes to the last node




if (previousPtr == NULL) {
>if the while loop failed,that means that *sPtr is NULL.
there was no previous node.



newPtr->nextPtr = *sPtr;
>newPtr->nextPTr=NULL,since this is the first node ,there is no next node.



*sPtr = newPtr;
>sPtr is reassigned to point to newPtr,or now newPtr becomes the first node
this was why the double pointer was needed.(why?)
}


and so on.

Code:

thx again as you have helped me a great deal with a problem I was having so much trouble with.