linkeddddddd

#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <string.h>
#include <stdbool.h>

typedef struct node
{
    char *data;
    struct node *next;
}node;

node* init();
int length(node* head);
void display(node* head);
void push(node**headPtr, char *data);
void freeList(node** head);
void appendNode(node**headRef, char *data);
node* copy(node* source);
void pop(node**headPtr);
void reverse(node **headPtr);
void sort(node **headPtr);
void handleError(const char *data);
struct node *createNewElement(char *data, struct node *next);

int main (int argc, char **argv)
{

    node* list = init();

  //  char* text = malloc;
  //  push(&list, text);
  //  free(text);


    push(&list, "ONE");


    appendNode(&list, "TWO");
    display(list);
    printf("\n");
    pop(&list);
    reverse(&list);
    node *duplicate = copy(list);
    freeList(&list);
    display(list);
    printf("\n");

    display(duplicate);
    printf("\n");

    sort(&duplicate);
    display(duplicate);
    freeList(&duplicate);

  return(0);
}

node* init()
{
    return NULL;
}

int length(node* head)
{
    node *currentPosition = head;
    int count = 0;
    while(currentPosition != NULL)
    {
        count++;
        currentPosition = currentPosition->next;
    }
    return count;
}

void display(node* head)
{
    node *currentPosition = head;
    if(length(head) == 0)
    {
        printf("NO ELEMNETS TO DISPALAY \n");
    }
    else
    {
    while(currentPosition != NULL)
        {
            printf("%s\n", currentPosition->data);
            currentPosition = currentPosition->next;
        }
    }
}


void handleError(const char *data)
{
    printf("%s\n", data);
    exit(0);
}


struct node *createNewElement(char *data, struct node *next)
{
    struct node *newElement = malloc(sizeof (struct node));
    if(newElement == NULL)
    {
        handleError("CANT CREATE A NEW ELEMNT");
    }
    newElement -> data = data;// here is a prblem to solve
    newElement -> next = next;

    return newElement;
}


void push(node**headPtr, char *data)
{
    struct node *newNode = createNewElement(data, *headPtr);
    *headPtr = newNode;
}

void pop(node**headPtr)
{
    node*newNode;
    newNode = *headPtr;
    (*headPtr) = (*headPtr)->next;
    newNode->next = NULL;
    free(newNode);
}

void freeList(node** headPtr)
{
    while(*headPtr)
    {
        freeList(&((*headPtr)->next));
        free(*headPtr);
        *headPtr = NULL;
    }
}

void appendNode(node**headRef, char *data)
{

    struct node *currentElement = *headRef;

    struct node *newElement = createNewElement(data, NULL);
    if((*headRef) == NULL)
    {
        *headRef = newElement;
        return;
    }

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

    currentElement -> next = newElement;
}



node* copy(node* source)
{
    node* head = NULL;
    node** temp = &head;
    while(source)
    {
        *temp = malloc(sizeof(node));
        (*temp)->data = source->data;
        (*temp)->next = NULL;
        source = source->next;
        temp = &((*temp)->next);
    }
    return head;


/**node current = source;
*node headOfNewList = NULL;
*node lastNodeInNewList = NULL;

while(current!= NULL)
{
    if(headOfNewList == NULL)
    {
        headOfNewList = (node*)malloc(sizeof(node));
        headOfNewListent->data = current->data;
        headOfNewList->next = NULL;
        lastNodeInNewList = headOfNewList;
    }
    else
    {
        lastNodeInNewList->next = ( node*)malloc(sizeof( node));
        lastNodeInNewList = lastNodeInNewList->next;
        lastNodeInNewList->data = current->data;
        lastNodeInNewList->next = NULL;
    }
    current = current->next;
}

    return  headOfNewList;
}*/


void sort(node **headPtr)
{
    bool swapped;
    node*newNode;
    node* lastNode = NULL;

    do
    {
        swapped = false;
        newNode = *headPtr;
        while(newNode->next != lastNode)
        {
            char* firstString = newNode->data;
            char * secondString = newNode->next->data;
            if(strcmp(firstString,secondString) > false)
            {
                char * temporaryString = newNode->data;
                newNode->data = newNode->next->data;
                newNode->next->data = temporaryString;
                swapped = true;
            }
            newNode = newNode->next;
        }
        lastNode = newNode;
    }
        while(swapped);
}