面试题：如何将任意一个 一维数组 转换成任意的 二维数组

最新推荐文章于 2024-10-16 21:32:12 发布
最新推荐文章于 2024-10-16 21:32:12 发布
阅读量326 收藏
点赞数
CC 4.0 BY-SA版权
文章标签： java 面试
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/flagyili/article/details/117335710

目录

代码如下：

说明：我这里写的代码的 限制条件是 一维数组中最多 有 26个 元素（以26个字母为基本）。当然，想测试更多，可以更改判断条件。

代码如下：

说明：输出二维数组的逻辑，参考JDK的源码。JDK有现成的API：Arrays.deepToString:

@SuppressWarnings("all")
public class ArrayTransform {
    private static final int
            ZERO = 0, ONE = 1, TWO = 2, THREE = 3, FOUR = 4,
            FIVE = 5, SEX = 6, SEVEN = 7, EIGHT = 8, NINE = 9,
            TEN = 10, ELEVEN = 11, TWELVE = 12, THIRTEEN = 13,
            FOURTEEN = 14, FIFTEEN = 15, SIXTEEN = 16, SEVENTEEN = 17,
            EIGHTEEN = 18, NINETEEN = 19, TWENTY = 20, TWENTY_ONE = 21,
            TWENTY_TWO = 22, TWENTY_THREE = 23, TWENTY_FOUR = 24, TWENTY_FIVE = 25,
            TWENTY_SIX = 26;


    public static Object[][] transformToTwoDimensionArray(Object[] srcArray, int howGap) throws Exception {
        if (srcArray.length > TWENTY_SIX) {
            throw new Exception("sorry, at most 26 element!!!");
        }
        if (howGap == ZERO){
            throw new Exception("sorry, how Gap cannot is zero !!!");
        }
        if (srcArray.length == ZERO){
            return new Object[ZERO][];
        }
        Object[][] objDimensionArr = null;
        int flag = ZERO;
        // 分配二维数组长度
        if ((howGap == srcArray.length)) {
            flag = ONE;
            objDimensionArr = new Object[ONE][];
        } else {
            objDimensionArr = allocationTwoDimensionArrayLength(srcArray, howGap, objDimensionArr);
        }

        int count = 0;
        for (int j = 0; j < objDimensionArr.length; j++) {
            // 为二维数组里面的一维数组分配长度
            if (flag == ONE) {
                objDimensionArr[j] = new Object[srcArray.length];
            } else {
                objDimensionArr[j] = new Object[howGap];
                if (j == objDimensionArr.length - 1) {
                    switch (srcArray.length % howGap) {
                        case ONE:
                            objDimensionArr[j] = new Object[ONE];
                            break;
                        case TWO:
                            objDimensionArr[j] = new Object[TWO];
                            break;
                        case THREE:
                            objDimensionArr[j] = new Object[THREE];
                            break;
                        case FOUR:
                            objDimensionArr[j] = new Object[FOUR];
                            break;
                        case FIVE:
                            objDimensionArr[j] = new Object[FIVE];
                            break;
                        case SEX:
                            objDimensionArr[j] = new Object[SEX];
                            break;
                        case SEVEN:
                            objDimensionArr[j] = new Object[SEVEN];
                            break;
                        case EIGHT:
                            objDimensionArr[j] = new Object[EIGHT];
                            break;
                        case NINE:
                            objDimensionArr[j] = new Object[NINE];
                            break;
                        case TEN:
                            objDimensionArr[j] = new Object[TEN];
                            break;
                        case ELEVEN:
                            objDimensionArr[j] = new Object[ELEVEN];
                            break;
                        case TWELVE:
                            objDimensionArr[j] = new Object[TWELVE];
                            break;
                    }
                }
            }

            // 给 每个二维数组里面的一位数组的元素 赋值
            to:
            for (int i = 0; i < srcArray.length; i++) {
                for (int d = 0; d < objDimensionArr[j].length; d++) {
                    objDimensionArr[j][d] = srcArray[count];
                    count++;
                    if (d == objDimensionArr[j].length - 1) {
                        break to;
                    }
                }
            }
        }
        return objDimensionArr;
    }

