Java 求数组的中值？

我想知道是否有可能找到数组的中值？例如，假设我有一个大小为9的数组。是否可以找到此阵列的中间插槽？

vector v；
vector<int> v;
size_t len = v.size;
nth_element( v.begin(), v.begin()+len/2,v.end() );

int median = v[len/2];

尺寸=v.尺寸；
第n个元素（v.begin（），v.begin（）+len/2，v.end（））；
整数中值=v[len/2]；

在java中：

int middleSlot = youArray.length/2;
yourArray[middleSlot];

或

排成一行

这是可能的，因为在java中，数组的大小是固定的

注：

3/2==1

---

资源：

---

在C++中，可以使用<代码> STD:：NthyEngult；请参见。
假设数组x已排序且长度为n：
如果n为奇数，则中值为x[（n-1）/2]。


---

如果n比中位数为偶数，则为（x[n/2]+x[（n/2）-1]）/2。
上述Java答案仅在有奇数的情况下有效，以下是我得到的答案：

if (yourArray.length % 2 == 0){

     //this is for if your array has an even ammount of numbers
     double middleNumOne = yourArray[yourArray.length / 2 - 0.5]
     double middleNumTwo = yourArray[yourArray.length / 2 + 0.5]
     double median = (middleNumOne + middleNumTwo) / 2;
     System.out.print(median);

}else{

     //this is for if your array has an odd ammount of numbers
     System.out.print(yourArray[yourArray.length/2];);
}

---

请注意，这是一个概念证明，而且是即时的。如果你认为你可以让它更紧凑或者更不密集，那就直接做吧。请不要批评它。
如果您想使用这里正在使用的任何外部库，您可以计算。
有关更多方法和用法，请参阅
• 更多关于评估方法的信息
在程序中计算
通常，中位数使用以下两个公式计算
如果n为奇数，则中值（M）=（n+1）/2）第项项的值。
如果n为偶数，则中值（M）=第[（（n）/2）个项目项的值+（（n）/2+1）个项目项]/2
这非常简单，因为您有9个元素（奇数）。
查找数组的中间元素。
在程序中可以声明数组

//as you mentioned in question, you have array with 9 elements
int[] numArray = new int[9]; 

然后，您需要使用

---

还有另一种选择——一般来说，这里的建议要么建议对数组进行排序，然后从这样的数组中取中值，要么依赖（外部）库解决方案。平均而言，目前最快的排序算法是线性算法，但在中值计算方面，它可能比线性算法做得更好
从未排序的数组中计算中值的最快算法是，平均而言，它发现中值在时间上与O（N）成比例。该算法以数组为参数，加上int值

k

（顺序统计量，即数组中第k个最小元素）。在本例中，

k

的值仅为N/2，其中N是数组长度
实现有点棘手，但下面是一个示例，它依赖于

Compariable

接口和

Collections.shuffle（）

，没有任何外部依赖项

public final class QuickSelectExample {

    public static <T extends Comparable<? super T>> T select(T[] a, int k) {
        if (k < 1) throw new IllegalStateException("Invalid k - must be in [1, inputLength].");
        if (k > a.length) throw new IllegalStateException("K-th element exceeds array length.");
        Collections.shuffle(Arrays.asList(a));
        return find(a, 0, a.length - 1, k - 1);
    }

    private static <T extends Comparable<? super T>> T find(T[] a, int lo, int hi, int k) {
        int mid = partition(a, lo, hi);

        if (k == mid) return a[k];
        else if (k < mid) return find(a, lo, mid - 1, k); // search left subarray
        else if (k > mid) return find(a, mid + 1, hi, k); // search right subarray
        else throw new IllegalStateException("Not found");
    }

    private static <T extends Comparable<? super T>> int partition(T[] a, int lo, int hi) {
        T pivot = a[lo];
        int i = lo + 1;
        int j = hi;

        while (true) { // phase 1
            while (i <= hi && (less(a[i], pivot) || eq(a[i], pivot))) // is a[i] >= pivot?
                i++;

            while (j >= i && !less(a[j], pivot))  // is a[j] <= pivot?
                j--;

            if (i >= j) break;
            exch(a, i, j);
        }
        exch(a, lo, j); // phase 2
        return j;
    }

