web-dev-qa-db-fra.com

Comment calculer la médiane d'un tableau?

J'essaie de calculer le total, la moyenne et la médiane d'un tableau peuplé par les entrées reçues par un champ de texte. J'ai réussi à calculer le total et la moyenne, je ne peux tout simplement pas faire en sorte que la médiane fonctionne. Je pense que le tableau doit être trié avant de pouvoir le faire, mais je ne sais pas comment faire. Est-ce le problème ou y en a-t-il un autre que je n'ai pas trouvé? Voici mon code:

import Java.applet.Applet;
import Java.awt.Graphics;
import Java.awt.*;
import Java.awt.event.*;

public class whileloopq extends Applet implements ActionListener
{
    Label label;
    TextField input;
    int num;
    int index;
    int[] numArray = new int[20];
    int sum;
    int total;
    double avg;
    int median;



    public void init ()
    {
        label = new Label("Enter numbers");
        input = new TextField(5);
        add(label);
        add(input);
        input.addActionListener(this);
        index = 0;
    }

    public void actionPerformed (ActionEvent ev)
    {
        int num = Integer.parseInt(input.getText());
        numArray[index] = num;
        index++;
        if (index == 20)
        input.setEnabled(false);
            input.setText("");
        sum = 0;
        for (int i = 0; i < numArray.length; i++)
        {
            sum += numArray[i];
        }
        total = sum;
        avg = total / index;

        median = numArray[numArray.length/2];



        repaint();

    }



    public void Paint (Graphics graf)
    {



        graf.drawString("Total   = " + Integer.toString(total), 25, 85);
        graf.drawString("Average = " + Double.toString(avg), 25, 100);
        graf.drawString("Median = " + Integer.toString(median), 25, 115);



    }
}
javaarrays
31
Will

La classe Arrays en Java a une fonction de tri statique, que vous pouvez appeler avec Arrays.sort(numArray).

Arrays.sort(numArray);
double median;
if (numArray.length % 2 == 0)
    median = ((double)numArray[numArray.length/2] + (double)numArray[numArray.length/2 - 1])/2;
else
    median = (double) numArray[numArray.length/2];
54
lynnyi

Si vous voulez utiliser une bibliothèque externe, voici Bibliothèque mathématique commune Apache en utilisant, vous pouvez calculer le Médian .
Pour plus de méthodes et d’utilisations, regardez la Documentation API

import org.Apache.commons.math3.*;
.....
......
........
//calculate median
public double getMedian(double[] values){
 Median median = new Median();
 double medianValue = median.evaluate(values);
 return medianValue;
}
.......

Mettre à jour 

_ {Calculer dans le programme} _ 

En règle générale, la médiane est calculée à l'aide des deux formules suivantes données ici

Si n est impair, médiane (M) = valeur de ((n + 1)/2) terme.
Si n est pair, alors la médiane (M) = la valeur de [((n)/2) terme de poste + ((n)/2 + 1) terme de poste]/2

Dans votre programme, vous avez numArray, vous devez d’abord trier un tableau à l’aide de Arrays # sort 

Arrays.sort(numArray);
int middle = numArray.length/2;
int medianValue = 0; //declare variable 
if (numArray.length%2 == 1) 
    medianValue = numArray[middle];
else
   medianValue = (numArray[middle-1] + numArray[middle]) / 2;
6
Aniket Kulkarni

Essayez de trier le tableau en premier. Ensuite, une fois le tableau trié, si le tableau contient une quantité paire d'éléments, la moyenne des deux médianes est la médiane. S'il comporte un nombre impair, l'élément médian est la médiane.

2
mjgpy3

Je regardais les mêmes problèmes statistiques. L'approche que vous pensez est bonne et cela fonctionnera. (La réponse au tri a été donnée) 

Mais si les performances des algorithmes vous intéressent, je pense qu'il existe plusieurs algorithmes plus performants que le simple tri du tableau, un ( QuickSelect ) est indiqué par la réponse de @ bruce-feist et est très bien expliqué.

