数据结构与算法之稀疏数组和队列

最新推荐文章于 2024-06-19 09:46:53 发布

oLengNuanZiZhi12

最新推荐文章于 2024-06-19 09:46:53 发布

阅读量81

点赞数 1

分类专栏：数据结构与算法

本文链接：https://blog.csdn.net/oLengNuanZiZhi12/article/details/113621181

版权

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

10 篇文章 0 订阅

订阅专栏

稀疏数组和队列

1>稀疏数组
2>队列

1>稀疏数组

1.1、实际需求

编写的五子棋程序中，有存盘退出和续上盘的功能
因为该二维数组的很多值是默认值 0，
因此记录了很多没有意义的数据，我们将其转为稀疏数组进行存储

在这里插入图片描述

1.2、稀疏数组处理方法

稀疏数组把具有不同值的元素的行列及值记录在一个小规模的数组中，
从而缩小程序的规模
稀疏数组也是二维数组，行数由原数组的数据决定，列数一般为 3 列
稀疏数组的第一行记录原数组一共有几行几列，有多少个不为零的值
第一列：原数组的行数
第二列：原数组的列数
第三列：原数组有多少个不为零的值
之后的行记录原数组中不为零（x）的值所在的行数、列数以及 x 的值
第一列：x 在原数组中的行数
第二列：x 在原数组中的列数
第三列：x 的值

1.3、实际应用

使用稀疏数组， 来保留类似前面的二维数组(棋盘、 地图等等)
把稀疏数组存盘， 并且可以从新恢复原来的二维数组数

在这里插入图片描述

代码实现

package com;

public class xishushuzu {
    public static void main(String[] args) {
        //1>创建11*11的数组
        int a[][] = new int[11][11];
        a[1][2] = 1;
        a[2][3] = 2;
        System.out.println("原始数组");
        for (int[] row: a
             ) {
            for (int data: row
                 ) {
                System.out.printf("%d\t",data);
            }
            System.out.println();
        }
        //2>将数组转换成稀疏数组
        int sum = 0;
        for (int i =0;i <11;i++)
        {
            for (int j =0;j<11;j++)
            {
                if (a[i][j]!=0)
                    sum++;
            }
        }
        int b[][]=new int[sum+1][3];
        int x = 0;
        b[0][0] = 11;
        b[0][1] = 11;
        b[0][2] = sum;
        for (int i =0;i<11;i++)
        {
            for (int j =0;j<11;j++)
            {
                if (a[i][j]!=0)
                {
                    x++;
                    b[x][0] = i;
                    b[x][1] = j;
                    b[x][2] = a[i][j];
                }
            }
        }
        System.out.println("稀疏数组");
        for (int[] row: b
        ) {
            for (int data: row
            ) {
                System.out.printf("%d\t",data);
            }
            System.out.println();
        }
        //3>稀疏数组转换成二维数组
        int c[][] = new int[b[0][0]][b[0][1]];
        int y = b[0][2];
        for (int i =1;i<=y;i++)
        {
            c[b[i][0]][b[i][1]] = b[i][2];
        }
        System.out.println("还原后的数组");
        for (int[] row: c
        ) {
            for (int data: row
            ) {
                System.out.printf("%d\t",data);
            }
            System.out.println();
        }
    }
}

2>队列

2.1、实际需求

银行排队问题：

在这里插入图片描述

2.2、队列介绍

队列是一个有序列表， 可以用数组或是链表来实现。
遵循先入先出的原则， 即： 先存入队列的数据， 要先取出，后存入的要后取出
示意图： (使用数组模拟队列示意图)

在这里插入图片描述

2.3、数组顺序队列

2.3.1、思路分析

maxSize ：队列容量（数组的长度）
arr ：模拟队列的数组
front ：指向队列头部元素的前一个元素，初始值为 -1
rear ：指向队列尾部元素，初始值为 -1

在这里插入图片描述

	基本操作
队列判空：front == rear 
队列判满：rear == (maxSize - 1) ，即 rear 是否已经指向了数组的最后一个位置
队列元素个数：rear - front
队列入队：队列不满才能入队，arr[++rear] = value
队列出队：队列不空才能出队，return arr[front++]

