Trouver le deuxième plus petit entier dans la gamme

Nous sont nécessaires dans notre mission pour trouver le deuxième plus petit entier dans un tableau de manière récursive. Cependant, pour des raisons de compréhension du sujet en plus, je veux le faire de manière itérative en premier (avec l'aide de ce site web) et de manière récursive sur mon propre.

Malheureusement, le faire de manière itérative est assez déroutant. Je comprends que la solution est simple, mais je ne peut pas envelopper la tête autour de lui.

Ci-dessous mon code pour l'instant:

public static void main(String[] args) 
{
    int[] elements  = {0 , 2 , 10 , 3, -3 }; 
    int smallest = 0; 
    int secondSmallest = 0; 

    for (int i = 0; i < elements.length; i++)
    {
        for (int j = 0; j < elements.length; j++)
        {
            if (elements[i] < smallest)
            {
                smallest = elements[i];

                if (elements[j] < secondSmallest)
                {
                    secondSmallest = elements[j];
                }
            }
        }

    }

    System.out.println("The smallest element is: " + smallest + "\n"+  "The second smallest element is: " + secondSmallest);
}

Cela fonctionne pour quelques numéros, mais pas tous. Les numéros de changement, parce que l'intérieur si la condition n'est pas aussi efficace que l'externe si la condition.

Tableau des réarrangements sont interdits.

Vous ne devriez pas initialiser smallest avec 0 si le tableau ne peut contenir que des nombres plus grands que. Essayez int smallest = Integer.MAX_VALUE pour commencer. En va de même pour secondSmallest.
Sinon, elements[0] est une bonne initialisation pour smallest et secondSmallest, puisque c'est un candidat pour le plus petit dans le tableau.

OriginalL'auteur Majd Khoury | 2015-05-24

arrays java

Essayer celui-ci. Deuxième condition est utilisé pour capturer un événement lorsque le nombre le plus petit est le premier

    int[] elements = { -5, -4, 0, 2, 10, 3, -3};
    int smallest = Integer.MAX_VALUE;
    int secondSmallest = Integer.MAX_VALUE;
    for (int i = 0; i < elements.length; i++) {
        if(elements[i]==smallest){
          secondSmallest=smallest;
        } else if (elements[i] < smallest) {
            secondSmallest = smallest;
            smallest = elements[i];
        } else if (elements[i] < secondSmallest) {
            secondSmallest = elements[i];
        }

    }

UPD par @Axel

    int[] elements = { -5, -4, 0, 2, 10, 3, -3};
    int smallest = Integer.MAX_VALUE;
    int secondSmallest = Integer.MAX_VALUE;
    for (int i = 0; i < elements.length; i++) {
    if (elements[i] < smallest) {
            secondSmallest = smallest;
            smallest = elements[i];
        } else if (elements[i] < secondSmallest) {
            secondSmallest = elements[i];
        }

    }

Quel est le résultat escompté lors de deux nombres ont la plus petite valeur? Par exemple, lorsque int[] elements = { -5, -4, 0, 2, 10, 3, -5}? Devrait-il être -5 ou -4? Celui-ci vous donne -4.
Ne suffirait-il pas d'utiliser => au lieu de > dans la deuxième if? (Oh, désolé, c'est maintenant la troisième.)
Oui, il sera également correct
Afin de mieux de tout simplement supprimer la première ifet l'ensemble de la && elements[i] > smallest pour le rendre plus lisible.
Pour l'entrée int[] éléments = { -5, -4, 0, 2, 10, 3, -5} nous devrions obtenir -4 en tant que deuxième plus petit nombre. Dans ce cas, else if (elements[i] < secondSmallest && elements[i] != la plus petite) { secondSmallest = elements[i]; }

OriginalL'auteur nesteant

    int[] arr = { 4, 1, 2, 0, 6, 1, 2, 0 };

    int smallest = Integer.MAX_VALUE;
    int smaller = Integer.MAX_VALUE;
    int i = 0;

    if (arr.length > 2) {
        for (i = 0; i < arr.length; i++) {

            if (arr[i] < smallest) {
                smaller = smallest;
                smallest = arr[i];
            } else if (arr[i] < smaller && arr[i] > smallest) {
                smaller = arr[i];
            }
        }

        System.out.println("Smallest number is " + smallest);
        System.out.println("Smaller number is " + smaller);

    } else {
        System.out.println("Invalid array !");
    }
}

