Sort linked list

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

#define N 12    //number of elements in the array
typedef bool (*CompareFunction)(void *, void *);

typedef struct Node{
      int data;
      char str[20];
      struct Node * next;
      } Node;

/*
* create a linked list from an array of elements
*/
void createLinkedList(int array[], int length, Node **head)
{
  int i;
  Node *current;
  Node *p;
  if(length == 0)
      return ;//;NULL;
  for(i = 0; i < length; i++)
  {
      if(i == 0)
      {
          *head = (Node*) malloc(sizeof(Node));
          (*head)->data = array[i];
          snprintf((*head)->str, 10,"%d",array[i]);
          (*head)->next = NULL;
          current = *head;
      }
      else
      {
          p = (Node*) malloc(sizeof(Node));
          p->data = array[i];
          snprintf(p->str, 10, "%d", array[i]);
          p->next = NULL;
          current->next = p;
          current = p;
      }
  }
}

/*
*   integer compare
*/
bool compareint(void *a, void *b)
{
  int x = *(int*)a;
  int y = *(int*)b;
  return (x > y);
}
/*
*   string compare
*/
bool comparechar(void *a, void *b)
{
  char *x = (char*)a;
  char *y = (char*)b;
  return strcmp(x, y) < 0 ? 1:0;
}

/*
*  print the linked list
*/
void printLinkedList(Node *head)
{
  Node *p = head;
  while(p != NULL)
  {
      printf("(%d,", p->data);
      printf("%s),", p->str);
      p=p->next;
  }
  printf("\n");
}


bool sort(Node **head, CompareFunction cmpFunc)
{
  Node *s = *head;    //start node
  Node *t = s->next;  //iterating node
  Node *t_parent = s; //parent of iterating node
  Node *index = NULL; // max or min node index
  Node *index_parent = NULL;
  Node *current = NULL;

  //iterate all nodes
  while(s->next != NULL)
  {
      index = s;
      t = s->next;
      t_parent = s;
      // find the max/min node
      while( t != NULL)
      {
          if(cmpFunc(&(index->data), &(t->data)))
          {
              index = t;
              index_parent = t_parent;
          }
          t_parent = t;
          t = t->next;
      }

      //printf("index=%d\t,", index->data);

      //move the seletced max/min to sorted list
      if(current == NULL)
      {
          current = index;
          *head = current;
      }
      else
      {
          current->next = index;
          current = current->next;
      }

      //remove the selected node from the unsorted list
      if(index == s)
          s = s->next;
      else
          index_parent->next = index->next;

      current->next = NULL;
  }
  //add the last single node in the original list to the sorted list
  if(current != NULL)
      current->next = s;
  return true;
}



int main()
{

  int array[N]={10,4,2,11,4,8,7,3,5,9,-1,2};
  Node *root;
  createLinkedList(array, N, &root);
  printLinkedList(root);
  sort(&root, &compareint);
  printf("Sorted List\n");
  printLinkedList(root);

      return 0;
}

Integer Expression Evaluator code

/*
* Expression evaluator. It supports +,-,*,/ and (), and integers.
* Example: 2*((5+4)/2)*6=48
* This code does not evaluate unary expression, such as -1
*
*/
#include <iostream>
#include <stack>
using namespace std;

enum OPR{ADD='+', SUB='-', MUL='*', DIV='/', PAR='('};

int eval(const string &exp);
int calc(int, int, OPR);
int rank(OPR r1);

int main(int argc, char *argv[])
{
    string exp;
 
    if(argc > 1)
         exp = argv[1];
    else
         exp = "2*((5+4)/2)*6+(2)";
    int result = eval(exp);
    cout << exp << "=" << result << endl;
}

/*
*     Evaluates a math expression
*/

int eval(const string & exp)
{
 
    stack<int> Opd;     //stack for operands
    stack<OPR> Opr;     //stack for operators
    int opd1;
    int opd2;
    OPR opr1;
    int result = 0;
    int i = 0;
    int Len = exp.length();
    for(i = 0; i < Len; i++)
    {
         //end of a parentheses
         if(exp[i] == ')')
         {
              while(Opr.top() != PAR)          //If last pushed opeator is not (, then evaluate
              {
                   opr1 = Opr.top();
                   Opr.pop();
                
                   opd1 = Opd.top();
                   Opd.pop();
                
                   opd2 = Opd.top();
                   Opd.pop();
                
                   Opd.push(calc(opd1,opd2,opr1));
              }
              Opr.pop();     // pop '('
         }  
         else if(isdigit(exp[i]))     //if a number, push to operand stack
         {
              Opd.push(exp[i] - '0');
         }
         else
         {
              //If current element is an operator, and operator stack is not empty
              //compare their precedence.
              if(!Opr.empty())
              {
                   opr1 = Opr.top();  
                   if(opr1 != '(' && rank(opr1) >= rank(static_cast<OPR>(exp[i])) )
                   {
                        opd1 = Opd.top();
                        Opd.pop();
                        opd2 = Opd.top();
                        Opd.pop();
                        result = calc(opd1,opd2, opr1);
                        Opr.pop();
                        Opd.push(result);
                   }
              }
              Opr.push(static_cast<OPR>(exp[i]));
         }
 
    }
 
    //Evaluate the last binary expression remainig in the stack
    while(!Opr.empty())
    {
         opr1 = Opr.top();
         Opr.pop();
         opd1 = Opd.top();
         Opd.pop();
         opd2 = Opd.top();
         Opd.pop();
         Opd.push(calc(opd1,opd2,opr1));
    }  
 
    return  Opd.top();
}

/*
*     Evaluates an binary expression such as 1+2
*/
int calc(int opd1, int opd2, OPR opr1)
{
    int c;
    switch(opr1)
    {
         case ADD:
              c = opd2 + opd1; break;
         case SUB:
              c = opd1 - opd2; break;
         case MUL:
              c = opd1 * opd2; break;
         case DIV:
              c = opd2 / opd1; break;
    }
    return c;
}
/*
*     Operator Precedence
*/
int rank(OPR opr1)
{
    int r = 0;
    switch(opr1)
    {
         case ADD:
         case SUB:
              r = 1; break;
         case MUL:
         case DIV:
              r = 2; break;
         case PAR:
              r = 3; break;
    }
 
    return r;
}