#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define N 100000000
#define M 100
#define SWAP(a,b) {int tmp; tmp = a; a = b; b = tmp;}
void arrPrint(int* arr);
void arr_bubble(int* arr);
void arr_select(int* arr);
void arr_Insert(int* arr);
void Binary_Insert_sort(int* arr);
void shell_sort(int* arr);
int partition(int* arr, int left, int right);
void arr_quick(int* arr, int left, int right);
void arr_Heap(int* arr);
void adjust_Max_Heap(int* arr, int adjustPos, int arrLen);
void heapSort(void* arr, size_t num, size_t size, int(*compare)(const void* a, const void* b));
void heapMax(void* arr, void* dadStartAddr, int len, int code_Num, int size, int(*compare)(const void* a, const void* b));
void swap(char* a, char* b, int len);
#include "sort.h"
void arrPrint(int* arr)
{
int i;
for (i = 0; i < N; i++)
{
printf("%3d", arr[i]);
}
printf("\n");
}
void arr_bubble(int* arr)
{
int i, j;
for (i = N - 1; i > 0; i--)
{
for (j = 0; j < i; j++)
{
if (arr[j] > arr[j + 1])
{
SWAP(arr[j], arr[j + 1]);
}
}
}
}
void arr_select(int* arr)
{
int i, j, min_pos;
for (i = 0; i < N - 1; i++)
{
min_pos = i;
for (j = i + 1; j < N; j++)
{
if (arr[min_pos] > arr[j])
{
min_pos = j;
}
}
SWAP(arr[i], arr[min_pos]);
}
}
void arr_Insert(int* arr)
{
int i, j, insertval;
for (i = 1; i < N; i++)
{
insertval = arr[i];
for (j = i - 1; j >= 0; j--)
{
if (arr[j] > insertval)
{
arr[j + 1] = arr[j];
}
else {
break;
}
}
arr[j + 1] = insertval;
}
}
void Binary_Insert_sort(int* arr)
{
int middle;
for (int i = 1; i < N; i++)
{
int insertNum = arr[i];
int left = 0;
int right = i - 1;
while (left <= right)
{
middle = (left + right) / 2;
if (insertNum > arr[middle])
{
left = middle + 1;
}
else {
right = middle - 1;
}
}
for (int j = i; j > left; j--)
{
arr[j] = arr[j - 1];
}
arr[left] = insertNum;
}
}
void shell_sort(int* arr)
{
int gap, i, j;
int insertval;
for (gap = N >> 1; gap > 0; gap >>= 1)
{
for (i = gap; i < N; i++)
{
insertval = arr[i];
for (j = i - gap; j >= 0; j -= gap)
{
if (arr[j] > insertval)
{
arr[j + gap] = arr[j];
}
else {
break;
}
}
arr[j + gap] = insertval;
}
}
}
int partition(int* arr, int left, int right)
{
int i;
int k = left;
for (i = left; i < right; i++)
{
if (arr[i] < arr[right])
{
SWAP(arr[k], arr[i]);
k++;
}
}
SWAP(arr[right], arr[k]);
return k;
}
void arr_quick(int* arr, int left, int right)
{
int pivot;
if (left < right)
{
pivot = partition(arr, left, right);
arr_quick(arr, left, pivot - 1);
arr_quick(arr, pivot + 1, right);
}
}
void adjust_Max_Heap(int* arr, int adjustPos, int arrLen)
{
int dad = adjustPos;
int son = 2 * dad + 1;
while (son < arrLen)
{
if (son + 1 < arrLen && arr[son] < arr[son + 1])
{
son++;
}
if (arr[dad] < arr[son])
{
SWAP(arr[dad], arr[son]);
dad = son;
son = 2 * dad + 1;
}
else
{
break;
}
}
}
void arr_Heap(int* arr)
{
int i;
for (i = N / 2 - 1; i >= 0; i--)
{
adjust_Max_Heap(arr, i, N);
}
SWAP(arr[0], arr[N - 1]);
for (i = N - 1; i > 1; i--)
{
adjust_Max_Heap(arr, 0, i);
SWAP(arr[0], arr[i - 1]);
}
}
void heapSort(void* arr, size_t num, size_t size, int(*compare)(const void* a, const void* b))
{
int i;
for (i = num / 2 - 1; i >= 0; i--) {
heapMax(arr, (char*)arr + i * size, num, i, size, compare);
}
swap((char*)arr, (char*)arr + (num - 1) * size, size);
for (i = num - 1; i > 1; i--) {
heapMax(arr, arr, i, 0, size, compare);
swap((char*)arr, (char*)arr + (i - 1) * size, size);
}
}
void swap(char* a, char* b, int len) {
char temp;
while (len--) {
temp = *a;
*a++ = *b;
*b++ = temp;
}
}
void heapMax(void* arr, void* dadStartAddr, int len, int code_Num, int size, int(*compare)(const void* a, const void* b))
{
char* dad = (char*)dadStartAddr;
char* son = (char*)arr + (code_Num * 2 + 1) * size;
code_Num = code_Num * 2 + 1;
while (son <= (char*)arr + (len - 1) * size)
{
if (son + size <= (char*)arr + (len - 1) * size && compare(son, son + size) < 0)
{
son = son + size;
code_Num++;
}
if (compare(dad, son) < 0)
{
swap(dad, son, size);
dad = son;
son = (char*)arr + (code_Num * 2 + 1) * size;
code_Num = code_Num * 2 + 1;
}
else
{
break;
}
}
}
#include "sort.h"
int compare(const void* a, const void* b)
{
return *(int*)a - *(int*)b;
}
int main()
{
int i = 0;
int* arr = (int*)malloc(N * sizeof(int));
time_t start, end;
srand(time(NULL));
for (i = 0; i < N; i++)
{
arr[i] = rand() % M;
}
start = time(NULL);
arr_Heap(arr);
end = time(NULL);
printf("use time=%d\n", end - start);
system("pause");
return 0;
}