稀疏数组与队列

最新推荐文章于 2024-10-13 16:52:53 发布

阿白白白白白白

最新推荐文章于 2024-10-13 16:52:53 发布

阅读量217

点赞数 1

分类专栏：数据结构与算法设计文章标签：算法贪心算法数据结构

本文链接：https://blog.csdn.net/weixin_45905080/article/details/125579090

版权

数据结构与算法设计专栏收录该内容

1 篇文章 0 订阅

订阅专栏

概述

1.1数据结构与算法关系

程序=数据结构+算法

数据结构（data structure）:研究组织数据方式的学科

算法（algorithm）

经典面试题

字符串匹配问题-------KMP算法

汉诺塔问题------分治算法

八皇后问题------回溯算法

马踏棋盘算法/骑士周游问题-------深度优化遍历算法（DFS）+贪心算法优化

生活中的算法

单链表问题
五子棋程序------稀疏数组

1）棋盘（二维数组）——>稀疏数组—>写入文件【存档功能】

2）读取文件——>稀疏数组——>二维数组——>棋盘
丢手帕问题/约瑟夫问题-----单向环形链表
修路问题------普里姆算法+最小生成树（加权值）（data structure）
最短路径----弗洛伊德算法+图

1.2数据结构

数据结构包括 线性结构和非线性结构

1.2.1线性结构

（最常用的数据结构）

①特点：数据元素间存在一对一的关系

②分为两种存储结构：

顺序存储：（eg：数组）构成顺序表，其中的存储元素是连续的
链式存储：构成链表，其中的存储元素不一定是连续的，元素节点则存放数据元素以及相邻元素的地址信息

③常见线性结构：数组、队列、链表和栈 and so on

1.2.1.1稀疏sparsearray数组

Basic introduction(数组下标从0开始)
①用于保存一个内部大部分元素为0或为同一个值的数组
②处理solution：1st.记录数组共有几行几列，有多少个不同值 2nd.把具有不同值的元素的行列及值记录在一个小规模的数组（即稀疏数组）中，从而缩小programme’s 规模

Eg1：数组下标从0开始
①0行元素依次symbolize原始数组的行数、列数、具有除0外的特殊值的个数（即1和2）

②1行依次symbolize第一个非0值的行数、列数、元素值（即原数组中1行2列，元素值为1）；2行类推。

二维数组转稀疏数组的思路：

①遍历原始二维数组，得到有效数据的个数sum

②according to 值sum即可创建稀疏数组sparseArr int【sum+1】【3】

③将二维数组的有效数据存入稀疏数组sparseArr

稀疏数组转原始二维数组的thinking：

①读取稀疏数组的第一行（即0行），根据该行的数据创建原始二维数组，eg：chessArr2=int【11】【11】

②再读取稀疏数组后几行的数据，并存入原始二维数组中

The code is as follow.

package com.atguigu.sparsearray;

public class SparseArray {
    public static void main(String[] args) {
        //创建一个原始的二维数组11*11
        //0：表示没有棋子，1表示黑子，2表示蓝子
        int chessArr1[][]=new int[11][11];
        chessArr1[1][2]=1;
        chessArr1[2][4]=2;
        //输出原始的二维数组
        System.out.println("原始的二维数组：");
        for(int[] row:chessArr1)
        {
            for(int data:row)
            {
                System.out.printf("%d\t",data);
            }
            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++;
            }
            }
        }
        //2.创建对应的稀疏数组
        int sparseArr[][] = new int[sum+1][3];
        //给稀疏数组赋值
        sparseArr[0][0]=11;
        sparseArr[0][1]=11;
        sparseArr[0][2]=sum;
        //遍历二维数组，将非0的值存放到sparseArr中
       int 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();
        System.out.println("稀疏数组为~~~~");
        for (int i = 0; i <sparseArr.length ; i++) {
            System.out.printf("%d\t%d\t%d\n",sparseArr[i][0],sparseArr[i][1],sparseArr[i][2]);
        }
        System.out.println();

    }
}

1.2.1.2队列（p10-p15）

队列介绍
①有序列表，可用数组（即顺序存储）或链表（即链式存储）实现
②遵循先进先出：先存入队列的数据，要先取出；后存入的后取

数组模拟顺序队列

queue类有两个指针，一个队尾rear，一个队头front，rear初值-1，front初值-1；
A. 图二display 存入数据，后进则rear++，而front不变；图三display取出数据，则front++，rear不变（加数据是在尾部加，取数据是在头部取）
B.队列为有序列表，使用数组存储队列数据时，则队列数组的声明are as follow:
a.maxSize为队列的最大容量；front为队列前端下标(随数据输出而改变)，rear为后端下标（随数据输入而改变）。
addQueue为数据存入队列，处理步骤如下：
①当数据入队列时，需判断队列是否为空：if（front==rear），若队列为空或未满时，可将数据入队列；
②队列满的条件:rear==maxSize-1，maxSize为队列最大容量，即队列中有多少个数，而数组以0为下标开头，则maxSize-1 symbolize 数组从0开始的最后个元素下标
③将尾指针后移：rear+1，进行队列添入数据操作
④若尾指针rear小于队列的最大下标maxSize-1，则可将数据存入rear所指的数组元素中；当rear等于maxSize-1，则队列满，即无法存入数据
问题分析：
①数组队列使用一次且不能再用，不能复用
②首先建立一个queue实体类，进行构造器、判断队列满、队列空、进队、出队、查看队头；
③在出队、查看队头数据时需要进行trycatch异常判断（RunTimeException）

 if(isEmpty())
        { //通过抛出异常来处理
            throw new RuntimeException("队列空，不能取数据");//通过抛异常来处理
            //throw本身会马上终止，不必再加return
        }