    private static Object[][] allocationTwoDimensionArrayLength(Object[] srcArray, int howGap, Object[][] objDimensionArr) throws Exception {
//        if (srcArray.length / howGap == srcArray.length) {
//            objDimensionArr = new Object[srcArray.length][];
//        }
        if (srcArray.length / howGap == TWENTY_SIX) {
            objDimensionArr = new Object[TWENTY_SIX][];
        } else {
            if (srcArray.length % howGap == 0) {
                objDimensionArr = schema1(srcArray, howGap);
            } else {
                if (howGap > (srcArray.length / 2)) {
                    switch (srcArray.length / howGap) {
                        case ONE:
                            objDimensionArr = new Object[ONE + 1][];
                            break;
                        default:
                            objDimensionArr = schema2(srcArray, howGap);
                    }
                } else {
                    objDimensionArr = schema2(srcArray, howGap);
                }
            }
        }
        return objDimensionArr;
    }

    private static Object[][] schema2(Object[] srcArray, int howGap) throws Exception {
        Object[][] objDimensionArr = null;
        switch (srcArray.length / howGap) {
            case ONE:
                objDimensionArr = new Object[ONE + 1][];
                break;
            case TWO:
                objDimensionArr = new Object[TWO + 1][];
                break;
            case THREE:
                objDimensionArr = new Object[THREE + 1][];
                break;
            case FOUR:
                objDimensionArr = new Object[FOUR + 1][];
                break;
            case FIVE:
                objDimensionArr = new Object[FIVE + 1][];
                break;
            case SEX:
                objDimensionArr = new Object[SEX + 1][];
                break;
            case SEVEN:
                objDimensionArr = new Object[SEVEN + 1][];
                break;
            case EIGHT:
                objDimensionArr = new Object[EIGHT + 1][];
                break;
            case NINE:
                objDimensionArr = new Object[NINE + 1][];
                break;
            case TEN:
                objDimensionArr = new Object[TEN + 1][];
                break;
            case ELEVEN:
                objDimensionArr = new Object[ELEVEN + 1][];
                break;
            case TWELVE:
                objDimensionArr = new Object[TWELVE + 1][];
                break;
            default:
                if (howGap > srcArray.length) {
                    throw new Exception("sorry, gap cannot greater than resource array length!!! array length: " + srcArray.length);
                }
        }
        return objDimensionArr;
    }
    
    private static Object[][] schema1(Object[] srcArray, int howGap) {
        Object[][] objDimensionArr = null;
        switch (srcArray.length / howGap) {
            case ONE:
                objDimensionArr = new Object[ONE][];
                break;
            case TWO:
                objDimensionArr = new Object[TWO][];
                break;
            case THREE:
                objDimensionArr = new Object[THREE][];
                break;
            case FOUR:
                objDimensionArr = new Object[FOUR][];
                break;
            case FIVE:
                objDimensionArr = new Object[FIVE][];
                break;
            case SEX:
                objDimensionArr = new Object[SEX][];
                break;
            case SEVEN:
                objDimensionArr = new Object[SEVEN][];
                break;
            case EIGHT:
                objDimensionArr = new Object[EIGHT][];
                break;
            case NINE:
                objDimensionArr = new Object[NINE][];
                break;
            case TEN:
                objDimensionArr = new Object[TEN][];
                break;
            case ELEVEN:
                objDimensionArr = new Object[ELEVEN][];
                break;
            case TWELVE:
                objDimensionArr = new Object[TWELVE][];
                break;
            case THIRTEEN:
                objDimensionArr = new Object[THIRTEEN][];
                break;
        }
        return objDimensionArr;
    }

    public static String dimensionArrayToString(Object[] oArr) {
        if (oArr == null){return "null";}
        int bufLength = oArr.length * 20;
        if (oArr.length != 0 && bufLength <= 0){
            bufLength = Integer.MAX_VALUE;
        }
        StringBuilder sb = new StringBuilder(bufLength);
        toStr(oArr,sb);
        return sb.toString();
    }
    private static void toStr(Object[] oArr, StringBuilder sb){
        if (oArr == null){
            sb.append("null");
            return;
        }
        int maxIndex = oArr.length -1;
        if (maxIndex == -1){
            sb.append("[]");
            return;
        }

        sb.append('[');
        int i = 0;
        while (true){
            // 每个元素
            Object ele = oArr[i];
            if (ele == null ){
                sb.append("null");
            }else{
                final Class<?> clazz = ele.getClass();
                // 是否是数组，是就递归
                if (clazz.isArray()){

                    toStr((Object[]) ele,sb);
                }else{
                    // 数组的每个元素to str
                    sb.append(ele.toString());
                }
            }
            if (i == maxIndex){
                break;
            }
            sb.append(", ");
            i++;
        }
        sb.append(']');
//        for (int i=0;;i++){
//            // 每个元素
//            Object ele = oArr[i];
//            if (ele == null ){
//                sb.append("null");
//            }else{
//                final Class<?> clazz = ele.getClass();
//                // 是否是数组，是就递归
//                if (clazz.isArray()){
//                    // 递归
//                    to((Object[]) ele,sb);
//                }else{
//                    //
//                    sb.append(ele.toString());
//                }
//            }
//            if (i == maxIndex){
//                break;
//            }
//            sb.append(", ");
//        }

    }
}

