Программа для поиска наибольшего и второго по величине числа в массиве

Question

Я искал много сайтов для этого вопроса. Они делают это с помощью другого подхода. Этот код просто не дает выход, если я ввожу первый элемент массива как самый большой i.e a[0]. Я думаю, что некоторые незначительные изменения не требуются. Может ли кто-нибудь мне рассказать?

#include <stdio.h> 

int main() { 
    int a[10], n; 
    int largest1, largest2, i; 

    printf("enter number of elements you want in array"); 
    scanf("%d", &n); 
    printf("enter elements"); 
    for (i = 0; i < n; i++) { 
     scanf("%d", &a[i]); 
    } 
    largest1 = a[0]; 
    for (i = 0; i < n; i++) { 
     if (a[i] > largest1) { 
      largest1 = a[i]; 
     } 
    } 
    largest2 = a[0]; 
    for (i = 1; i < n; i++) { 
     if (a[i] > largest2 && a[i] < largest1) 
      largest2 = a[i]; 
    } 
    printf("First and second largest number is %d and %d ", largest1, largest2); 
} 

Answer 1

Вы должны сохранить индекс элементов массива лучше, так как они уникальный Здесь рабочий код с некоторыми изменениями:

#include<stdio.h> 
int main() 
{ 
    int a[10],n; 
    int largest1,largest2,i; 

    printf("enter number of elements you want in array"); 
    scanf("%d",&n); 
    printf("enter elements"); 
    for(i=0;i<n;i++) 
    { 
     scanf("%d",&a[i]); 
    } 
    largest1=0; 
    for(i=0;i<n;i++) 
    { 
     if(a[i]>a[largest1]) 
     { 
      largest1=i; 
     } 
    } 
    if(largest1!=0) // this condition to select another index than the largest 
     largest2=0; 
    else 
     largest2=n-1; 
    for(i=0;i<n && i != largest1 ;i++) 
    { 
     if(a[i]>a[largest2]) 
      largest2=i; 
    } 
    printf("First and second largest number is %d and %d ",a[largest1],a[largest2]); 
} 

Обратите внимание, что, когда массив имеет размер 1 значений будет быть одинаковым.

Answer 2

(Я собираюсь игнорировать обработку ввода, его просто развлечением.)

Простой способ для сортировки.

#include <stdlib.h> 
#include <stdio.h> 

int cmp_int(const void *a, const void *b) { 
    return *(int*)a - *(int*)b; 
} 

int main() { 
    int a[] = { 1, 5, 3, 2, 0, 5, 7, 6 }; 
    const int n = sizeof(a)/sizeof(a[0]); 

    qsort(a, n, sizeof(a[0]), cmp_int); 
    printf("%d %d\n", a[n-1], a[n-2]); 
} 

Но это не самый эффективный, потому что это O(n log n), то есть, как массив становится больше количество сравнений становится больше быстрее. Не слишком быстро, медленнее экспоненциального, но мы можем сделать лучше.

Мы можем сделать это в O(n) или «линейное время», поскольку массив становится больше, количество сравнений растет с одинаковой скоростью.

Прокрутите массив, отслеживая максимум, это обычный способ найти максимум. Когда вы найдете новый макс, старый max становится вторым по величине номером.

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

#include <stdio.h> 
#include <limits.h> 

int main() { 
    int a[] = { 1, 5, 3, 2, 0, 5, 7, 6 }; 
    // This trick to get the size of an array only works on stack allocated arrays. 
    const int n = sizeof(a)/sizeof(a[0]); 

    // Initialize them to the smallest possible integer. 
    // This avoids having to special case the first elements. 
    int max = INT_MIN; 
    int second_max = INT_MIN; 

    for(int i = 0; i < n; i++) { 
     // Is it the max? 
     if(a[i] > max) { 
      // Make the old max the new 2nd max. 
      second_max = max; 
      // This is the new max. 
      max = a[i]; 
     } 
     // It's not the max, is it the 2nd max? 
     else if(a[i] > second_max) { 
      second_max = a[i]; 
     } 
    } 

    printf("max: %d, second_max: %d\n", max, second_max); 
} 

