Инженерия ПЗ Бакалавр / sort

// ПОРАЗРЯДНАЯ СОРТИРОВКА
void bitwiseSort(int Lenght, MyLst *&StartItem)
{
Queue qList;
Queue qArray[10];
int dopValue = 0;
int bitwise = 0;
MyLst *CurrentItem = nullptr;
CurrentItem = StartItem;
while (CurrentItem != nullptr)
{
qList.Qlnsert(CurrentItem->ElementLest);
CurrentItem = CurrentItem->NextItem;

}

for (int i = 0; i != 2; i++)
{
for (int j = 0; j != Lenght; j++)
{
dopValue = qList.qPeek();
if (i == 0)
{
bitwise = dopValue % 10;
}
else
{
bitwise = dopValue / 10;
}

qArray[bitwise].Qlnsert(dopValue);
}
qList.ClearQueue();
for (int j = 0; j != 10; j++)
{
dopValue = qArray[j].qPeek();
while (dopValue != 0)
{
qList.Qlnsert(dopValue);
dopValue = qArray[j].qPeek();
}
}
}
CurrentItem = StartItem;
while (CurrentItem != nullptr)
{
CurrentItem->ElementLest = qList.qPeek();
CurrentItem = CurrentItem->NextItem;
}

}



// ---------------------------------------------- //

// Сортировка массива рекурсивным слиянием

void sort(int A[], int a, int b)
{
if (a>=b)
return; // Разделение закончилось
int m=(a+b+1)/2,i,j,k; // Нет - взять середину интервала
sort(A,a,m-1); // Рекурсивный вызов для частей
sort(A,m,b);
int *tmp=new int[b-a+1]; // Слияние частей во временный массив
for (i=a,j=m,k=0; k<=b-a; k++)
if (i==m || j!=b+1 && A[j]<A[i])
tmp[k]=A[j++]; // слить из второй части, если
else // первая кончилась или во второй меньше
tmp[k]=A[i++]; // слить из первой части
for (i=a,j=0; i<=b; i++,j++)
A[i]=tmp[j]; // вернуть слитые части обратно в A
delete tmp; // удалить временный массив
}

// ---------------------------------------------- //


//------- Сортировка массива рекурсивным разделением
// В качестве медианы - среднее арифметическое
void sort(int in[], int a, int b)
{
int i,j,mode;
double sr=0;
if (a>=b)
return; // Размер части =0
for (i=a; i<=b; i++) sr+=in[i];
sr=sr/(b-a+1);
for (i=a, j=b; i <= j;)
{
if (in[i]< sr) { i++; continue; } // Слева - меньше, пропустить
if (in[j]>=sr) { j--; continue; } // Справа - больше, пропустить
int c = in[i]; in[i] = in[j]; in[j]=c;
i++,j--; // Поменять местами и пропустить
}
if (i==a) return; // все равны и в правой части
sort(in,a,j); sort(in,i,b); // рекурсивный вызов для двух частей
}


// ---------------------------------------------- //
//-------"Быстрая" сортировка
void sort(int in[], int a, int b)
{
int i,j,mode;
if (a>=b) return; // Размер части =0
for (i=a, j=b, mode=1; i < j; mode >0 ? j-- : i++) // Сокращение слева или справа
if (in[i] > in[j])
{ // Очередной не на своем месте
int c = in[i]; in[i] = in[j]; in[j]=c; // Перестановка медианы с концевым
mode = -mode; // элементом со сменой сокращаемого конца
}

sort(in,a,i-1); sort(in,i+1,b); // рекурсия для частей БЕЗ медианы
}
 



// ---------------------------------------------- //

// СОРТИРОВКА НА ОДНОСВЯЗНОМ СПИСКЕ