que si le tableau n'a qu'sigle de la valeur? int [] arr = {0}, alors il échoue, renvoie Max_VALUE

OriginalL'auteur Feeroz Alam

2

Simplement, vous pouvez le faire
```
int[] arr = new int[]{34, 45, 21, 12, 54, 67, 15};
Arrays.sort(arr);
System.out.println(arr[1]);
```
C'est la plus courte et la meilleure solution, à mon avis, mais il n'est pas récursive, comme décrit par l'auteur de la question 😉

OriginalL'auteur Ankit

Vous pouvez le faire en O(n) fois. Ci-dessous est le code python

def second_small(A):
    if len(A)<2:
        print 'Invalid Array...'
        return
    small = A[0]
    second_small = [1]
    if small >  A[1]:
        second_small,small = A[0],A[1]

    for i in range(2,len(A)):
        if A[i] < second_small and A[i]!=small:
            if A[i] < small:
                second_small = small
                small = A[i]
            else:
                second_small = A[i]
    print small, second_small
A = [12, 13, 1, 10, 34, 1]
second_small(A)

OriginalL'auteur Jay Parikh

public static int findSecondSmallest(int[] elements) {
    if (elements == null || elements.length < 2) {
        throw new IllegalArgumentException();
    } 
    int smallest = elements[0]; 
    int secondSmallest = elements[0]; 
    for (int i = 1; i < elements.length; i++) {
        if (elements[i] < smallest) {
            secondSmallest = smallest;
            smallest = elements[i];
        } 
        else if (elements[i] < secondSmallest) {
            secondSmallest = elements[i];
        }
    }
    return secondSmallest;
}