test: 

public static void main(String[] args) throws Exception {
        Character[] srcArray = {'a', 'b', 'c', 'd', 'e', 'f',
                'g', 'h', 'i', 'j', 'k', 'l',
                'm', 'n', 'o', 'p', 'q', 'r',
                's', 't', 'u', 'v', 'w', 'x', 'y', 'z'};
        final Object[][] resultArr = ArrayTransform.transformToTwoDimensionArray(srcArray, 3);
        final String s = ArrayTransform.dimensionArrayToString(resultArr);
        System.out.println(s);
    }

result:

 

Jonny Z
关注
2024年Unity 面试题 |五萬字 二佰道| Unity面试题大全，面试题总结【全网最全，收藏一篇足够面试】
努力前行，总会成为自己心中的那道光
02-23 16万+
正所谓 金三银四 ，又到了找工作的大好时机了，不知道大家有没有意向找一份更好的工作呢~ 之前写了很多Unity的学习和实例文章，但是面试题部分还没有一个系统的整理。 那本篇文章就来整理一下Unity中一些常见的面试题，说不准就会面试的时候就会遇到！ 本篇文章会将Unity所有方面的面试资料都融会贯通，绝对是2022年Unity面试领域最实用的文章啦！
第 1-7 课：数组和排序算法 + 面试题
磊哥聊Java
10-28 369
数组的定义与使用 数组是 Java 编程中最重要的数据结构之一，也是最基本的数据结构，Java 中的常用集合 ArrayList、HashMap 等内部的实现都使用到了数组结构。数组是只能用来存储一种类型的集合，可以通过下标访问数值中的所有元素。 数组的声明方式有以下两种，如整数型数组，请参考下面代码： 方式一：int[] arr; 方式二：int arr[]; 大部分情况下，我们会使用第一种...
Leetcode刷题100天—2022. 将一维数组转变成二维数组(数组)—day55
智的博客
12-02 2889
前言： 作者：神的孩子在歌唱 大家好，我叫运智 2022. 将一维数组转变成二维数组 难度简单0 给你一个下标从 0 开始的一维整数数组 original 和两个整数 m 和 n 。你需要使用 original 中 所有 元素创建一个 m 行 n 列的二维数组。 original 中下标从 0 到 n - 1 （都 包含 ）的元素构成二维数组的第一行，下标从 n 到 2 * n - 1 （都 包含 ）的元素构成二维数组的第二行，依此类推。 请你根据上述过程返回一个 m x n 的二维数组。如果无法构成
面试题（数组去重，排序，转换）
Kylincsg的博客
07-28 158
var arr = [ 15, [1, new Number(10), 2], { a: 3, b: [4, 7, 8] }, [6, 7, 8, 9, [11, 12, [12, 13, [14]]]], ]; // 输出：[1, 2, 3, 4, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]
一维数组转为二维数组(3种方法)-基于C语言
热门推荐
m0_54158068的博客
04-19 2万+
一维数组转为二维数组(3种方法)-基于C语言
JavaScript实现一维数组转化为二维数组
09-20
下面小编就为大家分享一篇JavaScript实现一维数组转化为二维数组，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
Java编程一维数组转换成二维数组实例代码
08-28
主要介绍了Java编程一维数组转换成二维数组，分享了相关代码示例，小编觉得还是挺不错的，具有一定借鉴价值，需要的朋友可以参考下
WebGIS开发面试题：前端篇（一）
2301_78220461的博客
09-06 1810
本系列内容主要介绍webgis开发过程中可能会遇到的常见面试题和答案，从前端到二维到三维，干货满满。记得关注我不走丢！需要更多面试题、视频讲解、webgis教程的宝子戳↓↓↓。
动态数组面试题解析：从原理到实现的全面揭秘
![所有数组变量-测试工程师校招面试题库]...本文还探讨了动态数组在实际编程面试中的应用，并提出了一些性能优化技术。最后，展望了
面试经典150题刷题——数组/字符串部分
最新发布
m0_47411815的博客
10-16 711
给你两个按排列的整数数组nums1和nums2，另有两个整数m和n，分别表示nums1和nums2中的元素数目。请你nums2到nums1中，使合并后的数组同样按排列。最终，合并后数组不应由函数返回，而是存储在数组nums1中。为了应对这种情况，nums1的初始长度为m + n，其中前m个元素表示应合并的元素，后n个元素为0，应忽略。nums2的长度为n。
二维数组转一维数组
04-13
将labview内二维数组方便的转化为一维数组使用
PHP二维数组（或任意维数组）转换成一维数组的方法
一个入门程序猿的博客
03-28 2779
$arr = [ 'a' =&gt; [ 1, 2, ], 'b' =&gt; [ '3', '4'=&gt;[ '5' ] ], 'b' ]; print_r(iterator_to_array( new RecursiveIterato...
创建numpy数组的不同方式
Gordennizaicunzai的博客
01-05 838
Numpy库的核心是数组对象或ndarray对象（n维数组）。你将使用Numpy数组执行逻辑，统计和傅里叶变换等运算。作为使用Numpy的一部分，你要做的第一件事就是创建Numpy数组。本指南的主要目的是帮助数据科学爱好者了解可用于创建Numpy数组的不同方式。 创建Numpy数组有三种不同的方法： 使用Numpy内部功能函数 从列表等其他Python的结构进行转换 使用特殊的库函数 #使...
一维数组转二维数组
weixin_45289656的博客
05-10 666
将一维数组根据某一个相同的属性变成二维数组，有两种转换的数据结构。以上两种方式想要哪种都可以转换。第二种：数据格式转换成这样。
一维数组转化为二维数组
weixin_49154058的博客
07-25 6235
一维数组的转换
MATLAB 将不同长度的一维数组存入二维数组
Anne033的博客
02-08 3690
将多个不同长度的一维数组存入二维数组时，需要将所有一维数组的长度转为相同长度，可以采用在数组后边补零的方式实现。 如果a是行向量，M是你要的最终向量的长度，用 a=[a , zeros(1,M-length(a))]; 如果a是列向量，改成 a=[ a ; zeros(M-length(a),1)]; ...
【力扣·每日一题】2022. 将一维数组转变成二维数组（C++ 模拟 vector）
我们都有光明的未来
01-01 995
linkk 题意 思路 只用vector的基本操作push_back和size就可以完成本题。 用二维vector存储答案，tmp表示一行的数。 遍历给出的original数组，将元素放到tmp里 每次对tmp里的元素个数进行判断，如果tmp的元素个数等于n的话，说明应该放到下一行了，就将当前tmp放入ans里，清空tmp。 代码 class Solution { public: vector<vector<int>> construct2DArray(vector<
c++ 一维数组转二维数组
xiangxianghehe的博客
09-12 8186
const int a[10] = { 1, 2, 3, 4, 5,6,7,8 }; int b[2][4]={0}; int i=0; int j=0; for (int m=0;m<10;m++) { i=m/4; j=m%4; b[i][j]=a[m]; } for (int i=0;i<2;i++) { for (int j=0;j<...
如何能让一维数组转换成二维数组
weixin_55633731的博客
07-25 3633
分析 接口给我们的数据是一个一维数组[{}, {}, {},{},{},{},{},{}]，为了方便轮播图使用，我们把4件商品分成一组，一组是一个单位来填充轮播的一屏。 二维数组转换成一维数组（[1,1],[2,2],[3,3] 转换成 [1, 1, 2, 2, 3, 3]） slice（）方法 // 得到需要的数据： 把一维数组转成二位数组 // 转换前：[1,2,3,4,5,6,7,8] // 取size=4； 4个一组 // 转换后：[[1,2,3,4], [5,6,7,8...
信息技术面试必备：笔试题精华整理
"这是一份关于笔试面试题的整理，主要涵盖了C/C++语言和编程基础，包括指针、数组、字符串操作、内存管理、文件处理、数据类型转换、字节序、自定义类实现等多个方面的知识。" 1. 指针与数组: - `sizeof`运算符...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值