Invalid conversion from `void*' to `int*' - C (СИ)

#define MAXN 10000 //максимальный размер массива для метода квадратичных проб
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
//---------------------------------------------------------------------------------------
void selection_method(char *a, int len) //сортировка методом прямого выбора
{
    /* внешний цикл. i – позиция первого неотсортированного элемента на данной итерации */
    int i;
    for (i = 0; i <= len - 1; i=i+1)
    {
        int min = i; /* min – позиция минимального элемента */
        /* внутренний цикл. если найден элемент строго меньший текущего минимального, записываем его индекс как минимальный */
        int j;
        for(j = i + 1; j <= len; j=j+1)
        {
            if(a[j] < a[min])
                min = j;
        }
        if(min != i) /* минимальный элемент не является первым неотсортированным, обмен нужен */
        {
            char tmp = a[i];
            char tmp1 = a[min];
            a[i] = tmp1;
            a[min]= tmp;
            printf("Перемещены элементы %d и %d", i, min);
        }
    }
    puts("Selection sort result");
    puts(a);
}
//---------------------------------------------------------------------------------------
void Swap(char Arr[], int i) //Перестановка i-го и i-1-го элемента массива Arr
{
    int temp;       //буфер
    temp = Arr[i];
    Arr[i] = Arr[i - 1];
    Arr[i - 1] = temp;
}
//---------------------------------------------------------------------------------------
void ShakerSort(char Arr[], int Start, int N) //Шейкер сортировка
{
    int Left, Right; //границы сортировки
 
    Left = Start;
    Right = N - 1;
    do
    {
        //Сдвигаем к началу массива "легкие элементы"
        int i;
        for (i = Right; i >= Left; i--)
        {
            if (Arr[i - 1]>Arr[i])
            {
                Swap(Arr, i);
            }
        }
 
        Left = Left + 1;
 
        //Сдвигаем к концу массива "тяжелые элементы"
 
        for (i = Left; i <= Right; i++)
        {
            if (Arr[i - 1] > Arr[i])
            {
                Swap(Arr, i);
            }
        }
 
        Right = Right - 1;
    }
    while (Left <= Right);
    puts("Shaker sort result");
    puts(Arr);
}
//---------------------------------------------------------------------------------------
void ShellSort(char v[], int n) //Сортировка Шелла
{
    int gap; // Расстояние между элементами
    int i,j,temp;
 
    for(gap = n/2; gap > 0; gap /= 2)
        for(i = gap; i < n; i++)
            for(j = i - gap; j >= 0 && v[j] > v[j + gap]; j -= gap)
            {
                temp = v[j];
                v[j] = v[j + gap];
                v[j + gap] = temp;
            }
    puts("Shell sort result");
    puts(v);
}
//---------------------------------------------------------------------------------------
void swap (char *a, char *b) //Функция обмена (по правилу трёх стаканов)
{
  char t = *a;
  *a = *b;
  *b = t;
}
//---------------------------------------------------------------------------------------
void PyramidSort(char a[], int n) //функция пирамидальной сортировки
{
    int  i, sh = 0, b = 0;
     while (1)
      {
        b = 0;
        for (i = 0; i < n; ++i)
        {
          if (i*2 + 2 + sh < n)
          {
            if (a[i+sh] > a[i*2 + 1 + sh] || a[i + sh] > a[i*2 + 2 + sh])
            {
              if (a[i*2+1+sh] < a[i*2+2+sh])
              {
                swap (&a[i+sh], &a[i*2+1+sh]);
                b = 1;
              }
              else if (a[i*2+2+sh] < a[i*2+1+sh])
              {
                swap (&a[i+sh],&a[i*2+2+sh]);
                b = 1;
              }
            }
          }
          else if (i * 2 + 1 + sh < n)
          {
            if (a[i+sh] > a[i*2+1+sh])
            {
              swap (&a[i+sh], &a[i*2+1+sh]);
              b=1;
            }
          }
        }
        if (!b) sh++;
        if (sh+2==n)
          break;
      }
     puts("Pyramid sort result");
     puts(a);
}
//---------------------------------------------------------------------------------------
void merge(char *a, long start, long split, long stop) {
// Слияние упорядоченных частей массива в буфер temp
// с дальнейшим переносом содержимого temp в a[lb]...a[ub]
 
  // текущая позиция чтения из первой последовательности a[lb]...a[split]
  long pos1=start;
 
  // текущая позиция чтения из второй последовательности a[split+1]...a[ub]
  long pos2=split+1;
 
  // текущая позиция записи в temp
  long pos3=0;
 
  int *temp;
  temp= malloc(sizeof(char)*(stop-start+1));
 
  // идет слияние, пока есть хоть один элемент в каждой последовательности
  while (pos1 <= split && pos2 <= stop) {
    if (a[pos1] < a[pos2])
      temp[pos3++] = a[pos1++];
    else
      temp[pos3++] = a[pos2++];
  }
 
  // одна последовательность закончилась -
  // копировать остаток другой в конец буфера
  while (pos2 <= stop)   // пока вторая последовательность непуста
    temp[pos3++] = a[pos2++];
  while (pos1 <= split)  // пока первая последовательность непуста
    temp[pos3++] = a[pos1++];
 
  // скопировать буфер temp в a[lb]...a[ub]
  for (pos3 = 0; pos3 < stop-start+1; pos3++)
    a[start+pos3] = temp[pos3];
 
  free(temp);
}
//---------------------------------------------------------------------------------------
void mergeSort(char *a, long start, long stop) { //сортировка слиянием
  long split;                   // индекс, по которому делим массив
 
  if (start < stop) {                // если есть более 1 элемента
 
    split = (start + stop)/2;
 
    mergeSort(a, start, split);       // сортировать левую половину
    mergeSort(a, split+1,stop);// сортировать правую половину
    merge(a, start, split, stop);    // слить результаты в общий массив
  }
 
}
//---------------------------------------------------------------------------------------
int GetEVersion1(char *a, int len, char e)
{   //метод поиска буквы Е №1
    int i;
    for(i =0; i != len; i=i+1) //поиск буквы Е перебором символов
    {
        if(a[i] == e)
        return i; //возвращаем ненулевой результат (позиция буквы Е в массиве)
    }
    return -1; //возвращаем -1 (если буква E не найдена)
}
//---------------------------------------------------------------------------------------
int GetEVersion2(char *a, int len, char e)
{   //метод поиска буквы Е №2
    ShakerSort(a, 0, len); //предварительно сортируем массив символов по алфавиту
    int i;
    for(i =0; i != len; i=i+1) //поиск буквы Е перебором символов
    {
        if(a[i] == e)
        return i;//возвращаем ненулевой результат (позиция буквы Е в отсортированном массиве)
    }
    return -1;//возвращаем -1 (если буква E не найдена)
}
//---------------------------------------------------------------------------------------
struct node //элемент хэш-таблицы
{
    char znac; //значение (символ)
    int key;   //ключ
};
struct node hashtable[MAXN]; //объявление хэш - таблицы
//---------------------------------------------------------------------------------------
int hash(char s) //функция построения хэш-кода символа
{
    int result;
    result = s; //в качестве хэша используем ASCII код
    return result;
}
//---------------------------------------------------------------------------------------
int kvhash(char* s) //метод квадратичных проб
{
    int ObTable = 0;
    int kolsl = strlen(s);
    int kolcol;
    kolcol = 0; //число коллизий
    int i;
    for( i =0; i!=strlen(s); i=i+1)
    {
        //получаем хэш-код символа
        int zn=1;
        int hs;
        hs=hash(s[i]);
        int num;
        num = hs;
        while(1)
        {
            //добавляем значение в хэш таблицу
            if (hashtable[num].key!=0)
            {
                        kolcol++;
                        //строки равны то выходим
                        if (hashtable[num].znac==s[i]) break;
                        //находим новую позицию как квадрат, меняем знак
                        num=(num+i*zn)*(num+i*zn); zn=-zn;
                        if (zn==1) i++;
                        //если вышли за пределы хэш-таблицы, то увеличиваем ее размер
                        if (num>kolsl && num<MAXN) kolsl=num;
                        //проверяем, не вышли ли за пределы массива
                        if (num>MAXN) num=num%MAXN;
                        if (num<0) num=1;
            }
            else
            {
                        ObTable++;
                        hashtable[num].znac =s[i];
                        hashtable[num].key=hs;
                        break;
            }
        }
    }
    return 0;
}
//---------------------------------------------------------------------------------------
struct chetv_chisl //структура - четверичное число
{
    int chislo[3]; //цифры четверичного числа
    int decimal_eqviv; //десятичный эквивалент четверичного числа
};
//---------------------------------------------------------------------------------------
int chetv_chisl_to_decimal(struct chetv_chisl ch)
{
            int c3 = ch.chislo[0] * 64;
            int c2 = ch.chislo[1] * 16;
            int c1 = ch.chislo[2] * 4;
            return  c1 + c2 + c3;
}
//---------------------------------------------------------------------------------------
void SwapChetvChisl(struct chetv_chisl Arr[], int i)
{
    struct chetv_chisl temp;       //буфер
    temp = Arr[i];
    Arr[i] = Arr[i - 1];
    Arr[i - 1] = temp;
}
//---------------------------------------------------------------------------------------
void ShakerSortChetvChisl(struct chetv_chisl Arr[], int Start, int N)
{
    int Left, Right; //границы сортировки
 
    Left = Start;
    Right = N - 1;

    do
    {
        //Сдвигаем к началу массива "легкие элементы"
        int i;
        for (i = Right; i >= Left; i--)
        {
            if (Arr[i - 1].decimal_eqviv>Arr[i].decimal_eqviv)
            {
                SwapChetvChisl(Arr, i);
            }
        }
 
        Left = Left + 1;
 
        //Сдвигаем к концу массива "тяжелые элементы"
 
        for (i = Left; i <= Right; i++)
        {
            if (Arr[i - 1].decimal_eqviv > Arr[i].decimal_eqviv)
            {
                SwapChetvChisl(Arr, i);
            }
        }
 
        Right = Right - 1;
    }
    while (Left <= Right);

}
//---------------------------------------------------------------------------------------
int main(void) {
        char fioconst[20] = {'P','l','o','t','n','e','r','c','h','u','k','D','m','i','t','r','y'};
        char fio[20];
        strcpy(fio,fioconst);
 
        /*1. Используя в качестве массива набор из 8 букв своих фамилии, имени, отчества,
         * определить на каждом шаге в методе прямого выбора номера перемещаемых элементов.*/
         puts("1. Используя в качестве массива набор из 8 букв своих фамилии, имени, отчества, определить на каждом шаге в методе прямого выбора номера перемещаемых элементов.");
         selection_method(fio, 8); //сотируем строку по методу прямого выбора + выводим номера перемещаемых элементов
         strcpy(fio,fioconst);
         /*2. Используя в качестве массива набор из 8 букв своих фамилии, имени, отчества,
              * опеределить на каждом шаге в методе шейкерной сортировки левую и правую границы сортируемой части массива (L и R)*/
 
         puts("2. Используя в качестве массива набор из 8 букв своих фамилии, имени, отчества, опеределить на каждом шаге в методе шейкерной сортировки левую и правую границы сортируемой части массива (L и R)");
         strcpy(fio,fioconst);
         ShakerSort(fio, 0, 8);
         /*3. Используя в качестве массива набор из 8 букв своих фамилии, имени, отчества, провести сортировку методом Шелла.
          * Последовательность шагов h1=1, h2=2.*/
 
         puts("3. Используя в качестве массива набор из 8 букв своих фамилии, имени, отчества, провести сортировку методом Шелла. Последовательность шагов h1=1, h2=2.");
         strcpy(fio,fioconst);
         ShellSort(fio, 8);
 
         /*4. Используя в качестве массива набор из 10 букв своих фамилии, имени, отчества, построить пирамиду и отсортировать массив.*/
         puts("4. Используя в качестве массива набор из 10 букв своих фамилии, имени, отчества, построить пирамиду и отсортировать массив.");
         strcpy(fio,fioconst);
         PyramidSort(fio,10);
 
          /*5. Провести сортировку последовательности из 15 букв своих фамилии, имени, отчества методом прямого слияния.*/
         puts("5. Провести сортировку последовательности из 15 букв своих фамилии, имени, отчества методом прямого слияния.");
         strcpy(fio,fioconst);
         mergeSort(fio,0, 15);
         puts("MergeSortResult");
         puts(fio);
 
        /*6. Составить произвольную последовательность из 12 трехзначных чисел
         * в четверичной системе счисления и отсортировать её при помощи цифровой сортировки*/
         puts("6. Составить произвольную последовательность из 12 трехзначных чисел в четверичной системе счисления и отсортировать её при помощи цифровой сортировки");
         struct chetv_chisl chisl_arr [12];
        //заполняем массив случайным образом
        int i = 0;
        for(;i!=12;i++)
        {
                chisl_arr[i].chislo[0] = (rand () % 9) + 1;
                chisl_arr[i].chislo[1] = (rand () % 9) + 1;
                chisl_arr[i].chislo[2] = (rand () % 9) + 1;
        }
 
        //переводим число в десятичную систему
 
        for(;i!=12;i++)
        {
            chisl_arr[i].decimal_eqviv = chetv_chisl_to_decimal(chisl_arr[i]);
        }
        ShakerSortChetvChisl(chisl_arr, 0, 12);
        puts("ChetvChisl Arr Shaker sort result");
        for(i=0; i!=12;i++)
        {
            printf("%d%d%d\n",chisl_arr[i].chislo[0],chisl_arr[i].chislo[1], chisl_arr[0].chislo[2] );
 
        }
 
        /*7. Провести быстрый поиск (2 версии) буквы "Е" (русс.) в массиве из 15 букв своих фамилии, имени, отчества.*/
        puts("7. Провести быстрый поиск (2 версии) буквы \"Е\" (русс.) в массиве из 15 букв своих фамилии, имени, отчества.");
        char e ;
         e= (char)'e';
         if( GetEVersion1(fio, 15,e) != -1) puts("Буква Е Способом 1 найдена!");
         else puts("Буква Е Способом 1 не найдена!");
         if( GetEVersion2(fio, 15,e) != -1) puts("Буква Е Способом 2 найдена!");
         else puts("Буква Е Способом 2 не найдена!");
 
        /*8. Построить хэш-таблицу методом квадратичных проб
         * для всех букв своих фамилии, имени, отчества*/
         puts("8. Построить хэш-таблицу методом квадратичных проб для всех букв своих фамилии, имени, отчества");
         kvhash(fio);
         //выводим хэш-таблицу на экран
         for(i = 0; i <= MAXN; i++ )
         {
                if(hashtable[i].znac != 0 )
                    printf("%c %d\n", hashtable[i].znac, hashtable[i].key);
         }

    return EXIT_SUCCESS;
}