稀疏数组之单向链表存储二维数组（JAVA）

最新推荐文章于 2024-08-14 16:46:37 发布

二个二个二

最新推荐文章于 2024-08-14 16:46:37 发布

阅读量780

点赞数 1

文章标签： java 链表数据结构

本文链接：https://blog.csdn.net/qq_47688745/article/details/125686625

版权

一、转换原理

将一个二维数组转换为链式存储，转换后再将其还原，简单原理见下图（结合了本人的理解，画图水平见谅，自己理解理解）。

二、代码结构

这一部分是代码结构，代表了我写代码的思路，有需要可以看一看。

//随机生成二维数组

public int[][] twoDimensionalArray(int row, int column){

//这里返回int[][]二维数组，是因为在下一个方法showValue()中，需要传入一个二维数组。
}

//返回二维数组有效值个数并展示二维数组

public int showValue(int[][] array){

//这里返回的int代表传入二维数组的有效值个数，在下个方法convertLinkedList()中要
//用来确定单向链表的first节点。
//这个方法实际上是展示数组，顺便计算有效值个数
}

//二维数组链式存储

public List<Node> convertLinkedList(int[][] array, int count){

//这是将数组转换为链表的代码
//为方便下个方法reduceArray()还原数组，故将链表中的数据存储到列表，并返回这个 //列表。
}

//将链表还原为数组

public int[][] reduceArray(List<Node> list){
//这里是还原数组的代码
//为了方便展示还原后的数组，返回还原后的二维数组
}

三、完整代码

1、SinglyLinkedList类

package com.parseArray.linkedlist;

import java.util.ArrayList;
import java.util.List;
import java.util.Random;

/*
链式存储压缩数组
    [行，列，值，next]->[行，列，值，next]……
 */
public class SinglyLinkedList {



    /**
     * 生成一个二维数组
     * @param row 行数
     * @param column 列数
     * @return 二维数组
     */
    public int[][] twoDimensionalArray(int row, int column){

        int[][] array = new int[row][column];

        //随机赋值
        Random random = new Random();
        int i = 0;
        while (i <= random.nextInt(row)){
            array[random.nextInt(row - 1)][random.nextInt(column - 1)] = random.nextInt(10);
            i++;
        }

        return array;
    }




    /**
     * 返回有效值个数并展示二维数组
     * @param array 二维数组
     * @return 有效值的个数
     */
    public int showValue(int[][] array){

        int count = 0;
        for(int[] arrs: array){
            for(int arr : arrs){
                if (arr != 0){
                    count++;
                }
                System.out.print(arr + "\t");
            }
            System.out.println();
        }

        return count;
    }




    /**
     * 二维数组链式存储
     * @param array 数组
     * @param count 有效值个数
     * @return 列表，存储链表中的数据
     */
    public List<Node> convertLinkedList(int[][] array, int count){

        //定义一个头节点（保存数组基本信息）
        Node first = new Node(array.length,array[0].length,count);

        //定义一个临时节点
        Node temp = first;

        //定义一个列表存储节点数据
        List<Node> list = new ArrayList<Node>();
        list.add(first);

        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                if (array[i][j] != 0){
                    while (temp.getNext() != null){
                        temp = temp.getNext();
                    }
                    temp.setNext(new Node(i,j,array[i][j]));
                    list.add(temp.getNext());
                    //System.out.println(temp.getNext());
                }
            }
        }

        //显示链表
        temp = first;
        while (true){
            System.out.println(temp);
            if (temp.getNext() != null){
                temp = temp.getNext();
            }else {
                break;
            }
        }
        return list;
    }




    /**
     * 将链表还原为数组
     * @param list 存储链表数据的列表
     * @return 还原后的数组
     */
    public int[][] reduceArray(List<Node> list){
        //定义数组
        int[][] array = new int[list.get(0).getRow()][list.get(0).getColumn()];

        //有效值个数
        int count = list.get(0).getValue();

        //遍历链表，给数组赋值
        for (int i = 1; i <= count; i++) {
            array[list.get(i).getRow()][list.get(i).getColumn()] = list.get(i).getValue();
        }
        return array;
    }
}

2、测试代码

package com.parseArray.linkedlist;

import java.util.List;

public class Test {
    public static void main(String[] args) {

        SinglyLinkedList linkedList = new SinglyLinkedList();

        //随机生成一个5行5列的数组
        int[][] array = linkedList.twoDimensionalArray(5,5);


        System.out.println("--------------------二维数组--------------------");
        //计算数组有效值个数，并展示随机生成的数组
        int count = linkedList.showValue(array);


        System.out.println("---------------二维数组转链式存储-----------------");
        //二维数组转链式存储，返回一个列表，接受链表中的数据
        List<Node> list = linkedList.convertLinkedList(array,count);


        System.out.println("---------------链式存储转二维数组-----------------");
        //还原数组
        array = linkedList.reduceArray(list);
        //展示数组
        linkedList.showValue(array);
    }
}