2.3.2、代码实现

package com;

public class ArrayQueue {
        private int maxsize;//表示数组最大容量
        private int front;//队列头
        private int rear;//队列尾
        private int[] arr;//用于存放数据的数组

        public ArrayQueue(int maxsize)
        {
            this.maxsize = maxsize;
            arr = new int[maxsize];
            front = -1; // 指向队列头部，分析出front是指向队列头的前一个位置
            rear = -1;// 指向队列尾，指向队列尾的数据(即就是队列最后一个数据)
        }
        public boolean isFull()
        {//判断队列是否为满
            return rear == maxsize-1;
        }
        public boolean isEmpty()
        {//判断队列是否为空
            return front == rear;
        }
        public void addQueue(int data)
        {//添加数据到队列中
            if (isFull()) {
                System.out.println("队列已满，无法添加！");
                return;
            }
            else
                {
                    rear++;
                    arr[rear] = data;
            }
        }
        public int getQueue()
        {//获得数据从队列中
            if (isEmpty()){
                throw new RuntimeException("数组是空的，无法取出！");
            }
            else{
                    front++;
                    return arr[front];
            }
        }
        public void showQueue()
        {//遍历队列
            if (isEmpty()){
                throw  new RuntimeException("数组是空的，无法遍历！");
            }
            for (int i = front+1;i<=rear;i++){
                System.out.printf("arr[%d] =%d\n",i,arr[i]);
            }
        }
        public int headQueue()
        {//获取头数据，但没有取出
            if (isEmpty()){
                throw  new RuntimeException("数组是空的，没有数据！");
            }
            return arr[front+1];
        }
}

package com;

import java.util.Scanner;

public class ArrayTest {
    public static void main(String[] args) {
        ArrayQueue arrayQueue = new ArrayQueue(3);
        Scanner scanner = new Scanner(System.in);
        char s;
        boolean key = true;
        while(key)
        {
            System.out.println("s(show):展示出队列中所有的数据");
            System.out.println("e(exit):退出程序");
            System.out.println("a(add):添加数据");
            System.out.println("g(get):取出数据");
            System.out.println("h(head):查看队列头的数据");
            s = scanner.next().charAt(0);
            switch (s)
            {
                case 's':
                    arrayQueue.showQueue();
                    break;
                case 'e':
                    key = false;
                    break;
                case 'a':
                    System.out.println("输入一个数字");
                    int value = scanner.nextInt();
                    arrayQueue.addQueue(value);
                    break;
                case 'g':
                    System.out.println(arrayQueue.getQueue());
                    break;
                case 'h':
                    System.out.println(arrayQueue.headQueue());
                    break;
            }
        }

    }
}

2.4、数组循环队列

2.4.1、提出问题

目前数组使用一次就不能用， 没有达到复用的效果，造成内存空间的浪费
将这个数组使用算法， 改进成一个环形的队列（取模：%）

2.4.2、思路分析

对前面的队列进行优化，改造为环形队列（通过取模实现）
maxSize ：队列容量（数组的长度）
arr ：模拟队列的数组
front ：指向队列头部元素，初始值为 0
rear ：指向队列尾部元素的后一个元素，初始值为 0

在这里插入图片描述

基本操作
- 队列判空：front == rear
- 队列判满：
  - 为何要在 rear 之后，front 之前空出一个元素的空间？因为如果不空出一个元素，队列判空条件为：front == rear ，队列判满的条件也是：front == rear ，有歧义！
- 队列容量：因为空出了一个元素，所以队列容量就变成了 (maxSize - 1)
- 当空出一个元素的空间，如何判满？当还剩一个元素时，队列就已经满了，所以判断条件为 (rear + 1) % maxSize == front
- 队列元数个数：
  - 计算公式：(rear + maxSize - front) % maxSize ，这样来思考：
  - 当 rear 比 front 大时，即 (rear -front) > 0 ，这时还没有形成环形结构，(rear -front) 即是队列元素个数
  - 当 rear 比 front 小时，即 (rear -front) < 0 ，这时已经形成了环形结构，(rear -front) 表示数组还差多少个元素存满（负数），(rear + maxSize - front) 即是队列元素个数
  - 综上：(rear + maxSize - front) % maxSize
