java数据结构和算法

程序=数据结构+算法

线性结构

1. 数据与元素之间存在一对一的线性关系
2. 线性结构有两种不同的存储结构,即睡醒存储结构(数组)和链式存储结构(链表),顺序存储的线性表称为顺序表,顺序表中的存储元素是连续的.
3. 链式存储的线性表称为链表,链表中存储的元素不一定是连续的,元素节点中存放数据元素以及相邻的地址信息
4. 线性结构常见的有:数组,队列,链表,和栈

非线性结构

1. 二维数组
2. 多维数组
3. 广义表
4. 树结构
5. 图结构

稀疏数组和队列

稀疏数组

应用场景:

 用稀疏数组对二维数组进行压缩,上图;

稀疏数组的基本介绍

 稀疏数组总是一个行(hang)不确定,但是列是三列的数组:上面的第一排6,7,8指的是原始数组是一个6行7列有8个有效值的二维数组.

二维数组转稀疏数组的思路如下

• 1,遍历原始的二维数组,得到有效数据的个数
• 2.根据sum就可以创建稀疏数组sparseArr int[sum+1][3]
• 3,将二维数组的有效数据存入到稀疏数组中就可以了

稀疏数组转二维数组的思路如下

• 1.先读取稀疏数组的第一行,根据第一行的数据,创建原始的二维数组,比如上面的chessArr2=int[6][7]
• 2,再读取稀疏数组后面的几行数组,并赋值给原始的二维数据即可.

package com.atguigu.sparsearray;

public class SparseArray {
    public static void main(String[] args) {
        //1.先创建一个原始的二维数组11*11
        //:0表示没有棋子,1表示黑子,2.表示蓝色的棋子
        int chessArr1[][]=new int[11][11];
        chessArr1[1][2]=1;
        chessArr1[2][4]=2;
        chessArr1[5][6]=2;
        //输出原始数组
        for(int[] row:chessArr1){
            for(int data:row){
                System.out.print(data+"\t");
            }
            System.out.println();
        }


        //将二维数组转换为稀疏数据
        //1,先遍历二维数组得到非0数据的个数
        int sum=0;
        for(int i=0;i<11;i++){
            for(int j=0;j<11;j++){
                if(chessArr1[i][j]!=0){
                    sum++;
                }
            }
        }
        System.out.println("sum的值为:"+sum);

        //2.创建稀疏数组
        int sparseArr[][]=new int[sum+1][3];
        //给稀疏数组赋值
        sparseArr[0][0]=11;
        sparseArr[0][1]=11;
        sparseArr[0][2]=2;
        //遍历二维数组,将非0的值存放到稀疏数组中
        int count=0;//count用于记录是第几个非0数据
        for(int i=0;i<11;i++){
            for(int j=0;j<11;j++){
                if(chessArr1[i][j]!=0){
                    count++;
                    sparseArr[count][0]=i;
                    sparseArr[count][1]=j;
                    sparseArr[count][2]=chessArr1[i][j];
                }
            }
        }

        System.out.println("得到的稀疏数组如下:==========");
        for(int i=0;i<sparseArr.length;i++){
            System.out.println(sparseArr[i][0]+"\t"+sparseArr[i][1]+"\t"+sparseArr[i][2]+"\t");
        }
        System.out.println();


        //将稀疏数据恢复成二维数据*

        /**
         * 1,先读取稀疏数组第一行,根据第一行数据,创建元素数组,
         * 2,在读取稀疏数组后几行的数组,并赋值给原始的二维数据即可
         * */

        int chessArr2[][]=new int[sparseArr[0][0]][sparseArr[0][1]];
        for(int i=1;i<sparseArr.length;i++){

            chessArr2[sparseArr[i][0]][sparseArr[i][1]]=sparseArr[i][2];
        }

        for(int[] chess:chessArr2){
            for(int che:chess){
                System.out.print(che+"\t");
            }
            System.out.println();
        }
    }
}

把稀疏数组写进磁盘(IO),这个就是用到io流,我之前写过io流的详细用法.

package io;

import java.io.*;
import java.nio.charset.StandardCharsets;

public class SparseArray {
    public static void main(String[] args) throws FileNotFoundException {
        
        /*这里对于pw流的使用,其实我们可以直接使用PrintWriter,但是我们也可以用下面的方法,因为这个是自定义的PW流,我们
        * 可以定义流的字符集,*/
        //要写入磁盘,先创建
        FileOutputStream fos=new FileOutputStream("pw.txt");
        OutputStreamWriter osw=new OutputStreamWriter(fos, StandardCharsets.UTF_8);
        BufferedWriter bw=new BufferedWriter(osw);
        PrintWriter pw=new PrintWriter(bw,true);
        
        //1.先创建一个原始的二维数组11*11
        //:0表示没有棋子,1表示黑子,2.表示蓝色的棋子
        int chessArr1[][]=new int[11][11];
        chessArr1[1][2]=1;
        chessArr1[2][4]=2;
        chessArr1[5][6]=2;
        //输出原始数组
        for(int[] row:chessArr1){
            for(int data:row){
                /*System.out.print(data+"\t");*/
                pw.print(data+"\t");
            }
           pw.println();
        }


        //将二维数组转换为稀疏数据
        //1,先遍历二维数组得到非0数据的个数
        int sum=0;
        for(int i=0;i<11;i++){
            for(int j=0;j<11;j++){
                if(chessArr1[i][j]!=0){
                    sum++;
                }
            }
        }
      /*  System.out.println("sum的值为:"+sum);*/
        pw.println("sum的值:"+sum);

        //2.创建稀疏数组
        int sparseArr[][]=new int[sum+1][3];
        //给稀疏数组赋值
        sparseArr[0][0]=11;
        sparseArr[0][1]=11;
        sparseArr[0][2]=2;
        //遍历二维数组,将非0的值存放到稀疏数组中
        int count=0;//count用于记录是第几个非0数据
        for(int i=0;i<11;i++){
            for(int j=0;j<11;j++){
                if(chessArr1[i][j]!=0){
                    count++;
                    sparseArr[count][0]=i;
                    sparseArr[count][1]=j;
                    sparseArr[count][2]=chessArr1[i][j];
                }
            }
        }
       
//        System.out.println("得到的稀疏数组如下:==========");
        pw.println("得到稀疏数据如下=======================");
        for(int i=0;i<sparseArr.length;i++){
          //  System.out.println(sparseArr[i][0]+"\t"+sparseArr[i][1]+"\t"+sparseArr[i][2]+"\t");
             pw.println(sparseArr[i][0]+"\t"+sparseArr[i][1]+"\t"+sparseArr[i][2]+"\t");
        }
       /* System.out.println();*/
        pw.println();


        //将稀疏数据恢复成二维数据*

        /**
         * 1,先读取稀疏数组第一行,根据第一行数据,创建元素数组,
         * 2,在读取稀疏数组后几行的数组,并赋值给原始的二维数据即可
         * */

        int chessArr2[][]=new int[sparseArr[0][0]][sparseArr[0][1]];
        for(int i=1;i<sparseArr.length;i++){

            chessArr2[sparseArr[i][0]][sparseArr[i][1]]=sparseArr[i][2];
        }

        for(int[] chess:chessArr2){
            for(int che:chess){
                System.out.print(che+"\t");
            }
            System.out.println();
        }

        pw.close();
    }
}

文本写入磁盘,用的是pw流,因为它可以按行写出字符串和自动刷新的特性,可以很好的写出我们的二维数组和稀疏数组