面试常见5个算法套装，4个排序+二分查找

面试常见的要你手写的算法，今天复习了一下，表示heapsort没法一次写对。

#include "stdio.h"
#include "stdlib.h"

#define LEFT(i) (2 * i + 1)
#define RIGHT(i) (2 * i + 2)

void printArray(int a[], int len);
void mergearray(int a[], int head, int mid, int tail);

void heapify(int a[], int len, int i)
{
    int left = LEFT(i);
    int right = RIGHT(i);
    int max = i;
    
    if(left < len && a[left] > a[max])
    {
        max = left;
        
    }
    if(right < len && a[right] > a[max])
    {
        max = right;
    }
    
    if(max != i)
    {
        int mid = a[i];
        a[i] = a[max];
        a[max] = mid;
        heapify(a, len, max);
    }
}

void heapcreate(int a[], int len)
{
    int i = len / 2;
    
    for(; i>=0; i--)
    {
        heapify(a, len, i);
        //printArray(a, len);
    }
}

void hs(int a[], int len)
{
    int i = len - 1;
    heapcreate(a, len);
    
    //printArray(a, len);
    
    for(; i > 0; i--)
    {
        int mid = a[i];
        a[i] = a[0];
        a[0] = mid;
        heapify(a, i, 0);
        
        printArray(a, len);
    }
}

void qs(int a[], int start, int end)
{
    if(start < end)
    {
        int position = partition(a, start, end);
        qs(a, start, position - 1);
        qs(a, position + 1, end);
    }
}

int partition(int a[], int start, int end)
{
    int pivot = a[end];
    int i = start - 1;
    int j = start;
    for(; j < end; j++)
    {
        if(a[j] < pivot)
        {
            i++;
            int mid = a[i];
            a[i] = a[j];
            a[j] = mid;
        }
    }
    
    i++;
    a[j] = a[i];
    a[i] = pivot;
    return i;        
}

void printArray(int a[], int len)
{
   int i;
   for(i = 0; i < len; i++)
   {
        printf("%d,", a[i]);
   }
   printf("
");
}

int binarySearchUnrecursion(int a[], int start, int end, int key)
{
    int head = start;
    int tail = end;
    
    while(head < tail)
    {
        int index = (head + tail) / 2;
        if(a[index] == key)
        {
            return index;
        }
        else{
            if(a[index] > key)
            {
                tail = index - 1;
            }
            else
            {
                head = index + 1;
            }
        }
    }
    
    return -1;
}

int binarySearch(int a[], int start, int end, int key)
{
    if(start <= end)
    {
        int index = (start + end) / 2;
        if(a[index] == key)
        {
            return index;
        }
        else{
            if(a[index] > key)
            {
                return binarySearch(a, start, index-1, key);
            }
            else
            {
                return binarySearch(a, index + 1, end, key);
            }
            
        }
    }
    else{
        return -1;
    }
}

void ms(int a[], int start, int end)
{
    if(start < end){
        int mid = (start + end) / 2;
        ms(a, start, mid);
        ms(a, mid + 1, end);
        
        mergearray(a, start, mid, end);
    }
}

void mergearray(int a[], int head, int mid, int tail)
{
    int i = head;
    int j = mid + 1;
    int k = 0;
    
    int *temp = (int*)malloc(sizeof(int) * (tail - head + 1));
    
    while(i <= mid && j <= tail)
    {
        if(a[i] <= a[j])
        {
            temp[k] = a[i];
            i = i + 1;
        }
        else
        {
            temp[k] = a[j];
            j = j + 1;    
        }
        k = k + 1;
    }
    
    while(i <= mid)
    {
        temp[k] = a[i];
        k = k + 1;
        i = i + 1;
    }
    
    while(j <= tail)
    {
        temp[k] = a[j];
        k = k + 1;
        j = j + 1;
    }
    
    for(i = 0; i < (tail - head + 1); i++)
    {
        a[ head + i] = temp[i];
    }
    
}

void is(int a[], int len)
{
    int i,j;
    for(i = 1; i < len; i++)
    {
        int val = a[i];    
        for(j = i - 1; j >=0; j--)
        {
            if(a[j] > val){
                a[j + 1] = a[j];
                if(j == 0)
                {
                    a[j] = val;
                    continue;
                }
            }
            else{
                a[j] = val;
                continue;
            }
        }
    }
}

void main()
{
    int a[]={
        5,4,3,2,1
    };

    int b[]={
        1,2,3,4,5
    };
    //qs(a, 0, 4);
    //hs(a, 5);
    //ms(a, 0, 4);
    //is(a, 5);
    printArray(a, 5);
    
    //printf("%d", binarySearchUnrecursion(a, 0, 4, 3));

}