#ifndef SRT_H
#define SRT_H

#define MAX_BUF 256

void srtbubb(void *, size_t, size_t, int (*)(const void *, const void *));
void srtheap(void *, size_t, size_t, int (*)(const void *, const void *));
void srtquik(void *, size_t, size_t, int (*)(const void *, const void *));
void srtshak(void *, size_t, size_t, int (*)(const void *, const void *));

#endif /* SRT_H */

#include <limits.h>
#include <stdio.h>
#include <stdlib.h>
#include "srt.h"

int intcmp(const void *, const void *);

int main(int argc, char *argv[]) {

  int size = argc == 2 ? atoi(argv[1]) : SHRT_MAX;

  int *a = calloc(size, sizeof(int));

#ifdef RAND
  for (int i = 0; i < size; ++i) {

    a[i] = rand();
  }
#else
  for (int i = 0; i < size; ++i) {

    a[i] = i;
  }
#endif

#if defined BUBB
  srtbubb(a, size, sizeof(int), intcmp);
#elif defined HEAP
  srtinsr(a, size, sizeof(int), intcmp);
#elif defined QUIK
  srtquik(a, size, sizeof(int), intcmp);
#elif defined SHAK
  srtshak(a, size, sizeof(int), intcmp);
#endif

#ifdef PRNT
  for (int i = 0; i < size; ++i) {

    printf("%i\n", a[i]);
  }
#endif

  free(a);

  return 0;
}

int intcmp(const void *p1, const void *p2) {

  if (*(int *)p1 < *(int *)p2) {

    return -5;
  }
  else if (*(int *)p1 > *(int *)p2) {

    return +5;
  }

  return 0;
}

#include <stdbool.h>
#include <stdlib.h>
#include <string.h>
#include "srt.h"

void srtbubb(void *base, size_t nelem, size_t size, int (*cmp)(const void *, const void *)) {

  for (size_t i = nelem - 1; i > 0; --i) {

    bool sorted = true;

    for (size_t j = 0; j < i; ++j) {

      char *qj = (char *)base + size * j;
      char *qn = qj + size;

      if (cmp(qj, qn) > 0) {

	sorted = false;

	char buf[MAX_BUF];
	char *q1 = qj;
	char *q2 = qn;

	for (size_t m, ms = size; ms > 0; ms -= m, q1 += m, q2 += m) {

	  m = ms < sizeof(buf) ? ms : sizeof(buf);

	  memcpy(buf, q1, m);
	  memcpy(q1, q2, m);
	  memcpy(q2, buf, m);
	}
      }
    }

    if (sorted) {

      break;
    }
  }

  return;
}

#include <stdlib.h>
#include <string.h>
#include "srt.h"

void srtquik(void *base, size_t nelem, size_t size, int (*cmp)(const void *, const void *)) {

  if (nelem > 1) {

    size_t i = 0;
    size_t j = nelem - 1;

    char *qi = (char *)base;
    char *qj = qi + size * j;
    char *qp = qj;

    while (i < j) {

      while (i < j && cmp(qi, qp) <= 0) {

	++i;
	qi += size;
      }

      while (i < j && cmp(qp, qj) <= 0) {

	--j;
	qj -= size;
      }

      if (i < j) {

	char buf[MAX_BUF];
	char *q1 = qi;
	char *q2 = qj;

	for (size_t m, ms = size; ms > 0; ms -= m, q1 += m, q2 += m) {

	  m = ms < sizeof(buf) ? ms : sizeof(buf);

	  memcpy(buf, q1, m);
	  memcpy(q1, q2, m);
	  memcpy(q2, buf, m);
	}

	++i;
	qi += size;
      }
    }

    if (qi != qp) {

      char buf[MAX_BUF];
      char *q1 = qi;
      char *q2 = qp;

      for (size_t m, ms = size; ms > 0; ms -= m, q1 += m, q2 += m) {

	m = ms < sizeof(buf) ? ms : sizeof(buf);

	memcpy(buf, q1, m);
	memcpy(q1, q2, m);
	memcpy(q2, buf, m);
      }
    }

    ++i;
    qi += size;

    srtquik(base, j, size, cmp);
    srtquik(qi, nelem - i, size, cmp);
  }

  return;
}

#include <stdbool.h>
#include <stdlib.h>
#include <string.h>
#include "srt.h"

