C ++ Array Sort Me

Question

Застрял на сортировщике массива. Приходится сортировать числа от самых больших до самых маленьких. Я пробую две петли (одна вложена в другую). Вот код:

int counter=0; // inner counter
int counter2=0; // outer counter
int sparky[14]; //array set to 14 just to simplify things
int holder; // holds the highest value
int high; //stores the position where it found the value holder

while (counter2 < howmany)
 {
  holder= sparky[counter];
  while (counter <= howmany)
   {
    counter++;
    if (sparky[counter] > holder)
     {
      holder= sparky[counter];
      high= counter; 
     }
   }
   counter2++;
   counter=counter2;
   sparky[high]= sparky[counter-1];
   sparky[counter-1]=holder;
 }

---

Массив несортирован:

data[ 0] = 9
data[ 1] = 8
data[ 2] = 7
data[ 3] = 15
data[ 4] = 14
data[ 5] = 3
data[ 6] = 2
data[ 7] = 1
data[ 8] = 10
data[ 9] = 6
data[10] = 5
data[11] = 4
data[12] = 13
data[13] = 12
data[14] = 11

---

Массив отсортирован из-за кода:

data[ 0] = 15
data[ 1] = 14
data[ 2] = 13
data[ 3] = 12
data[ 4] = 11
data[ 5] = 11
data[ 6] = 10
data[ 7] = 9
data[ 8] = 8
data[ 9] = 7
data[10] = 6
data[11] = 5
data[12] = 4
data[13] = 3
data[14] = 2

Как вы можете видеть, 11 появляется дважды в "отсортированном" коде. Хотя, даже когда я набираю это, мне интересно, имеет ли значение значение high какое-либо отношение к этому

Answer 1

Перво-наперво:

int sparky[14];

даст вам массив из 14 элементов sparky[0..13], , а не 15 элементов, как вам кажется.

Во-вторых, ваш внутренний цикл не совсем правильный. Ваш начинается с индекса 1 и переходит к индексу 15, тогда как, поскольку массив C начинается с нуля, вы должны циклически изменяться от 0 до 14.

Это можно исправить, изменив условие цикла на while (counter < howmany) и переместив counter++ непосредственно перед концом внутреннего цикла.

Просто чтобы прояснить этот момент, вы делаете на самом деле начинаете цикл с 0, но, поскольку первое, что вы делаете в цикле, это counter++ перед использованием sparky[counter], вы обрабатываете элементы начиная с индекса 1. И, в последнем цикле цикла, где counter == howmany (14 согласно вашим другим комментариям здесь), вы увеличиваете его до 15 и используете то, что находится за концом массива.

И, чтобы прояснить это уточнение :-), ваш цикл будет правильным, если у вас установлено значение 14 (т. Е. На один меньше, чем количество элементов массива), поскольку, как вы указали в комментарий в другом месте, вы загружаете нулевой элемент перед входом во внутренний цикл. Я думаю, что do все равно нужно установить high всякий раз, когда вы устанавливаете holder. Если этого не сделать, я получу два 6 и два 2 в моем списке, а не 3 или 4.

В качестве дополнительной проблемы для вашего комментария о том, что для howmany установлено значение 14, я бы предложил, чтобы имена переменных отражали их намерения. У вас явно есть 15 элементов в массиве (индексы от 0 до 14 включительно). Не воспринимайте это как критику, я просто пытаюсь помочь.

В-третьих, (и, наконец, я думаю), вы не устанавливаете high каждый каждый раз, когда вы устанавливаете holder - они должны синхронизироваться для правильной работы вашего алгоритма.

Пожалуйста, дайте нам знать, это домашнее задание. Если нет, я выложу свое решение. Если это так, вы должны решить это из руководящих принципов, приведенных в этом и других ответах. Вы должны знать, что, если это домашнее задание, и вы используете решение, опубликованное на публичном форуме в Интернете (например, это), вы почти наверняка потерпите неудачу из-за плагиата. Не делайте ошибку, думая, что ваши преподаватели не проверяют такого рода вещи.

Итог, хотя я рад опубликовать свое решение, вы, вероятно, не должны использовать его в качестве классной работы. Высшие оценки, хотя, по крайней мере, дать ему выстрел в первую очередь. Большинство искателей домашних заданий, похоже, приходят сюда только с техническими характеристиками: -)

Обновление: Поскольку вы опубликовали следующее:

Извините, что упомянул, но это часть дополнительного кредитного проекта для класса.

Я думаю, это классная работа. Так что, для вас нет супа :-) Тем не менее, трех пунктов выше должно быть достаточно, чтобы вы могли это исправить. Если у вас есть конкретные вопросы по ним, не стесняйтесь спрашивать в комментарии к этому ответу.

Удачи.

Answer 2

, если это не домашнее задание, вы можете попробовать:

std::sort(A, A + N, std::greater<int>());

Answer 3

Попробуйте это:

int counter=0; // inner counter 
int counter2=0; // outer counter 
int sparky[14] = {14,13,12,11,10,9,8,7,6,5,4,3,2,1}; //array set to 14 just to simplify things 
int holder; // holds the highest value 
int FoundIndex; //stores the position where it found the value holder
int temp; 
bool Found; 
while (counter2 < howmany) 
 { 
  holder= sparky[counter];
  Found = false; 
  while (counter <= howmany && !Found) 
   { 

        if (sparky[counter] >= holder) 
         { 
              holder= sparky[counter]; 
              FoundIndex= counter; 
              Found = true; 
         }
         counter++; 
   } 
   counter2++; 
   counter=counter2;
   temp = sparky[FoundIndex]; 
   sparky[FoundIndex]= sparky[counter-1]; 
   sparky[counter-1]=temp; 
 }

В основном я просто исправил твой внутренний цикл и поменялся местами. но не используйте его, если не понимаете. ошибки, которые вы допустили, были довольно тривиальными, поэтому я чувствую себя комфортно, публикуя код, который вы можете использовать ... Основная идея заключается в том, что если вы используете этот вид сортировки (без каламбура), будьте очень осторожны, когда ваши индексы заканчиваются. При работе с двумя счетчиками убедитесь, что вы отслеживаете их и даете им значимые имена переменных. counter и counter2 не так хороши. Попробуйте что-то вроде externalCounter и innerCounter. Кроме того, высокий был изменен на FoundIndex.

запомните, код трассировки (код, который просто выводит значение varaible) чрезвычайно важен для выяснения такого рода проблем ... просто вставив 'cout << counter << endl; показал, что он проходит через конец массива ... </p>

Answer 4

да, это так ...

посмотрите, где вы используете holder = sparky [counter]; и искрящийся [высокий] = искрящийся [counter-1]

если вы прочитаете ваш код, вы увидите, что когда значение установлено для последнего значения, counter-1 и sparky [high] - это одно и то же. это произойдет на всех значениях, но вы заметите это только на последнем

попробуйте добавить туда отладочный код, чтобы сказать: «Я перемещаю это значение в это место», чтобы показать вам, что вы на самом деле делаете ... это может помочь:)