④在调用出队、查看队头数据时也需要对trycatch异常进行处理

 try
                    {
                        int res = arrayQueue.getQueue();
                        System.out.printf("取出的数据是%d\n", res);
                    }catch(Exception e)
                    {
                        System.out.println(e.getMessage());
                    }

The codes are as follow.

package com.atguigu.queue;
import java.util.Scanner;
//使用数组模拟队列——编写一个ArrayQueue类
public class ArrayQueueDemo {
    public static void main(String[] args) {
        //创建一个队列
        ArrayQueue arrayQueue=new ArrayQueue(3);
        char key=' ';//接受用户输入
        Scanner sc=new Scanner(System.in);
        boolean loop=true;
        //输出一个菜单
        while(loop)
        {
            System.out.println("s(show):show queue");
            System.out.println("e(exit):exit queue");
            System.out.println("a(add):add data to queue");
            System.out.println("g(get):get data from queue");
            System.out.println("h(head):check the head of the queue");
            key=sc.next().charAt(0);//接受一个字符
            switch(key) {
                case 's':
                    arrayQueue.showQueue();
                    break;
                case 'a':
                    System.out.println("输出一个数");
                    int value = sc.nextInt();
                    arrayQueue.addQueue(value);
                    break;
                case 'g': //可能会有异常，当为空时无数据可取
                    try
                    {
                        int res = arrayQueue.getQueue();
                        System.out.printf("取出的数据是%d\n", res);
                    }catch(Exception e)
                    {
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'h'://查看队列头的数据
                    try
                    {
                        int res= arrayQueue.headQueue();
                        System.out.printf("队列头的数据是%d\n",res);
                    }catch(Exception e)
                    {
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'e':
                    sc.close(); //关闭输出
                    loop=false;
                    break;
                default:
                    break;
            }
        }
        System.out.println("程序退出~~~");
    }
}
class ArrayQueue
{
    private int maxSize;//表示数组的最大容量
    private int front;//队列头
    private int rear;//队列尾
    private int[] arr;//该数组用于存数据，模拟队列
    //创建队列的构造器
    public ArrayQueue(int arrMaxSize)
    {
        maxSize=arrMaxSize;
        arr=new int[maxSize];//不new的话，是空数组，不能存数据
        front=-1;//指向队列头，可得出front是指向队列头的前一个位置
        rear=-1;//指向队列尾，指向队列尾的数据（即就是队列最后一个数据
    }
    //判断队列是否满
    public boolean isFull()
    {
        return rear==maxSize-1;
    }
    //判断队列是否为空
    public boolean isEmpty()
    {
        return rear==front;
    }
    //添加数据到队列
    public void addQueue(int n)
    {
        //①判断队列是否满
        if(isFull())
        {
            System.out.println("队列满，不能加入数据~");
            return;
        }
        rear++;//让rear后移
        arr[rear]=n;
    }
    //获取数据，即出队列
    public int getQueue()
    {
        //判断队列是否为空
        if(isEmpty())
        { //通过抛出异常来处理
            throw new RuntimeException("队列空，不能取数据");//通过抛异常来处理
            //throw本身会马上终止，不必再加return
        }
        front++;//front后移
        return arr[front];
    }
    //显示队列的所有数据
    public void showQueue()
    { //遍历
        if(isEmpty())
        {
            System.out.println("队列空，没有数据~");
            return;
        }
        for (int i = 0; i < arr.length ; i++) {
            System.out.printf("arr[%d]=%d\n",i,arr[i]);
        }
    }
    //显示队列的头数据，注意不是取数据
    public int headQueue()
    {
        if(isEmpty())
        {
            throw new RuntimeException("队列空，无数据");
        }
        return arr[front+1];//因front本身是指向队列头的前一个位置
    }

}

数组模拟环形队列

取模：%

假溢出：设置队满的条件不合理，导致队中有空位置

环形（循环）队列介绍

把数组的前后端相连，形成环形顺序表，即把存储队列元素的表从逻辑上看成一个环

①As a matter of fact,内存地址是连续的，不可能是环形的，此处通过逻辑方式实现环形队列
- 思路分析：
  ①改变front变量的意义：rear++—>rear=(rear+1)%MaxSize
  ②改变rear变量的意义:front++——>front=(front+1)%MaxSize
  在初始时将队头队尾设置成相同值：rear=0,front=0
  队列中有效的数据的个数：(rear+MaxSize-front)%MaxSize
环形队列的4要素：
①队空：front==rear
②队满：(rear+1)%MaxSize=front //当MaxSize=4，则只能存放3个元素——>牺牲一个空间
③e进队：rear=(rear+1)%MaxSize;//将元素e放在rear处
④出队：front=(front+1)%MaxSize;//取出front处的元素e