数据结构与算法

数据结构

第一章 线性结构

1.稀疏数组

1.线性结构  和非线性结构
    --| 数据元素中间存在一一对应的线性关系 称为线性结构 -常见 数组 栈  链表
                顺序存储是指存储的地址是连续的  ，链式 存储元素不一定是连续的
    --| 非线性结构：  多维数组  数结构 图结构



2.稀疏数组和队列：

    ---|  稀疏数组： 当一个数组中大部分元素为0 或者为同一个 值的数组时  可以使用稀疏数组 库保存 该数组
       稀疏数组的处理办法为：
                    1. 记录数组一共有几行几列  有多少 不同的值
                    2.把具有不同值的元素的行列值 记录在一个小规模的数组中 从而缩小出程序的规模

    稀疏数组的使用：
       行不确定  有三个列
                row  col  val
         0      11    11    2    这组值记录的是  原来数组中 有11个行 有11个列  有效数据为2个
         1      1      2     1   这组值记录的是 原来数组中  第一个有效数据的位置  第一行 第二列 值为1
         2      2     3     2 这组数据 记录的是在原来数组中 第二行 第二列的 值为2

      因此
         二维数组转稀疏数组：
                    1. 遍历原始的二维数组  得到有效的个数为sum
                    2. 根据sum就可以创建稀疏数组sparseArr int[有效数据+1][3]  列是确定 总是三列  分别为 原二位数组中 第row行 第col列 的值为val
                    3.将二维数组的有效数据 存入到稀疏数组即可

           稀疏数组 转换为原始的二维数组：
                   1.先读取到稀疏数组的第一行 根据第一行的数据 可以拿到原来数组的行列及有效数据的有效值   创建原始的二位数组 比如： chessArr=int[11][11]
                   2.在读取稀疏数组后几行的数据 并赋值给原始的二维数组即可

        稀疏数组的代码实现：

package demo1;



class Array1{

    public static void main(String[] args) {

//        1.先创建一个原始的二维数组
            int[][] Array=new int[11][11];

//            2.在数组中复制  0表示没有子  1 表示黑子  2表示蓝子
        Array[1][2]=1;//在 二维数组的第一行第一列 有黑子
        Array[2][3]=2;//在第二行第三列 有篮子
        Array[4][4]=18;


        System.out.println("原始的二维数组");
//    外层循环遍历行
for (int[] row:Array){//先拿到 二位数组中的行

    for (int data:row){//在从行中拿到值
        System.out.printf("%d\t",data);
    }
    System.out.println();
}

//2.将 二维数组转换为稀疏数组
//          1.先变量二位数拿到 有效值
        int count = 0;//记录有效值
        for (int i=0;i<Array.length;i++){

            for (int j=0;j<Array.length;j++){
                if (Array[i][j]!=0){
                    count++;
                }
            }
        }
        System.out.println("有效数据为"+count);


//        3.创建对应的稀疏数组
        int[][] sparseAr=new int[count+1][3];

//        给稀疏数组完成复制
//        根据图片来描述这个稀疏二位数组的代码化
        sparseAr[0][0]=11;//x=0 y=0 的位置存储着11
        sparseAr[0][1]=11;//x=0 y=1 的位置存储着11
        sparseAr[0][2]=count;//x=0 y=2 的位置存储着有效数据的个数


//        遍历 原来的二维数组  依次把有效数据放到新数组中
        int newCount=0;//记录着非01数据
        for (int i=0;i<Array.length;i++){
            for (int j=0;j<Array.length;j++){
                if (Array[i][j]!=0){
                  newCount++;
                  sparseAr[newCount][0]=i;
                  sparseAr[newCount][1]=j;
                  sparseAr[newCount][2]=Array[i][j];
                }
            }
        }

        System.out.println();
        System.out.println("得到的稀疏数组为：");

        for (int i = 0; i < sparseAr.length; i++) {
            System.out.printf("%d\t%d\t%d\t\n",sparseAr[i][0],sparseAr[i][1],sparseAr[i][2]);
        }
        System.out.println();




        //3. 稀疏数组 转换为 普通数组
//    创建 一个二维数组
//    新数组的规模为 之前稀疏数组的第一行的数据 稀疏数组中第一个位置的值为 新数组的规模的长  第二个位置为新数组的规模的宽
        int[][] newSpar=new int[  sparseAr[0][0]]     [sparseAr[0][1]     ];
//        接着 循环 把 值还原回去  读取后两行的数据  把数据还原
        for (int i = 1; i < sparseAr.length; i++) {//这里i从1开始
            newSpar[ sparseAr[i][0] ]   [sparseAr[i][1]]=sparseAr[i][2];//把稀疏数组的第i行的第二列 的值 复制给
//            新数组
        }




//        还原后的二维数组
        for (int[] row:newSpar){

            for (int clo:row){
                System.out.printf("%d\t",clo);
            }
            System.out.println();
        }

    }




}

2.队列