Sorting Practice

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <time.h>
//#include <math.h>

#define MAX_SIZE 100
#define SWAP(x,y,t)((t)=(x), (x)=(y), (y)=(t))

/* Sort functions decalaration */
/* Quick Sort */
void QuickSort(int a[],int left,int right);

/* Merge Sort */
void mergesort_new(int list[], int temp[],int left, int right);
int listMerge(int a[], int link[], int start1, int start2);
int reMergeSort(int a[],int link[], int left, int right);
void Merge(int initlist[], int mergedlist[], int head, int middle, int tail);
void MergePass(int initlist[], int mergedlist[], int n, int size);
void MergeSort(int a[],int n);

/* Heap Sort */
void Heap_Construct(int list[],int n);
void Heap_Adjust(int list[],int n,int i);
void Heap_Sort(int list[],int n);

/* Others */
void printAry(int a[],int left, int length);
void Intro(void);
void chooseSort(unsigned int num , int a[] , int arySz);

int main(int argc, const char * argv[])
{
    /* Variable decalre */
    int Data_input;
    static int temp,i;
    int *userAry;

    Intro();
    while(1)
    {
    printf("Please decide how to input data\n");
    printf("Enter by yourself  for 1\n");
    printf("Generate in random for 2\n");
    scanf("%d",&Data_input);


        printf("Enter how many integers you want to input: ");
        scanf("%d",&temp);
        if((userAry = malloc(sizeof(int)*temp)) == NULL)
        {
            printf("Error allocating memory!\n");
            exit(EXIT_FAILURE);
        }

    switch (Data_input) {
        case 1:
//            printf("Enter how many integers you want to input: ");
//            scanf("%d",&temp);
//            if((userAry = malloc(sizeof(int)*temp)) == NULL)
//            {
//                printf("Error allocating memory!\n");
//                exit(EXIT_FAILURE);
//            }
            printf("Enter your data : ");
            for(i=0 ; i<temp ; i++)
                scanf("%d",&userAry[i]);
//            printf("Which sort do you want to do : ");
//            scanf("%1d",&i);
//            chooseSort(i, userAry, temp);
            break;

        case 2:

            srand((unsigned int)time(NULL));
            for(i=0 ; i<temp ; i++)
            {
                userAry[i] = ((rand() * i +99) % 1024) + 1;
            }

            break;
        default:
            break;
    }
        printf("Which sort do you want to do : ");
        scanf("%1d",&i);
        chooseSort(i, userAry, temp);
        free(userAry);
    }
    //int ary[8] = {8,4,5,6,2,1,7,4};
    //int temp[8];
    //int ary[8] = {1,2,3,4,5,6,7,8};
    //int link[8] = {0};
    //printAry(ary,0, 8);
    //QuickSort(ary, 0, 7);
    //mergesort_new(ary, link, 0, 7);
    //Heap_Sort(ary, 8);
    //printAry(ary,0, 8);
    return 0;
}

/* Heap Sort */
void Heap_Construct(int list[],int n)
{
    int i;
    for(i=n/2-1; i>=0; i--)
        Heap_Adjust(list, n, i);
}

void Heap_Adjust(int list[],int n,int i)
{
    int temp,large;
    temp = list[i];
    while(2*i+1 < n)
    {
        large = 2*i+1;
        if((large+1)<n && list[large]<list[large+1])
            large++;
        if(temp >= list[large])
            break;
        list[i] = list[large];
        i=large;
    }
    list[i] = temp;
}

void Heap_Sort(int list[],int n)
{
    int temp;
    Heap_Construct(list, n);
    while (n>1)
    {
        temp = list[0];
        list[0] = list[n-1];
        list[n-1] = temp;
        n--;
        Heap_Adjust(list, n, 0);
    }
}

/* Quick Sort */
void QuickSort(int a[],int left,int right)
{
    int pivot,i,j,temp=0;
    if(left < right)
    {
        i = left ; j = right + 1;
        pivot = a[left];
        //printf("init pivot = %d i=%d j=%d\n",pivot,i,j);
        do
        {
            do i++; while(a[i] < pivot && i<right);
            do j--; while(a[j] > pivot && j>left);
           // printf("[i=%d , j=%d]\n",i,j);
            if (i<j) SWAP(a[i],a[j],temp);
           // printAry(a, left,right+1);
        } while (i<j);
        SWAP(a[left],a[j],temp);
        //printAry(a, left, right+1);
        QuickSort(a, left, j-1);
        QuickSort(a, j+1, right);
    }
}