Там может быть более элегантный способ сделать это, но это будет делать, в большинстве, 2n сравнений. В лучшем случае это будет n.

Обратите внимание, что есть открытый вопрос, что делать с { 1, 2, 3, 3 }. Должно ли это возвращаться 3, 3 или 2, 3? Я оставлю это вам, чтобы решить и соответствующим образом настроить.

Answer 3

Вопрос неоднозначен: если массив может содержать повторяющиеся значения, вы должны найти 2 наибольших отдельных значения или два наибольших возможно одинаковых значения?

Ваш код показывает, что вам нужен первый подход, но у вас есть проблема, если наибольшее значение - a[0]. Вы должны использовать дополнительное логическое значение, чтобы отслеживать, находили ли вы другое значение.

Вы также должны проверить возвращаемое значение различных вызовов и возврата scanf() 0 от main().

Вот модифицированная версия:

#include <stdio.h> 

int main(void) { 
    int a[10], n, i; 
    int largest1, largest2, has_largest2; 

    printf("enter number of elements you want in array: "); 
    if (scanf("%d", &n) != 1) 
     return 1; 
    if (n < 2) { 
     printf("need at least 2 elements\n"); 
     return 1; 
    } 
    printf("enter elements: "); 
    for (i = 0; i < n; i++) { 
     if (scanf("%d", &a[i]) != 1) { 
      printf("input error\n"); 
      return 1; 
     } 
    } 
    largest1 = a[0]; 
    for (i = 1; i < n; i++) { 
     if (a[i] > largest1) { 
      largest1 = a[i]; 
     } 
    } 
    has_largest2 = largest2 = 0; 
    for (i = 0; i < n; i++) { 
     if (a[i] < largest1) { 
      if (!has_largest2) { 
       has_largest2 = 1; 
       largest2 = a[i]; 
      } else 
      if (a[i] > largest2) { 
       largest2 = a[i]; 
      } 
     } 
    } 
    if (has_largest2) { 
     printf("First and second largest number is %d and %d\n", 
       largest1, largest2); 
    } else { 
     printf("All values are identical to %d\n", largest1); 
    } 
    return 0; 
} 

Answer 4

Вы можете сделать это лучше всего в один проход.

наибольший и самый большой2 установлены на INT_MIN при входе. Затем пройдите через массив.Если наибольшее число меньше числа, наибольшее становится наибольшим, тогда наибольшее становится новым числом (или меньше или равно, если вы хотите разрешить дубликаты). Если наибольшее значение больше, то новое число, test most2.

Обратите внимание, что этот алгоритм масштабируется, чтобы найти три или четыре вершины в массиве, прежде чем он станет слишком громоздким, и лучше просто сортировать.

Answer 5

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

http://www.codeido.com/2010/10/bubblesort-written-in-c-with-example-step-by-step/

Надеется, что это помогает !!!

Answer 6

Проблема с вашим кодом - это логическая проблема (о чем говорит большинство кодировок). Если наибольшее число является первым, тогда оно становится вторым по величине ошибочным ... почему?

Хорошо, посмотрите на свою логику для принятия решения о втором по величине номере. Сначала вы установите его равным первому элементу массива, а затем пройдете через массив и измените индекс, если элемент больше текущего второго по величине числа (это никогда не будет истинным, потому что мы уже установили его как наибольшее число!).

Для решения этого вопроса вы можете воспользоваться специальным случаем: проверьте, было ли наибольшее число первым, и если да, то установите его во второй элемент (а затем в специальном случае проблема с кем-то, кто просит найти самые высокие два элемента в одном элемент массива, не прочитывая конца массива.)

Я думаю, что метод, заданный в ответе chqrlie, сделать это за один проход лучше. И логично: напишите программу, чтобы найти наибольшее число. Второе по величине число, ну это именно тот, который был ранее самым большим!

Answer 7

// Я думаю, его просто как

#include<stdio.h> 
int main() 

