Shell Sort and Sort Verification

Я довольно новичок в кодировании, и я боролся с этим кодом, который позволит мне случайным образом генерировать массивный массив целых чисел, выбирать конкретную сортировку оболочки и затем проверять, был ли массив отсортирован правильно.

#include <iostream>
#include <stdlib.h>
#include <time.h>
#define LISTLEN 100000
using namespace std;

void shellSort(int[], int, int[], int);
void testIfSorted(int[], int);

void main()
{
{
int list[LISTLEN];
int seq1[] = {LISTLEN/2};
int seq2[] = {2-1};
int seq3[] = { 4 + 3 * (2 ^ 0) + 1 };
int choice;

for (int i = 1; i < LISTLEN; i++)
{
list[i] = rand() % LISTLEN + 1;

cout << list[i] << endl;
}
cout << "\nEnter the Number for Which Sequence-Type You Wish to Use: \n""1) Shell Sequence\n""2) Hibbard Sequence\n""3) Sedgewick Sequence\n";
cin >> choice;

if (choice == 1)
{
shellSort(list, LISTLEN, seq1, LISTLEN / 2);
}
else if (choice == 2)
{
shellSort(list, LISTLEN, seq2, (2 - 1));
}
else if (choice == 3)
{
shellSort(list, LISTLEN, seq3, (4 + 3 * (2 ^ 0) + 1));
}

cout << "\nVerifying List was Sorted\n";
testIfSorted;
}
}

void shellSort(int arr[], int arrsize, int seq[], int seqsize)
{
clock_t t;
t = clock();
{
int j, temp;
for (int i = seqsize; i < arrsize; i += 1)
{
temp = seq[i];
for (j = i; j >= seqsize && seq[j - seqsize] > temp; j -= seqsize)
{
seq[j] = seq[j - seqsize];
}
seq[j] = temp;
cout << temp << endl << endl;
}
t = clock() - t;
printf("It took me %d clicks (%f seconds).\n", t, ((float)t) / CLOCKS_PER_SEC);
}
}

void testIfSorted(int list[], int length)
{
for (int i = 0; i < length - 1; i++)
{
if (list[i] < list[i + 1])
{
cout << "List Isn't Sorted Correctly\n";
}
else (list[i] > list[i + 1]);
{
cout << "List Sorted Correctly\n";
}
}
}

Я не знаю, что я делаю неправильно, сортировка оболочки на самом деле не сортирует массив или, по крайней мере, не выполняет сортировку по убыванию, и если программа проверяет, правильно ли отсортирован массив, она выиграла не отображать сообщение, которое я хочу, чтобы оно отображалось.

0

Решение

У меня нет конкретного ответа, но вот несколько советов по быстрой отладке:

1 — запустить код через clang-format, Если вы не можете / не можете установить его на свой компьютер, доступны онлайн-форматеры, такие как http://format.krzaq.cc/

2 — скомпилируйте ваш код с clang Компилятор со всеми включенными предупреждениями. Опять же, если вы не можете / не можете установить clang на вашем компьютере есть несколько онлайн-песочниц для игры. Почему лязг? Они приложили большие усилия, чтобы выдать очень приятные предупреждения / сообщения об ошибках.

Я сделал и то, и другое clang пришлось сказать о программе (ссылка Вот)

prog.cc:10:1: error: 'main' must return 'int'
void main()
^~~~
int

prog.cc:41:9: warning: expression result unused [-Wunused-value]
testIfSorted;
^~~~~~~~~~~~

prog.cc:61:56: warning: format specifies type 'int' but the argument has type 'clock_t' (aka 'long') [-Wformat]
printf("It took me %d clicks (%f seconds).\n", t, ((float)t) / CLOCKS_PER_SEC);
~~                          ^
%ld

prog.cc:45:20: warning: unused parameter 'arr' [-Wunused-parameter]
void shellSort(int arr[], int arrsize, int seq[], int seqsize)
^

prog.cc:72:22: warning: expression result unused [-Wunused-value]
(list[i] > list[i + 1]);
~~~~~~~ ^ ~~~~~~~~~~~

4 warnings and 1 error generated.

Это может помочь — особенно последний!

2

Другие решения

Сортировка снарядов сломана. Кажется, пытается сортировать разрыв последовательность seq[] когда это должно быть сортировка значение последовательность arr[], Кроме того, последовательность пропусков должна быть последовательностью значений. Например:

static void hsort(int a[], size_t n, size_t h)
{
for ( size_t i, j = h; j < n; j++ ) {
int temp = a[j];
// @note the comparison is setup for descending.
for ( i = j; i >= h && temp > a[i-h]; i -= h )
a[i] = a[i-h];
a[i] = temp;
}
}

Последовательность оболочки:

void shellsort1(int a[], size_t n)
{
for ( size_t h = n/2; h > 0; h /= 2 )
hsort(a, n, h);
}

Последовательность Кнута:

void shellsort2(int a[], size_t n)
{
size_t i, h = 0;
while ( 2*(i = h*3+1) <= n )
h = i;
for ( ; h > 0; h /= 3 )
hsort(a, n, h);
}

В совокупности ценности h при каждом звонке hsort ваша последовательность пробелов. Поочередно они могут быть предварительно вычислены и сохранены.


Тестирование последовательности по убыванию (или, точнее, не по возрастанию) может быть выполнено с помощью:

bool is_descending(int a[], size_t n)
{
for ( size_t i = 1; i < n; i++ )
if (a[i-1] < a[i])
return false;
return true;
}

Однако этого теста недостаточно для проверки правильности алгоритма. Рассмотрим функцию, которая просто устанавливает все элементы в одно значение. Результирующая последовательность прошла бы этот тест. Визуальный осмотр — хотя и несколько полезный при отладке — подвержен ошибкам и невозможен для больших наборов.

Лучшее решение — выделить дубликат массива и отсортировать его с помощью известного хорошего алгоритма, а затем сравнить каждый элемент на равенство.

0

По вопросам рекламы [email protected]