- 队列入队：
  - 首先，队列不满才能入队
  - 由于 rear 指向队列尾部元素的后一个元素，所以直接设置即可： arr[rear] = value
  - 接下来，rear 应该向后移动一个位置：rear = (rear + 1) % maxSize
  - 取模是为了防止数组越界，让指针从新回到数组第一个元素
- 队列出队：
  - 首先，队列不空才能出队
  - 由于 front 直接指向队列头部元素，所以直接返回该元素即可：int value = arr[front ]
  - 接下来，front 应该向后移动一个位置：front = (front + 1) % maxSize
  - 取模是为了防止数组越界，让指针从新回到数组第一个元素

2.4.3、代码实现

package com;

public class CircleQueue {
    private int maxsize;
    private int front;//头结点
    private int rear;//尾节点
    private int[] arr;

    public CircleQueue(int maxsize)
    {
        this.maxsize = maxsize;
        arr = new int[maxsize];
        front = 0;//这里指向的是头节点第一个元素
        rear = 0;//这里指向尾节点的后一个元素，因为希望空出一个空间作为区分满与不满
    }
    public boolean isEmpty()
    {
        return front == rear;
    }
    public boolean isFull()
    {
        return (rear+1)%maxsize ==front;
    }
    public void addQueue(int data)
    {
        if (isFull()) {
            System.out.println("队列已满，无法加入");
            return;
        }
        arr[rear] = data;
        rear++;
    }
    public int getQueue() {
        if (isEmpty()) {
            throw new RuntimeException("队列是空，无法获得元素");
        }
        int value = arr[front];
        front++;
        return  value;
    }
    public int size(){
        //有效数据
        return (maxsize+rear-front)%maxsize;
    }
    public void showQueue(){
        if (isEmpty()){
            throw new RuntimeException("队列为空，无法遍历元素");
        }
        for (int i =front;i<front+size();i++)
        {
            System.out.printf("arr[%d] = %d\n",i,arr[i]);
        }
    }
    public int headQueue(){
        if (isEmpty()){
            throw new RuntimeException("队列为空，无法查找头节点");
        }
        return arr[front];
    }
}

package com;

import java.util.Scanner;

public class CircleTest {
    public static void main(String[] args) {
        CircleQueue circleQueue = new CircleQueue(4);
        Scanner scanner = new Scanner(System.in);
        char s =' ';
        boolean key = true;
        while(key)
        {
            System.out.println("s(show):展示出队列中所有的数据");
            System.out.println("e(exit):退出程序");
            System.out.println("a(add):添加数据");
            System.out.println("g(get):取出数据");
            System.out.println("h(head):查看队列头的数据");
            s = scanner.next().charAt(0);
            switch (s){
                case 's':
                    circleQueue.showQueue();
                    break;
                case 'e':
                    key = false;
                    break;
                case 'a':
                    System.out.println("请输入一个数字");
                    int value = scanner.nextInt();
                    circleQueue.addQueue(value);
                    break;
                case 'g':
                    System.out.println(circleQueue.getQueue());
                    break;
                case 'h':
                    System.out.println(circleQueue.headQueue());
                    break;
            }

        }
    }
}

oLengNuanZiZhi12

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
数据结构与算法之稀疏数组和队列

稀疏数组和队列1>稀疏数组1.1、实际需求1.2、稀疏数组处理方法1.3、实际应用代码实现2>队列2.1、实际需求2.2、队列介绍2.3、数组顺序队列2.3.1、思路分析2.3.2、代码实现2.4、数组循环队列2.4.1、提出问题2.4.2、思路分析2.4.3、代码实现1>稀疏数组1.1、实际需求编写的五子棋程序中，有存盘退出和续上盘的功能因为该二维数组的很多值是默认值 0，因此记录了很多没有意义的数据，我们将其转为稀疏数组进行存储1.2、稀疏数组处理方法稀疏数组把具有不
复制链接

扫一扫