void sortInsert(int Lenght, MyLst *&StartItem)
{
Stack stack;
MyLst *CurrentItem = nullptr;
MyLst *NextItem = nullptr;
MyLst *predCurrentItem = nullptr;
MyLst *predNextItem = nullptr;
// MyLst *saveFirst = nullptr;
int p = 0;
predCurrentItem = StartItem;
CurrentItem = StartItem->NextItem;
for (int i = 1; i != Lenght; i++)
{
predNextItem = nullptr;
NextItem = StartItem;
while (NextItem != CurrentItem)
{
if (CurrentItem->ElementLest>NextItem->ElementLest)
{
predNextItem = NextItem;
NextItem = NextItem->NextItem;
}
else
{
if (predCurrentItem == NextItem)
{

if (predNextItem)
{

stack.Push(NextItem);
stack.Push(CurrentItem);
stack.Push(CurrentItem->NextItem);
NextItem->NextItem = stack.Peek();
predNextItem->NextItem = stack.Peek();
CurrentItem->NextItem = stack.Peek();
CurrentItem = NextItem;
break;
}
else
{
stack.Push(CurrentItem->NextItem);
NextItem->NextItem = stack.Peek();
CurrentItem->NextItem = NextItem;
if (NextItem == StartItem)
{
StartItem = CurrentItem;
}

CurrentItem = NextItem;

break;
}

}
else
{
if (predNextItem)
{
//stack.Push(predNextItem->NextItem);
stack.Push(CurrentItem);
stack.Push(CurrentItem->NextItem);
predCurrentItem->NextItem = stack.Peek();
predNextItem->NextItem = stack.Peek();
CurrentItem->NextItem = NextItem /*stack.Peek()*/;
CurrentItem = predCurrentItem;
break;
}
else
{
stack.Push(NextItem);
stack.Push(CurrentItem->NextItem);
predCurrentItem->NextItem = stack.Peek();
CurrentItem->NextItem = stack.Peek();
if (NextItem == StartItem)
StartItem = CurrentItem;
CurrentItem = predCurrentItem;
break;
}
}

}
}
predCurrentItem = CurrentItem;
stack.ClearStack();

CurrentItem = CurrentItem->NextItem;
}
}



// ---------------------------------------------- //



// ---------------------------------------------- //


// ---------------------------------------------- //




// ----------------------------------------------------------------


//Классическая приоритетная очередь на базе бинарной кучи

#include <cstdio>
#include <cstdlib>
using namespace std;

template<typename T, typename Cmp>
class TPQueue {
private:
T* arr;
size_t cnt;
size_t mem;
Cmp cmp;
public:

TPQueue(void) : arr(NULL), cnt(0), mem(16) {}
~TPQueue() {
this->clear();
}

TPQueue(const TPQueue&);
TPQueue& operator = (const TPQueue&);
public:

bool push(const T& val) {
size_t i, p;
T tmp;

if (!this->_alloc())
return false;
arr[cnt] = val;

i = cnt;
p = (!i) ? 0 : (i - 1) >> 1;

while ((i > 0) && !cmp(arr[p], arr[i])) {
tmp = arr[i];
arr[i] = arr[p];
arr[p] = tmp;

i = p--;
if (!i)
break;
p >>= 1;
}
++cnt;
return true;
}

void pop(void) {
if (cnt > 1) {
arr[0] = arr[--cnt];
this->this_heapify(0);
}
else
cnt = 0;
}

T& top(void) { return arr[0]; }
T& top(void) const { return arr[0]; }

bool empty(void) const { return (!cnt); }

size_t size(void) const { return cnt; }

void clear(void) {
if (arr != NULL)
delete[] arr;
arr = NULL;
cnt = 0;
mem = 16;
}

private:

bool _alloc(void) {
size_t tmem;
T* tmp;

if (arr == NULL) {
arr = new T[mem];
if (arr == NULL)
return false;
}

if ((cnt + 1) >= mem) {
tmem = cnt + 1 + cnt / 3;
tmp = new T[tmem];
if (tmp == NULL)
return false;
for (size_t i = 0u; i < cnt; ++i)
tmp[i] = arr[i];
delete[] arr;
arr = tmp;
mem = tmem;
}
return true;
}

void this_heapify(size_t index) {
size_t l, r, big;
T tmp;

while (1) {
l = (index << 1) + 1u;
r = (index << 1) + 2u;

if ((l < cnt) && cmp(arr[l], arr[index]))
big = l;
else
big = index;

if ((r < cnt) && cmp(arr[r], arr[big]))
big = r;

if (big != index) {
tmp = arr[index];
arr[index] = arr[big];
arr[big] = tmp;
index = big;
}
else
break;
}
}
};

struct cmp {
bool operator () (const int& a, const int& b) const {
return (a > b);
}};

int main(void) {
TPQueue<int, cmp> pq;

for (int i = 0; i < 30; ++i)
pq.push(rand() % 400);

while (!pq.empty()) {
printf("%d\n", pq.top());
pq.pop();
}
return 0;
}