{ 
int a1[100],a2[100],i,t,l1,l2,n; 
printf("Enter the number of elements:\n"); 
scanf("%d",&n); 
printf("Enter the elements:\n"); 
for(i=0;i<n;i++) 
{ 
    scanf("%d",&a1[i]); 
} 
l1=a1[0]; 
for(i=0;i<n;i++) 
{ 
    if(a1[i]>=l1) 
    { 
     l1=a1[i]; 
     t=i; 
    } 
} 
for(i=0;i<(n-1);i++) 
{ 
    if(i==t) 
    { 
     continue; 
    } 
    else 
    { 
     a2[i]=a1[i]; 
    } 
} 
l2=a2[0]; 
for(i=1;i<(n-1);i++) 
{ 
    if(a2[i]>=l2 && a2[i]<l1) 
    { 
     l2=a2[i]; 
    } 
} 
printf("Second highest number is %d",l2); 
return 0; 
} 

Answer 8

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

См этот код.

#include <stdio.h> 

int main() 

{ 
int a[10], n; 

int i; 

printf("enter number of elements you want in array"); 

scanf("%d", &n); 

printf("enter elements"); 

for (i = 0; i < n; i++) { 
    scanf("%d", &a[i]); 
} 

int largest1 = a[0],largest2 = a[0]; 

for (i = 0; i < n; i++) 
{ 
    if (a[i] > largest1) 
    { 
     largest2=largest1; 
     largest1 = a[i]; 
    } 
} 

printf("First and second largest number is %d and %d ", largest1, largest2); 
} 

Надежда этот код будет работать для вас.

Наслаждайтесь Coding :)

Answer 9

#include<stdio.h> 

int main() 
{ 
    int a[10]; 
    int i,b,c; 

    printf("Enter ten values : \n"); 
    for(i=0; i<10; i++) 
    { 
     scanf("%d",&a[i]); 
    } 

    b=a[0]; 

    for(i=0; i<10; i++) 
    { 
     if(a[i]>b) 
     { 
      b=a[i]; 
     } 

     else 
     { 
      b=b; 
     } 
    } 

    if(b==a[1]) 
    { 
     c=a[2]; 
    } 
    else 
    { 
     c=a[1]; 
    } 

    for(i=0; i<10; i++) 
    { 
     if(a[i]>c && a[i]!=b) 
     { 
      c=a[i]; 
     } 

     else if (b>c) 
     { 
      c=c; 
     } 

    } 




    printf("Largest number is %d\nSecond largest number is %d",b,c); 

} 

Answer 10

Найти второе по величине число без использования Строка:

int array[];//Input array 
int firstLargest, secondLargest; 
int minNumber = -1;//whatever smallest you want to add here 
/*There should be more than two elements*/ 
if (array_size < 2) 
{ 
    printf("Array is too small"); 
    return; 
} 

firstLargest = secondLargest = minNumber; 
for (index = 0; index < array_size ; ++index) 
{ 
    //Largest number check 
    if (array[index] > first) 
    { 
     secondLargest = firstLargest; 
     firstLargest = array[index]; 
    } 

    //It may not larger than first but can be larger than second number 
    else if (array[index] > secondLargest && array[index] != firstLargest) 
{ 
     secondLargest = array[index]; 
} 

//Finally you got your answer 
if (secondLargest == minNumber) 
{ 
    printf("No Second largest number"); 
} 
else 
{ 
    printf("Second Largest Number is %d", secondLargest); 
} 

Answer 11

Вот ответ с одним циклом.

int array[] = { 10, 15, 13, 20, 21, 8, 6, 7, 9, 21, 23 }; 
const int count = sizeof(a)/sizeof(a[0]); 
int lastMaxNumber = 0; 
int maxNumber = 0; 

for (int i = 0; i < count; i++) { 

    // Current number 
    int num = array[i]; 

    // Find the minimum and maximum from (num, max) 
    int maxValue = (num > maxNumber) ? num : maxNumber; 
    int minValue = (num < maxNumber) ? num : maxNumber; 

    // If minValue is greater than lastMaxNumber, update the lastMaxNumber 
    if minValue > lastMaxNumber { 
     lastMaxNumber = minValue; 
    } 

    // Updating maxNumber 
    maxNumber = maxValue; 
} 

printf("%d", lastMaxNumber);