[Implémentation Java: https://discuss.leetcode.com/topic/14611/Java-quick-select ]

Mais il existe une variante de cet algorithme nommé médiane des médianes , vous pouvez trouver une bonne explication sur ce lien: http://austinrochford.com/posts/2013-10-28-median- of-medians.html

Implémentation Java de ceci: - https://stackoverflow.com/a/27719796/957979

1
cesaregb

Hier, j'ai rencontré un problème similaire… J'ai écrit une méthode avec des génériques Java afin de calculer la valeur médiane de chaque collection de Numbers; vous pouvez appliquer ma méthode aux collections de doublons, entiers, flottants et renvoie un double. Veuillez considérer que ma méthode crée une autre collection afin de ne pas altérer celle d'origine . Je fournis également un test, amusez-vous. ;-)

public static <T extends Number & Comparable<T>> double median(Collection<T> numbers){
    if(numbers.isEmpty()){
        throw new IllegalArgumentException("Cannot compute median on empty collection of numbers");
    }
    List<T> numbersList = new ArrayList<>(numbers);
    Collections.sort(numbersList);
    int middle = numbersList.size()/2;
    if(numbersList.size() % 2 == 0){
        return 0.5 * (numbersList.get(middle).doubleValue() + numbersList.get(middle-1).doubleValue());
    } else {
        return numbersList.get(middle).doubleValue();
    }

}

Extrait de code de test JUnit:

/**
 * Test of median method, of class Utils.
 */
@Test
public void testMedian() {
    System.out.println("median");
    Double expResult = 3.0;
    Double result = Utils.median(Arrays.asList(3.0,2.0,1.0,9.0,13.0));
    assertEquals(expResult, result);
    expResult = 3.5;
    result = Utils.median(Arrays.asList(3.0,2.0,1.0,9.0,4.0,13.0));
    assertEquals(expResult, result);
}

Exemple d'utilisation (considérez que le nom de la classe est Utils):

List<Integer> intValues = ... //omitted init
Set<Float> floatValues = ... //omitted init
.....
double intListMedian = Utils.median(intValues);
double floatSetMedian = Utils.median(floatValues);

Note: ma méthode fonctionne sur les collections, vous pouvez convertir des tableaux de nombres en liste de nombres comme indiqué ici

1
Fabiano Tarlao

Vous pouvez trouver une bonne explication sur https://www.youtube.com/watch?time_continue=23&v=VmogG01IjYc

L'idée d'utiliser 2 tas, à savoir un tas maximum et un tas moyen.

class Heap {
private Queue<Integer> low = new PriorityQueue<>(Comparator.reverseOrder());
private Queue<Integer> high = new PriorityQueue<>();

public void add(int number) {
    Queue<Integer> target = low.size() <= high.size() ? low : high;
    target.add(number);
    balance();
}

private void balance() {
    while(!low.isEmpty() && !high.isEmpty() && low.peek() > high.peek()) {
        Integer lowHead= low.poll();
        Integer highHead = high.poll();
        low.add(highHead);
        high.add(lowHead);
    }
}

public double median() {
    if(low.isEmpty() && high.isEmpty()) {
        throw new IllegalStateException("Heap is empty");
    } else {
        return low.size() == high.size() ? (low.peek() + high.peek()) / 2.0 : low.peek();
    }
}

}

1
Abhijit Gaikwad

Utilisez Arrays.sort puis prenez l'élément central (dans le cas où le nombre n d'éléments dans le tableau est impair) ou prenez la moyenne des deux éléments intermédiaires (dans le cas où n est pair).

  public static long median(long[] l)
  {
    Arrays.sort(l);
    int middle = l.length / 2;
    if (l.length % 2 == 0)
    {
      long left = l[middle - 1];
      long right = l[middle];
      return (left + right) / 2;
    }
    else
    {
      return l[middle];
    }
  }

Voici quelques exemples:

  @Test
  public void evenTest()
  {
    long[] l = {
        5, 6, 1, 3, 2
    };
    Assert.assertEquals((3 + 4) / 2, median(l));
  }

  @Test
  public oddTest()
  {
    long[] l = {
        5, 1, 3, 2, 4
    };
    Assert.assertEquals(3, median(l));
  }

Et si votre saisie est une Collection, vous pouvez utiliser Google Guava pour faire quelque chose comme ceci:

public static long median(Collection<Long> numbers)
{
  return median(Longs.toArray(numbers)); // requires import com.google.common.primitives.Longs;
}
1
Hbf
public int[] data={31, 29, 47, 48, 23, 30, 21
        , 40, 23, 39, 47, 47, 42, 44, 23, 26, 44, 32, 20, 40};

public double median()
    {
        Arrays.sort(this.data);
        double result=0;
        int size=this.data.length;


        if(size%2==1)
        {
            result=data[((size-1)/2)+1];
            System.out.println(" uneven size : "+result);
        }
        else
        { 
            int middle_pair_first_index =(size-1)/2;
            result=(data[middle_pair_first_index+1]+data[middle_pair_first_index])/2;
            System.out.println(" Even size : "+result);
        }

        return result;
    }
0
N_E

Découvrez les méthodes Arrays.sort:

http://docs.Oracle.com/javase/6/docs/api/Java/util/Arrays.html

Vous devriez aussi vraiment abstraite trouver la médiane dans sa propre méthode et renvoyer la valeur à la méthode qui appelle. Cela facilitera grandement le test de votre code.

0
aglassman
Arrays.sort(numArray);
return (numArray[size/2] + numArray[(size-1)/2]) / 2;
0
i_use_the_internet