linkilist4

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


#define MAX_HEAP 100

typedef struct IMem
{
    void* mem;
    int size;
}IMem;
int mem_index = 0;
int max_stack = 0;
int free_stack = 0;

IMem heap[MAX_HEAP];

void* Malloc(int size)
{
    void* data = malloc(size);
    heap[mem_index].size= size;
    heap[mem_index].mem =data;
    max_stack += size;
    mem_index++;
    return  data;
}

void Free(void* data)
{
    free(data);
    data = NULL;
    heap[mem_index-1].mem = NULL;
    free_stack+=heap[mem_index-1].size;
    heap[mem_index-1].size=0;
    mem_index--;
}


void mem_leak()
{
printf("\n");
printf("***   Memory HEAP trace ***\n");
printf("*                         *\n");
printf("*   Memory request : %d  *\n",max_stack);
printf("*   Memory free    : %d  *\n",free_stack);
printf("*                         *\n");
if (max_stack!=free_stack)
printf("*  * memory leaks *   :(  *\n");
else
printf("* < no memory leaks > :)  *\n");
printf("*                         *\n");
printf("***************************\n");
printf("\n");
}




typedef struct Node
{
  int data;
  struct Node* next;
}Node;

Node *head_ref=NULL;

void insertAtBeginning( int new_data)
{
  Node* new_node = ( Node*)Malloc(sizeof( Node));
  new_node->data = new_data;
  new_node->next = head_ref;

  // a pilha da cebaca fica o novo node
  head_ref = new_node;
}


void insertAfter( Node* prev_node, int new_data)
{
  if (prev_node == NULL)
  {
  printf("the given previous node cannot be NULL");
  return;
  }

  Node* new_node = ( Node*)Malloc(sizeof( Node));
  new_node->data = new_data;
  new_node->next = prev_node->next;
  prev_node->next = new_node;
}


void insertAtEnd( int new_data)
{

   Node* new_node = ( Node*)Malloc(sizeof( Node));
   Node* last = head_ref;

  new_node->data = new_data;
  new_node->next = NULL;

  if (head_ref == NULL)
  {
  head_ref = new_node;
  return;
  }

  while (last->next != NULL)
    last = last->next;

  last->next = new_node;

}

void pop()
{
    Node *temp = head_ref;
    head_ref = head_ref->next;
    Free(temp);
}

void clear()
{
    while(head_ref)
    {
        pop();
    }
}

void deleteNode( int key)
{

   Node *temp = head_ref, *prev;

  if (temp != NULL && temp->data == key)
  {
  head_ref = temp->next;
  Free(temp);
  return;
  }
  // prcuramos a chave na pilha
  while (temp != NULL && temp->data != key)
  {
  prev = temp;
  temp = temp->next;
  }

  // se a pilha nao contem a chave
  if (temp == NULL) return;

  // remove a pilha
  prev->next = temp->next;

  Free(temp);
}


int searchNode( int key)
{
   Node* current = head_ref;

  while (current != NULL)
  {
  if (current->data == key) return 1;
  current = current->next;
  }
  return 0;
}


void sortLinkedList()
{
   Node *current = head_ref, *index = NULL;
  int temp;

  if (head_ref == NULL)
  {
  return;
  } else
  {
  while (current != NULL)
  {

    index = current->next;

    while (index != NULL)
    {
        if (current->data > index->data)
        {
          temp = current->data;
          current->data = index->data;
          index->data = temp;
        }
        index = index->next;
    }
    current = current->next;
  }
  }
}


void printList(Node* node)
{
  while (node != NULL)
  {
  printf(" %d ", node->data);
  node = node->next;
  }
   printf("\n");
}





int main()
{


  insertAtEnd( 1);
  insertAtBeginning( 2);
  insertAtBeginning( 3);
  insertAtEnd( 4);
  insertAfter(head_ref->next, 5);

  printf("Linked list: \n");
  printList(head_ref);

  printf("\nAfter deleting an element: \n");
  deleteNode( 3);
  printList(head_ref);

  int item_to_find = 5;
  if (searchNode(item_to_find))
  {
  printf("\n [%d] is found \n", item_to_find);
  } else {
  printf("\n [%d] is not found \n", item_to_find);
  }

  sortLinkedList();
  printf("\nSorted List: \n");
  printList(head_ref);


  clear();

printList(head_ref);


    mem_leak();

    return 0;
}