Ce code n'est pas d'aller travailler si il y a un élément qui est >= smallest, cependant < secondSmallest. Dans ce cas, `secondSmallest doit être remplacé.
Aussi, si la première valeur dans les éléments est plus petit, il ne secondSmallest

OriginalL'auteur Adam Stelmaszczyk

     public static void main(String[] args) 
{
    int[] elements  = { -4 , 2 , 10 , -2, -3 }; 
    int smallest = Integer.MAX_VALUE; 
    int secondSmallest = Integer.MAX_VALUE; 

    for (int i = 0; i < elements.length; i++)
    {
        if (smallest>elements[i])
            smallest=elements[i];

    }

    for (int i = 0; i < elements.length; i++)
    {
        if (secondSmallest>elements[i] && elements[i]>smallest)
            secondSmallest=elements[i];

    }

    System.out.println("The smallest element is: " + smallest + "\n"+  "The second smallest element is: " + secondSmallest);
}

cela permettra de travailler sur des tableaux avec des doublons , comme int[] éléments = { -4 , -4 , -4 , -4, -3 };

OriginalL'auteur Amit.rk3

public static void main(String[] args) {

    Scanner in = new Scanner(System.in);
    System.out.println("Enter array size = ");
    int size=in.nextInt();
    int[] n = new int[size];
    System.out.println("Enter "+ size +" values ");

    for(int i=0;i<n.length;i++)
        n[i] = in.nextInt();
    int small=n[0],ssmall=n[0];

    //finding small and second small
    for(int i=0;i<n.length;i++){
        if(small>n[i]){
            ssmall=small;
            small=n[i];
            }else if(ssmall>n[i])
                ssmall=n[i];
    }

    //finding second small if first element itself small
    if(small==n[0]){
        ssmall=n[1];
        for(int i=1;i<n.length;i++){
            if(ssmall>n[i]){
                ssmall=n[i];
                }
        }
    }

    System.out.println("Small "+ small+" sSmall "+ ssmall);

    in.close();
}

OriginalL'auteur girish

public static void main(String[] args)  {
    int arr[] = {6,1,37,-4,12,46,5,64,21,2,-4,-3};
    int lowest =arr[0];
    int sec_lowest =arr[0];
    for(int n : arr){
        if (lowest >  n)
        {
            sec_lowest = lowest;
            lowest = n;

        }
        else if (sec_lowest > n && lowest != n)
            sec_lowest = n;
    }

    System.out.println(lowest+"   "+sec_lowest);

    }

à Partir de l'examen de la file d'attente: puis-je vous demander à s'il vous plaît ajouter un peu plus le contexte autour de votre réponse. Code-seulement les réponses sont difficiles à comprendre. Il aidera le demandeur et les futurs lecteurs à la fois si vous pouvez ajouter plus d'informations dans votre post.

OriginalL'auteur Rounak

Trouver le deuxième plus petit entier dans la gamme

public class SecondSmallestNumberInArray 
{
public static void main(String[] args) 
{
int arr[] = { 99, 76, 47, 85, 929, 52, 48, 36, 66, 81, 9 };
int smallest = arr[0];
int secondSmallest = arr[0];
System.out.println("The given array is:");
boolean find = false;
boolean flag = true;
for (int i = 0; i < arr.length; i++) 
{
System.out.print(arr[i] + "  ");
}
System.out.println("");
while (flag) 
{
for (int i = 0; i < arr.length; i++) 
{
if (arr[i] < smallest) 
{   
find = true;
secondSmallest = smallest;
smallest = arr[i];
} else if (arr[i] < secondSmallest) {   
find = true;
secondSmallest = arr[i];
}
}
if (find) {
System.out.println("\nSecond Smallest number is Array : ->  " + secondSmallest);
flag = false;
} else {
smallest = arr[1];
secondSmallest = arr[1];
}
}
}
}
**Output is**
D:\Java>java SecondSmallestNumberInArray
The given array is:
99  76  47  85  929  52  48  36  66  81  9
Second Smallest number is Array : ->  36
D:\Java>

expliquer s'il vous plaît
Muhammad Muazzam Sec d'Exécuter ce code très simple pas Besoin de vérifier si le else

OriginalL'auteur Keshav Gera

Essayer celui-ci.

    public static void main(String args[]){
int[] array = new int[]{10, 30, 15, 8, 20, 4};
int min, secondMin;
if (array[0] > array[1]){
min = array[1];
secondMin = array[0];
}
else{
min = array[0];
secondMin = array[1];
}
for (int i=2; i<array.length; i++){
if (array[i] < min){
secondMin = min;
min = array[i];
}
else if ((array[i] > min) && (array[i] < secondMin)){
secondMin = array[i];
}
}
System.out.println(secondMin);
}

OriginalL'auteur Prabhashani

0

J'ai utilisé Tri fonction en javascript
```
function sumTwoSmallestNumbers(numbers){  
numbers = numbers.sort(function(a, b){return a - b; });
return numbers[0] + numbers[1];
};
```
en fournissant un compareFunction pour la fonctionnalité de tri des éléments d'un tableau sont triés en fonction de la valeur de retour de la fonction.

OriginalL'auteur Jayampathy Wijesena

public static int getSecondSmallest(int[] arr){
int smallest = Integer.MAX_VALUE;
int secondSmallest = Integer.MAX_VALUE;
for(int i=0;i<arr.length;i++){
if(smallest > arr[i]){
secondSmallest = smallest;
smallest = arr[i];
}else if (secondSmallest > arr[i] && arr[i] != smallest){
secondSmallest = arr[i];
}
System.out.println(i+" "+smallest+" "+secondSmallest);
}
return secondSmallest;
}

Juste donné un essai avec quelques-uns des cas de test et ça a fonctionné. Veuillez vérifier s'il est correct!

OriginalL'auteur Nilesh

Comment à ce sujet?

   int[] result = Arrays.asList(-3, 4,-1,-2).stream()
.reduce(new int[]{Integer.MIN_VALUE, Integer.MIN_VALUE},
(maxValues, x) -> {
if (x > maxValues[0]) {
maxValues[1] = maxValues[0]; //max becomes second max
maxValues[0] = x;
}
else if (x > maxValues[1]) maxValues[1] = x;
return maxValues;
}
, (x, y) -> x);

OriginalL'auteur Satyendra Kumar

Essayez ceci ...
Première condition vérifie si les deux valeurs sont inférieures à la valeur dans le tableau.
Seconde condition si la valeur est inférieure à petit que smallest=element[i]
d'autre secondSmallest=elements[i]..

public static void main(String[] args) 
{
int[] elements  = {0 , 2 , 10 , 3, -3 }; 
int smallest = elements[0];
int secondSmallest = 0; 
for (int i = 0; i < elements.Length; i++)
{
if (elements[i]<smallest || elements[i]<secondSmallest )
{
if (elements[i] < smallest )
{
secondSmallest  = smallest ;
smallest = elements[i];
}
else
{
secondSmallest = elements[i];
}
}
}
System.out.println("The smallest element is: " + smallest + "\n"+  "The second smallest element is: " + secondSmallest);
}

OriginalL'auteur akmal saeed

class A{
public static void main (String args[]){
int array[]= { -5, -4, 0, 2, 10, 3, -3};
int min;
int second_min;
if(array[0]<array[1]){
min=array[0];
second_min=array[1];
}else{
min=array[1];
second_min=array[0];
}
for(int i=2;i<array.length;i++){
if(second_min > array[i] && min > array[i]){
second_min=min;
min=array[i];                              
}else  if(second_min > array[i] && min < array[i]){
min=min;
second_min=array[i];
}
}
System.out.println(min);
System.out.println(second_min);
}
}

S'il vous plaît ajouter quelques explications.

OriginalL'auteur Kushan Kavinda Edirisooriya

Trouver le deuxième élément minimum d'un tableau en Python, court et simple

def second_minimum(arr):
second = arr[1]
first = arr[0]
for n in arr:
if n < first:
first = n
if n > first and n < second  :
second = n
return second
print(second_minimum([-2, 4, 5, -1, 2, 3, 0, -4, 1, 99, -6, -5, -19]))

OriginalL'auteur Muhammad Usman

Essayez ceci, le programme donne la solution pour les deux plus faibles de la valeur et la deuxième valeur la plus basse du tableau.

Initialiser min et second_min avec le premier élément du tableau.Trouver la valeur min et la comparer avec second_min valeur . Si c' (second_min) est plus grand que l'élément courant du tableau et la valeur min puis le second_min valeur de le remplacer avec de l'élément courant du tableau.

En cas arr[]={2,6,12,15,11,0,3} comme ceci , temp variable utilisée pour stocker précédente second_min valeur.

public class Main
{
public static void main(String[] args) {
//test cases.
int arr[]={6,12,1,11,0};
//int arr[]={0,2,10,3,-3}; 
//int arr[]={0,0,10,3,-3}; 
//int arr[]={0,2 ,10, 3,-3}; 
//int arr[]={12,13,1,10,34,1};
//int arr[]={2,6,12,15,11,0,3};
//int arr[]={2,6,12,15,1,0,3};
//int arr[]={2,6,12,15};
//int arr[]={0,1};
//int arr[]={6,16};
//int arr[]={12};
//int arr[]={6,6,6,6,6,6};
int position_min=0;
int min=arr[0];int second_min=arr[0]; int temp=arr[0];
if(arr.length==1)
{
System.out.println("Lowest value is "+arr[0]+"\n Array length should be greater than 1. ");
}
else if(arr.length==2)
{
if(arr[0]>arr[1])
{
min=arr[1];
second_min=arr[0];
position_min=1;
}
else
{
min=arr[0];
second_min=arr[1];
position_min=0;
}
System.out.println("Lowest value is "+min+"\nSecond lowest value is "+second_min);
}
else
{
for( int i=1;i<arr.length;i++)
{
if(min>arr[i])
{
min=arr[i];
position_min=i;
}
}
System.out.println("Lowest value is "+min);
for(int i=1;i<arr.length;i++)
{
if(position_min==i)
{
}
else
{
if(second_min > min & second_min>arr[i])
{
temp=second_min;
second_min=arr[i];
}
else if(second_min == min )
{
second_min=arr[i];
}
}
}
if(second_min==min )
{
second_min=temp;
}
//just for message if in case all elements are same in array.
if(temp==min && second_min==min)
{
System.out.println("There is no Second lowest element in array.");
}
else{
System.out.println("\nSecond lowest value is "+second_min);
}
}
}
}

Une seule solution n'est pas recommandée.

OriginalL'auteur Prajakta Kale

Vous devez vous connecter pour publier un commentaire.