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

#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("\n");
}

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));

}