/* Merge Sort */
void mergesort_new(int list[], int temp[],int left, int right)
{
    int middle,i,j,k,n;

    if(left < right)
    {
        middle = (left+right)/2;
        mergesort_new(list, temp, left, middle);
        mergesort_new(list, temp, middle+1, right);

        i=left;
        j=middle+1;
        k=left;
        n=right-left+1;

        while(i <= middle && j <= right)
            if(list[i] <= list[j])  temp[k++] = list[i++];
            else                    temp[k++] = list[j++];

        while(i <= middle)
            temp[k++] = list[i++];
        while(j <= right)
            temp[k++] = list[j++];
        for(i=0; i<n; i++,right--)
            list[right] = temp[right];
        //printAry(list, 0, 8);
    }
}
/*
int listMerge(int a[], int link[], int start1, int start2)
{
    int last1,last2,lastResult = 0;
    for(last1 = start1 , last2 = start2; last1 && last2; )
        if(a[last1] <= a[last2])
        {
            link[lastResult] = last1;
            lastResult = last1; last1 = link[last1];
        }
        else
        {
            link[lastResult] = last2;
            lastResult = last2; last2 = link[last2];
        }

    if(last1 == 0) link[lastResult] = last2;
    else    link[lastResult] = last1;
    return link[0];
}

int reMergeSort(int a[],int link[], int left, int right)
{
    if(left >= right)   return left;
    int mid = (left+right)/2;
    return listMerge(a, link, reMergeSort(a, link, left, mid), reMergeSort(a, link, mid+1, right));
}

void Merge(int initlist[], int mergedlist[], int head, int middle, int tail)
{
    int j,k,l,t;
    j = middle + 1;
    k = head;   l = head;
    // Put element into mergedlist
    while( k<=middle && j<=tail)
    {
        if( initlist[k] < initlist[j] )
            mergedlist[l++] = initlist[k++];
        else
            mergedlist[l++] = initlist[j++];
    }

    if(k>middle)
        for(t=j; t<=tail; t++)
            mergedlist[t] = initlist[t];
    else
        for(t=k; t<=middle; t++)
            mergedlist[t] = initlist[t];
}

void MergePass(int initlist[], int mergedlist[], int n, int size)
{
    int i,j;
    for( i=1; i<=n-2*size+1; i+=2*size )
        Merge(initlist, mergedlist, i, i+size-1, i+2*size-1);
    if( (i+size-1) < n )
        Merge(initlist, mergedlist, i, i+size-1, n);
    else
        for(j=i; j<=n; j++)
            mergedlist[j] = initlist[j];
}

void MergeSort(int a[],int n)
{
    int size=1;
    int extra[MAX_SIZE];
    while(size < n)
    {
        MergePass(a, extra, n, size);
        size*=2;
        MergePass(extra, a, n, size);
        size*=2;
    }
}
*/
/* Others */
void Intro(void)
{
    printf("Welcome to use the Sorting System\n");
    printf("There are three different ways to sort your data\n");
    printf("1.Quick Sort\n");
    printf("2.Merge Sort\n");
    printf("3.Heap  Sort\n");
    printf("And you can input your own data\n");
    printf("Or we can generate if randomly\n");
    printf("So.... Let's start!\n\n");
}

void printAry(int a[],int left,int length)
{
    int i = left;
    printf("Output : \n");
    for (; i<length ; i++)
        printf("%d ",a[i]);
    printf("\n");
}

void chooseSort(unsigned int num , int a[] , int arySz)
{
    int *tempAry;
    tempAry = malloc(sizeof(int) * arySz);
    if((tempAry = malloc(sizeof(int)*arySz)) == NULL)
    {
        printf("Error allocating memory!\n");
        exit(EXIT_FAILURE);
    }
    printAry(a, 0, arySz);
    switch (num) {
        case 1:
            QuickSort(a, 0, arySz);
            break;
        case 2:
            mergesort_new(a, tempAry, 0, arySz);
            break;
        case 3:
            Heap_Sort(a, arySz);
            break;
        default:
            break;
    }
    printAry(a, 0, arySz);
}