void srtshak(void *base, size_t nelem, size_t size, int (*cmp)(const void *, const void *)) {

  for (size_t i = 0, j = nelem - 1; i < j; ++i, --j) {

    bool sorted = true;

    for (size_t k = i; k < j; ++k) {

      char *qk = (char *)base + size * k;
      char *qn = qk + size;

      if (cmp(qk, qn) > 0) {

	sorted = false;

	char buf[MAX_BUF];
	char *q1 = qk;
	char *q2 = qn;

	for (size_t m, ms = size; ms > 0; ms -= m, q1 += m, q2 += m) {

	  m = ms < sizeof(buf) ? ms : sizeof(buf);

	  memcpy(buf, q1, m);
	  memcpy(q1, q2, m);
	  memcpy(q2, buf, m);
	}
      }
    }

    if (sorted) {

      break;
    }

    for (size_t k = j - 1; k > i; --k) {

      char *qk = (char *)base + size * k;
      char *qp = qk - size;

      if (cmp(qk, qp) < 0) {

	sorted = false;

	char buf[MAX_BUF];
	char *q1 = qk;
	char *q2 = qp;

	for (size_t m, ms = size; ms > 0; ms -= m, q1 += m, q2 += m) {

	  m = ms < sizeof(buf) ? ms : sizeof(buf);

	  memcpy(buf, q1, m);
	  memcpy(q1, q2, m);
	  memcpy(q2, buf, m);
	}
      }
    }

    if (sorted) {

      break;
    }
  }

  return;
}

void srtheap(void *, size_t, size_t, int (*)(const void *, const void *));

#include <stdbool.h>
#include <stdlib.h>
#include <string.h>
#include "srt.h"


#define LEFT(x) ((x<<1) + 1)
#define RIGHT(x) ((x<< 1) +2)
#define PARENT(x) ((x-1) >> 1)

void swap(void*, void*);
void srtheap(void *, size_t, size_t, int (*)(const void *, const void *));

void swap(void *p1, void *p2)
{

	char buf[MAX_BUF];
	char *q1 = p1;
	char *q2 = p2;

	for (size_t m, ms = size; ms > 0; ms -= m, q1 += m, q2 += m) 
    {

	  m = ms < sizeof(buf) ? ms : sizeof(buf);

	  memcpy(buf, q1, m);
	  memcpy(q1, q2, m);
	  memcpy(q2, buf, m);
	}
}

void srtheap(void *base, size_t nelem, size_t size, int (*)(const void *, const void *))
{
    void *p1;
    void *p2;
    void *last = base + (size*(nelem-1));
    int checkchild;
    
    
    size_t index = nelem-1;
    
    for(int i = 0; i< nelem; ++i)
    {
        for(j=0; j< index -1; i++)
        {
                if(RIGHT(index) < nelem)
                {
                        checkchild = 2;
                        p1 = last - size;
                        p2 = last;
                                
                     if(cmp(L,R) > 0)
                     {
                         p2 = base + ((index-j)*size);
                         
                          if(cmp(p1,p2) > 0)
                           {
                              swap(p1,p2);
                                                      
                           }
                      }
                      
                      else if(cmp(p1,p2) < 0)
                      {
                         p1 = base+ ((index-j)*size);

                            
                            if(cmp(p2,p1) > 0)
                            {
                                  swap(p2, p1);
                            }
                      }
                else if(LEFT(index) < nelem)
                {
                   checkchild =1;
                   p1= last;
                   p2 = base+((index-j)*size);
                   
                    if(cmp(p1,p2) > 0)
                    {
                        swap(p1,p2);
                    }               
                }
                --track;
                switch(checkchild)
                {
                   case 1:
                   last = base+(size*index);
                   break;
                   case 2:
                   last = base+size*(index-1);
                   break;
                   default:
                }
                   
            }

    
    
}

# Project: Sort
# Makefile created by Dev-C++ 4.9.8.0

CPP  = g++.exe
CC   = gcc.exe
WINDRES = windres.exe
RES  = 
OBJ  = srtshak.o main.o srtbubb.o srtquik.o srtheap.o $(RES)
LINKOBJ  = srtshak.o main.o srtbubb.o srtquik.o srtheap.o $(RES)
LIBS =  -L"C:/Dev-Cpp/lib" 
INCS =  -I"C:/Dev-Cpp/include" 
CXXINCS =  -I"C:/Dev-Cpp/include/c++"  -I"C:/Dev-Cpp/include/c++/mingw32"  -I"C:/Dev-Cpp/include/c++/backward"  -I"C:/Dev-Cpp/include" 
BIN  = Sort.exe
CXXFLAGS = $(CXXINCS)  std=c99
CFLAGS = $(INCS)  std=c99

.PHONY: all all-before all-after clean clean-custom

all: all-before Sort.exe all-after


clean: clean-custom
	rm -f $(OBJ) $(BIN)

$(BIN): $(LINKOBJ)
	$(CC) $(LINKOBJ) -o "Sort.exe" $(LIBS)

srtshak.o: srtshak.c
	$(CC) -c srtshak.c -o srtshak.o $(CFLAGS)

main.o: main.c
	$(CC) -c main.c -o main.o $(CFLAGS)

srtbubb.o: srtbubb.c
	$(CC) -c srtbubb.c -o srtbubb.o $(CFLAGS)

srtquik.o: srtquik.c
	$(CC) -c srtquik.c -o srtquik.o $(CFLAGS)

srtheap.o: srtheap.c
	$(CC) -c srtheap.c -o srtheap.o $(CFLAGS)

void srtheap(void *base, size_t nelem, size_t size, int (*)(const void *, const void *))

void srtheap(void *base, size_t nelem, size_t size, int (*cmp)(const void *, const void *))