java实现：数组矩阵a获取相邻的数，取中间值填入到数组b

如下：

5 85 4 2 68

78 82 75 41 14
79 47 38 1 47
1 2 14 65 13

 

96 87 32 14 21

 

按下列要求编程：

1.分配两个5X5的数组a和数组b，数组a如上图赋值。

2.对于数组a中的每一个元素a[i][j]，从他相邻元素中选取中间值填入到b[i][j]

3.打印数组b

例如：

a[0][2]的相邻元素为85，82，75，41，2 。升序排序为2，41，75，82，85 取中间值75，将75填入b[0][2]位置；

a[2][1]的相邻元素为78,75,79,38,1,2,14。升序排序为1，2，14，28，75，78，79，82.中间值为75，填入b[2][1]位置；

最终数组b应该为：

82 75 75 41 14
79 75 41 38 41
47 75 47 41 14
79 47 38 21 21

2 14 14 21 14

我的思路是：

1，循环数组a;

2,“十”字边界探知：对于当前循环的a[i][j],先查看其 正上方(up),正下方(down),正左方(left)，正右方(right)，是否存在，存在就加入到一个集合里。例如对于a[1][1],查看其 上方 a[0][1] ,下方 a[2][1]，左方 a[1][0] ，右方 a[0][2]；

3,夹角准则：根据刚刚获取的数据，判断对应的夹角是否存在，如up=true && left=true，则左上角存在，如果有任何一个为false,则该夹角不存在，即a[i][j]在边上，甚至在角上。例如对于a[1][1],查看其 上方 a[0][1] ，左方 a[1][0] 都存在，则其左上方也存在。同理可得，对于a[1][0]  查看其 上方 a[0][0] 存在 ，左方 a[1][-1] 不存在，则其左上方就不存在；

4，排序，取中间值，填入到数组b中；

优点：

1.适用于任何n X n的矩阵；

2.效率高；

附Java 代码：

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class Redom {
    //数组a赋初值
    static int[][] a = {{5, 85, 4, 2, 68},
            {78, 82, 75, 41, 14},
            {79, 47, 38, 1, 47},
            {1, 2, 14, 65, 13},
            {96, 87, 32, 14, 21}};
    //设定数组b的大小与数组a相同
    static int[][] b = new int[a.length][a[0].length];

    public static void main(String[] args) {
        for (int i = 0; i < a.length; i++) {
            for (int j = 0; j < a[i].length; j++) {
                b[i][j] = getAvg(i, j);
                System.out.print(a[i][j] + "\t");
                if (j == a[i].length - 1) System.out.println();
            }
        }
        System.out.println("--------------------------------------");
        for (int i = 0; i < b.length; i++) {
            for (int j = 0; j < b[i].length; j++) {
                System.out.print(b[i][j] + "\t");
                if (j == b[i].length - 1) System.out.println();
            }
        }
    }

    static int getAvg(int i, int j) {
        //获取某一个位置的周围数字
        List<Integer> list = new ArrayList<>();
        boolean up = false;
        boolean down = false;
        boolean left = false;
        boolean right = false;
        //"十"字边界探知
        if (i - 1 >= 0) {
            list.add(a[i - 1][j]);
            up = true;
        }
        if (i + 1 < a.length) {
            list.add(a[i + 1][j]);
            down = true;
        }
        if (j - 1 >= 0) {
            list.add(a[i][j - 1]);
            left = true;
        }
        if (j + 1 < a[i].length) {
            list.add(a[i][j + 1]);
            right = true;
        }
        //方向夹角准则
        if (up && left) {
            list.add(a[i - 1][j - 1]);
        }
        if (up && right) {
            list.add(a[i - 1][j + 1]);
        }
        if (down && left) {
            list.add(a[i + 1][j - 1]);
        }
        if (down && right) {
            list.add(a[i + 1][j + 1]);
        }
        //排序
        Collections.sort(list);
        //取中间值
        int num = list.get((list.size()) / 2);
        return num;
    }
}