    private static <T extends Comparable<? super T>> boolean less(T x, T y) {
        return x.compareTo(y) < 0;
    }

    private static <T extends Comparable<? super T>> boolean eq(T x, T y) {
        return x.compareTo(y) == 0;
    }
}

---

像专业人士一样在一行中完成：

return (arr[size/2] + arr[(size-1)/2]) / 2;

---

如果您希望使用

double

等，则转换为

double

。
对于Java，除以

2.0

就足以将

int

转换为

double

：

 return n%2 == 0 ? (all[n/2] + all[n/2-1])/2.0 : all[(n-1)/2];

---

第一个条件检查值是否为偶数。
如果您对数组处理有任何了解，那么这应该很简单。请注意，除非对数组进行排序，否则中间的插槽不是中间位置。这是作业吗？java还是C++？挑一个。“中值”和“中间位置”不是一回事，选择一个。你的答案是错误的。例如，考虑一个具有两个元素的数组：3和75。你的答案给出的中位数是75。{3，75}的中位数是多少？梅森，你似乎把中位数和平均值混淆了。@Gal，根据中位数的定义，如果值的数目是偶数，中位数就是两个中间值的平均值。所以曼森是对的。这至少需要o（nlogn）时间。

public final class QuickSelectExample {

    public static <T extends Comparable<? super T>> T select(T[] a, int k) {
        if (k < 1) throw new IllegalStateException("Invalid k - must be in [1, inputLength].");
        if (k > a.length) throw new IllegalStateException("K-th element exceeds array length.");
        Collections.shuffle(Arrays.asList(a));
        return find(a, 0, a.length - 1, k - 1);
    }

    private static <T extends Comparable<? super T>> T find(T[] a, int lo, int hi, int k) {
        int mid = partition(a, lo, hi);

        if (k == mid) return a[k];
        else if (k < mid) return find(a, lo, mid - 1, k); // search left subarray
        else if (k > mid) return find(a, mid + 1, hi, k); // search right subarray
        else throw new IllegalStateException("Not found");
    }

    private static <T extends Comparable<? super T>> int partition(T[] a, int lo, int hi) {
        T pivot = a[lo];
        int i = lo + 1;
        int j = hi;

        while (true) { // phase 1
            while (i <= hi && (less(a[i], pivot) || eq(a[i], pivot))) // is a[i] >= pivot?
                i++;

            while (j >= i && !less(a[j], pivot))  // is a[j] <= pivot?
                j--;

            if (i >= j) break;
            exch(a, i, j);
        }
        exch(a, lo, j); // phase 2
        return j;
    }

    private static <T extends Comparable<? super T>> boolean less(T x, T y) {
        return x.compareTo(y) < 0;
    }

    private static <T extends Comparable<? super T>> boolean eq(T x, T y) {
        return x.compareTo(y) == 0;
    }
}

            "                  Input Array                    |                                                           Actual Output [format: (index k -> array element)]                                                           ", //
            "                                                 |                                                                                                                                                                        ", //
            "       [S, O, R, T, E, X, A, M, P, L, E]         |                            [(1 -> A), (2 -> E), (3 -> E), (4 -> L), (5 -> M), (6 -> O), (7 -> P), (8 -> R), (9 -> S), (10 -> T), (11 -> X)]                            ", //
            "   [P, A, B, X, W, P, P, V, P, D, P, C, Y, Z]    |            [(1 -> A), (2 -> B), (3 -> C), (4 -> D), (5 -> P), (6 -> P), (7 -> P), (8 -> P), (9 -> P), (10 -> V), (11 -> W), (12 -> X), (13 -> Y), (14 -> Z)]           " //

return (arr[size/2] + arr[(size-1)/2]) / 2;

 return n%2 == 0 ? (all[n/2] + all[n/2-1])/2.0 : all[(n-1)/2];