数据结构与算法—线性与非线性结构、稀疏矩阵和队列

已于 2023-12-06 21:32:36 修改
阅读量119 收藏 2
点赞数
分类专栏： 数据结构与算法 文章标签： 算法 java 线性回归 数据结构
于 2023-12-04 10:48:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_49429082/article/details/134778283
版权

数据结构与算法—线性与非线性结构、稀疏矩阵和队列

尚硅谷韩老师数据结构与算法:线性与非线性结构、稀疏矩阵和队列

文章目录

1. 线性结构与非线性结构

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

1.1 线性结构

  1. 线性结构作为最常用的数据结构，其特点是数据元素之间存在一对一的线性关系
  2. 线性结构有两种不同的存储结构，即顺序存储结构和链式存储结构。顺序存储的线性表称为顺序表，顺序表中的存储元素是连续的（地址连续）。
  3. 链式存储的线性表称为链表，链表中的存储元素不一定是连续的，元素节点中存放数据元素以及相邻元素的地址信息。
  4. 常见的线性结构有：数组、队列、链表和栈

1.2 非线性结构

  非线性结构包括：二维数组，多维数组、广义表、树结构、图结构。

2. 稀疏数组

  需求引入：对于一个很多值默认值是0的二维数组，记录了很多没有意义的数据(值为0的数据)

  这个时候就可以用一个稀疏数组对此二维数组进行压缩

2.1 基本介绍

  当一个数组中大部分元素为0，或者为同一个值的数组时，可以使用稀疏数组来保存该数组。

稀疏数组的处理方法是:

  1. 记录数组一共有几行几列，有多少个不同的值
  2. 把具有不同值的元素的行列及值记录在一个小规模的数组中，从而缩小程序的规模。

举例说明
在这里插入图片描述

图1 稀疏数组的例子

  如图1所示，左侧的数组为保存了所有数据值的6 * 7的二维数组，右侧是转换为9 * 3的稀疏数组，后者相对于前者少了一定的数据，缩小了数据的规模。其中图1中稀疏数组的第一行的三个元素分别表示原数组的行数、列数、有效数据值的个数，后面每一行都分别保存一个有效数据值所在原数组中第几行、第几列、值。

2.2 二维数组与稀疏数组的相互转化

2.2.1 二维数据转稀疏数组

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

  1. 遍历原始的二维数组，得到有效数据的个数sum
  2. 根据sum就可以创建稀疏数组大小为:sum+1 * 3
  3. 将二维数组的有效数据存入到稀疏数组中
2.2.2 稀疏数组转二维数组

稀疏数组转二维数组思路:

  1. 先读取稀疏数组的第一行，根据第一行的数据，创建原始的二维数组。
  2. 再读取稀疏数组后几行的数据，并赋给原始的二维数组即可。
2.2.3 代码实现
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][3] = 2;
        //输出原始二维数组
        System.out.println("==============原始的二维数组===============");
        for (int[] row : chessArr1) {
            for (int data : row) {
                System.out.print(data + "\t");
            }
            System.out.println();
        }

        //将二维数组转稀疏数组
        //1. 先遍历二维数组 得到非0数据的个数
        int sum = 0;
        for (int[] row : chessArr1) {
            for (int data : row) {
                if (data != 0) {
                    sum++;
                }
            }
        }
        System.out.println("数组不为零的个数为sum:" + sum);

        //2. 创建对应的稀疏数组
        int[][] sparseArr = new int[sum + 1][3];
        //给稀疏数组赋值
        sparseArr[0][0] = chessArr1.length;//行数
        sparseArr[0][1] = chessArr1[0].length;//列数
        sparseArr[0][2] = sum;  //有效数据的个数
        int k = 1;//用于记录是第一个非零值
        //遍历二维数组 将非零的值存放到sparseArr中
        for (int i = 0; i < chessArr1.length; i++) {
            for (int j = 0; j < chessArr1[0].length; j++) {
                if (chessArr1[i][j] != 0) {
                    sparseArr[k][0] = i;//保存此值的行数
                    sparseArr[k][1] = j;//保存此值的列数
                    sparseArr[k++][2] = chessArr1[i][j];//保存值
                }
            }
        }
        //输出稀疏数组的形式
        System.out.println("==============得到的稀疏数组===============");
        for (int[] row : sparseArr) {
            for (int data : row) {
                System.out.print(data + "\t");
            }
            System.out.println();
        }

        //将稀疏数组 -->恢复为原始的二维数组
        //1.先读取稀疏数组的第一行，根据第一行的数据，创建原始的二维数组。
        int[][] chessArr2 = new int[sparseArr[0][0]][sparseArr[0][1]];
        //2. 再读取稀疏数组后几行的数据，并赋给原始的二维数组即可。
        for (int i = 1; i < sparseArr.length; i++) {
            chessArr2[sparseArr[i][0]][sparseArr[i][1]] = sparseArr[i][2];
        }
        System.out.println("==============由稀疏数组得到的二维数组===============");
        for (int[] row : chessArr2) {
            for (int data : row) {
                System.out.print(data + "\t");
            }
            System.out.println();
        }
    }
}
2.2.4 课后练习
  1. 在前面的基础上 将稀疏数组保存到磁盘上，比如map.data
  2. 恢复原来的数组时，读取map.data进行恢复

实现代码如下:

//在前面的基础上 将稀疏数组保存到磁盘上，比如map.data
try {
    DataOutputStream dataOutputStream = new DataOutputStream(new FileOutputStream("map.dat"));
    // 保存稀疏数组的行和列信息
    dataOutputStream.writeInt(sparseArr.length);
    dataOutputStream.writeInt(sparseArr[0].length);

    for (int i = 0; i < sparseArr.length; i++) {
        for (int j = 0; j < sparseArr[0].length; j++) {
            if (sparseArr[i][j] != 0) {
                // 保存非零元素的行、列和值
                dataOutputStream.writeInt(i);
                dataOutputStream.writeInt(j);
                dataOutputStream.writeInt(sparseArr[i][j]);
            }
        }
    }
    dataOutputStream.close();
} catch (IOException e) {
    throw new RuntimeException(e);
}

//恢复原来的数组时，读取map.data进行恢复
try {
    DataInputStream dataInputStream = new DataInputStream(new FileInputStream("map.dat"));
    int rows = dataInputStream.readInt();
    int cols = dataInputStream.readInt();

    int[][] sparseArr2 = new int[rows][cols];
    while (dataInputStream.available() > 0) {
        int row = dataInputStream.readInt();
        int col = dataInputStream.readInt();
        int value = dataInputStream.readInt();

        sparseArr2[row][col] = value;
    }
    dataInputStream.close();
    System.out.println("==============由稀疏数组得到的二维数组===============");
    for (int[] row : sparseArr2) {
        for (int data : row) {
            System.out.print(data + "\t");
        }
        System.out.println();
    }
} catch (IOException e) {
    throw new RuntimeException(e);
}

或者使用字符包装流

try {
    BufferedWriter writer = new BufferedWriter(new FileWriter("src\\map.txt"));
    // 保存稀疏数组的行和列信息
    writer.write(sparseArr.length + " " + sparseArr[0].length);
    writer.newLine();

    for (int i = 0; i < sparseArr.length; i++) {
        for (int j = 0; j < sparseArr[0].length; j++) {
            if (sparseArr[i][j] != 0) {
                // 保存非零元素的行、列和值
                writer.write(i + " " + j + " " + sparseArr[i][j]);
                writer.newLine();
            }
        }
    }
    writer.close();
} catch (IOException e) {
    throw new RuntimeException(e);
}

try {
    BufferedReader reader = new BufferedReader(new FileReader("src\\map.txt"));
    String line = reader.readLine();
    String[] dimensions = line.split(" ");
    int rows = Integer.parseInt(dimensions[0]);
    int cols = Integer.parseInt(dimensions[1]);

    int[][] sparseArr2 = new int[rows][cols];
    while ((line = reader.readLine()) != null) {
        String[] elements = line.split(" ");
        int row = Integer.parseInt(elements[0]);
        int col = Integer.parseInt(elements[1]);
        int value = Integer.parseInt(elements[2]);

        sparseArr2[row][col] = value;
    }
    reader.close();
    System.out.println("==============由稀疏数组得到的二维数组===============");
    for (int[] row : sparseArr2) {
        for (int data : row) {
            System.out.print(data + "\t");
        }
        System.out.println();
    }
} catch (IOException e) {
    throw new RuntimeException(e);
}

3.队列

3.1 队列介绍

队列介绍:

  • 队列是一个有序列的表，可以用数组或是链表来实现

  • 遵循先入先出的原则，即：先存入队列的数据，要先取出。后存入的要后取出。

  • 示意图：（使用数组模拟队列示意图）

    外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

图2 使用数组模拟队列示意图

  图2中，变量rear随着数据的加入而变化，变量front随着数据的取出而变化。由图2可知，先进入的数据先被取走(0、1处的数据比2、3处的数据先放入，最后也是先被取出)。

3.2 数组模拟队列

数组模拟队列:

  • 队列本身是有序列表，若使用数组的结构来存储队列的数据，则队列数组的声明如下图，其中maxSize是该队列的最大容量。

  • 因为队列的输出、输入是分别从前后端来处理，因此需要两个变量front及rear分别记录队列前后端的下标，front会随着数据输出而改变，而rear则会随着数据输入而改变，如图2所示。

  • 当需要将数据存入到队列中时，称为"addQueue"，addQueue的处理需要有两个步骤：

    • 当front==rear（此时为空），将尾指针往后移：rear++;
    • 当rear<maxSize-1（此时队列未满），将尾指针往后移：rear++。否则说明队列满了，无法存入数据。
//使用数组模拟队列 编写一个ArrayQueue类
class ArrayQueue {
    private int maxSize;    //表示数组的最大容量
    private int front;      //队列头
    private int rear;       //队列尾
    private int[] arr;      //该数据用于存放数据，模拟队列

    //创建队列的构造器
    public ArrayQueue(int arrMaxSize) {
        maxSize = arrMaxSize;
        arr = new int[maxSize];
        front = -1; //指向队列头部 分析出front是指向队列头的第一个位置
        rear = -1;  //指向尾，指向队列尾的数据(即就是队列的最后一个数据)
    }

    //判断队列是否满
    public boolean isFull() {
        return rear == maxSize - 1;
    }

    //判断队列是否为空
    public boolean isEmpty() {
        //因为每次取数据都是取的是front+1时的数据
        //但是一旦front==rear 那么说明后面没数据了
        //则队列为空了
        return rear == front;
    }

    //添加数据到队列
    public void addQueue(int n) {
        //判断队列是否满
        if (isFull()) {
            System.out.println("队列满，不能加入数据~~~");
            return;
        }
        arr[++rear] = n;
    }

    //获取队列的数据，出队列 为null则失败
    public Integer getQueue() {
        //判断队列是否为空
        if (isEmpty()) {
            System.out.println("队列空，取不出来数据~~~");
            return null;
//            //通过抛出异常处理
//            throw new RuntimeException("队列空，不能取数据");
        }
        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 Integer headQueue() {
        //判断
        if (isEmpty()) {
            System.out.println("队列是空的，没有数据~~");
            return null;
//            throw new RuntimeException("队列空，没有数据");
        }
        return arr[front + 1];
    }
}

  问题分析并优化

  1. 目前数组使用一次就不能用，没有达到复用的效果
  2. 将这个数组使用算法，改进成一个环境队列

3.3 使用数组模拟环形队列的思路分析

俺先在上面基础上写了一个环形队列，测试的话还能用,显示队列的功能没有完善(从零显示到尾)

//使用数组模拟队列 编写一个ArrayQueue类
class ArrayQueue {
    private int maxSize;    //表示数组的最大容量
    //队列头  指向的位置 代表已经取出了相应位置的值
    private int front;      //比如front=2 则说明第2个位置不在栈中了(从0开始计数) front + 1为第一个有效数据的位置
    private int rear;       //队列尾  指向的位置 代表最新添加的数据所在的位置
    private int[] arr;      //该数据用于存放数据，模拟队列
    private boolean flag;   //用来辅助判断是否为空 true则说明上一次执行的是添加数据操作

    //创建队列的构造器
    public ArrayQueue(int arrMaxSize) {
        maxSize = arrMaxSize;
        arr = new int[maxSize];
        front = -1; //指向队列头部 分析出front是指向队列头的第一个位置
        rear = -1;  //指向尾，指向队列尾的数据(即就是队列的最后一个数据)
    }

    //判断队列是否满
    public boolean isFull() {
//        return rear == maxSize - 1;
        //因为每次读入的数据都写在第rear+1个位置
        //如果第rear+1个位置正好在第一个有效数据的位置(front+1) 则说明写满了
        if(front == -1){//说明还没取出过数据1
            return rear == maxSize - 1;
        }else {
            return (rear + 1 > maxSize - 1 ? 0 : rear + 1) == (front + 1 > maxSize - 1 ? 0 :front + 1);
        }
        //return ((rear + 1 > maxSize - 1 ? 0 : rear) == front && front != -1) || (front == -1 && rear == maxSize - 1);
    }

    //判断队列是否为空
    public boolean isEmpty() {

        if(flag){//如果上一个是添加数据操作 则直接返回false
            return false;
        }
        //否则 如果最新添加的数据的位置是与front相同
        //则说明最新添加的数据也被取走了
        //则此时没有数据了
        return front == rear;
    }

    //添加数据到队列
    public void addQueue(int n) {
        //判断队列是否满
        if (isFull()) {
            System.out.println("队列满，不能加入数据~~~");
            return;
        }
        //++rear 说明添加的数据值的位置放在rear+1处 且rear + 1 代表最新添加的数据的位置
        arr[++rear > maxSize - 1 ? rear = 0 : rear] = n;
        flag = true;
    }

    //获取队列的数据 出队列 为null则失败
    public Integer getQueue() {
        //判断队列是否为空
        if (isEmpty()) {
            System.out.println("队列空，取不出来数据~~~");
            return null;
//            //通过抛出异常处理
//            throw new RuntimeException("队列空，不能取数据");
        }
        flag = false;
        //++front 说明取出的值为front+1出的位置 且front + 1 代表此位置被取走了
        //那么此时一个有效数据的位置为 在得到++front更新后的front值再加1
        return arr[++front > maxSize - 1 ? front = 0 : 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 Integer headQueue() {
        //判断
        if (isEmpty()) {
            System.out.println(front);
            System.out.println("队列是空的，没有数据~~");
            return null;
//            throw new RuntimeException("队列空，没有数据");
        }else if(front == -1){//此时不为空 但是也没取出过数据
            return arr[0];
        }
        //front + 1 第一个有效数据的位置
        return arr[front + 1 > maxSize - 1 ? 0 : front + 1];
    }

韩老师将front、rear变量的含义均做了一个调整，思路如下:

  1. front就指向队列的第一个元素，即arr[front]就是队列的第一个有效数据

    • 所以现在取出来就应该执行return arr[front++];先用front再加1
    • 初始值一开始指向位置为零的第1个元素 front = 0;

  2. rear指向队列的最后一个元素(新添加元素)的后一个位置。主要是想空出一个空间作为约定

    • 所以现在添加元素应该是执行arr[rear++] = n;先用rear再加1
    • 初始值一开始指向位置为零的第1个元素 rear = 0;

  3. 当队列满时，条件是(rear + 1) % maxSize == front 或者 (rear + 1 > maxSize - 1? 0 : rear +1) ==front

    • rear + 1得到的就是最后一个元素的后面第二个位置 如果此位置和front队列元素的第一个位置相同 则此时满了
    • 说明最后一个元素的后面第一个位置直接被跳过去了 没有利用到 所以这里牺牲了一个空间(最后一个元素的后一个空间)
    • 也就是说当最后一个的后面第二个空间为队列第一个有效数据时 那么此时的最后一个元素的后一个空间永远不存数据 因为此时就认为是满了 不存数据了
    • 按道理来说应该是最后一个元素的后面第一个位置如果与front队列元素第一个位置相同才说明满了
    • 这是为了避免出现我上个代码中写的问题(出现了一个flag辅助判断是否为满)

  4. 当队列空时，条件是front == rear

    • 也就是说当队列的一个元素和队列最后一个元素的后一个位置相同时 说明空了
    • 因为队列最后一个元素的后一个位置肯定是没存有效数据的 此时如果队列一个元素还和其位置相同
    • 那就说明刚好读空了 有一个元素的条件的front + 1 == rear;第二个元素的位置是空的

  5. 当我们这样分析 队列中有效数据的个数则为 (maxSize + rear - front ) % maxSize

    • 有效个数 其实就是从rear的位置开始 数前面位置(rear-1 rear-2…)的数 直到数到front的位置 总和

    • 当rear > front时 直接就是rear - front 此时就是rear与front的长度

    • 当rear < front时 如果直接rear-front(=-(front - rear)) 则得到的是 从front开始往前数 数到rear 那么得到的就是无效数据的个数的负数 若加上 maxSize(总长度、总个数) 最后得到的就是有效数据的个数，这才是我们需要求得数据。即应该为rear-front + maxSize

    • 接下来将两个条件写成一个等式，注意到两个条件最后得到的都是整数 如果对第一个条件也加上maxSize ,则两个条件得等式相同 但是由于第一个条件会多出一个maxSize 所以再对式子取模maxSize 那么还是得到正确的结果。同样此时第二个条件也还是得到正确的结果

    • 综上所示 条件为 (maxSize + rear - front ) % maxSize
      韩老师代码如下

//使用数组模拟队列 编写一个ArrayQueue类
class ArrayQueue {
    private int maxSize;    //表示数组的最大容量
    //队列头  指向的位置 代表已经取出了相应位置的值
    private int front;      //比如front=2 则说明第2个位置不在栈中了(从0开始计数) front + 1为第一个有效数据的位置
    private int rear;       //队列尾  指向的位置 代表最新添加的数据所在的位置
    private int[] arr;      //该数据用于存放数据，模拟队列
    private boolean flag;   //用来辅助判断是否为空 true则说明上一次执行的是添加数据操作

    //创建队列的构造器
    public ArrayQueue(int arrMaxSize) {
        maxSize = arrMaxSize;
        arr = new int[maxSize];
        front = -1; //指向队列头部 分析出front是指向队列头的第一个位置
        rear = -1;  //指向尾，指向队列尾的数据(即就是队列的最后一个数据)
    }

    //判断队列是否满
    public boolean isFull() {
//        return rear == maxSize - 1;
        //因为每次读入的数据都写在第rear+1个位置
        //如果第rear+1个位置正好在第一个有效数据的位置(front+1) 则说明写满了
        if(front == -1){//说明还没取出过数据1
            return rear == maxSize - 1;
        }else {
            return (rear + 1 > maxSize - 1 ? 0 : rear + 1) == (front + 1 > maxSize - 1 ? 0 :front + 1);
        }
        //return ((rear + 1 > maxSize - 1 ? 0 : rear) == front && front != -1) || (front == -1 && rear == maxSize - 1);
    }

    //判断队列是否为空
    public boolean isEmpty() {

        if(flag){//如果上一个是添加数据操作 则直接返回false
            return false;
        }
        //否则 如果最新添加的数据的位置是与front相同
        //则说明最新添加的数据也被取走了
        //则此时没有数据了
        return front == rear;
    }

    //添加数据到队列
    public void addQueue(int n) {
        //判断队列是否满
        if (isFull()) {
            System.out.println("队列满，不能加入数据~~~");
            return;
        }
        //++rear 说明添加的数据值的位置放在rear+1处 且rear + 1 代表最新添加的数据的位置
        arr[++rear > maxSize - 1 ? rear = 0 : rear] = n;
        flag = true;
    }

    //获取队列的数据 出队列 为null则失败
    public Integer getQueue() {
        //判断队列是否为空
        if (isEmpty()) {
            System.out.println("队列空，取不出来数据~~~");
            return null;
//            //通过抛出异常处理
//            throw new RuntimeException("队列空，不能取数据");
        }
        flag = false;
        //++front 说明取出的值为front+1出的位置 且front + 1 代表此位置被取走了
        //那么此时一个有效数据的位置为 在得到++front更新后的front值再加1
        return arr[++front > maxSize - 1 ? front = 0 : 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 Integer headQueue() {
        //判断
        if (isEmpty()) {
            System.out.println(front);
            System.out.println("队列是空的，没有数据~~");
            return null;
//            throw new RuntimeException("队列空，没有数据");
        }else if(front == -1){//此时不为空 但是也没取出过数据
            return arr[0];
        }
        //front + 1 第一个有效数据的位置
        return arr[front + 1 > maxSize - 1 ? 0 : front + 1];
    }

}
小小低头哥
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JAVA 数据结构--稀疏数组
Slamande的博客
04-03 182
稀疏数组       学算法的基础要从了解数据结构开始，了解数据结构可以先从数组开始，我们先来看一下 稀疏数组 吧! 稀疏数组的优缺点 优点： 避免了基本数据类型的装箱操作 不需要额外的结构体，单个元素的存储成本更低 数据量小的情况下，随机访问的效率更高 缺点： 插入操作需要复制数组，增删效率降低 数据量巨大时，查询效率也会明显下降       （当前理解到这些） 接下来，我们可
《数据结构 1800题》
12-27
7. 数据结构是研讨数据的_（1）物理结构_和_（2）逻辑结构 _，以及它们之间的相互关系，并对与这种结构定义相应的_操作（3）_，设计出相应的（4）算法_。【西安电子科技大学 1998 二、2（3分）】 8． 一个算法具有 ...
非线性稀疏表示理论及其应用
07-15
非线性稀疏表示理论及其应用，这一方向是当前信号处理领域的热点研究方向。
压缩感知里的稀疏为什么是非线性模型
冬瓜班小朋友的博客
04-24 859
Sparsity is a highly nonlinear model，since the choice of which dictionary elements are used can change from signal to signal[1]. [1]Devore R A. Nonlinear approximation[J]. Acta Numerica, 1998, 7(7):51...
非&线性结构&稀疏数组(JAVA)
weixin_63818303的博客
05-13 180
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 数据结构前言一、线性结构二、非线性结构三、稀疏数组 前言 本文章为利用Java来写数据结构与算法 一、线性结构 线性结构作为最常用的数据结构，其特点是数据元素之间存在一对一的线性关系。 线性结构有两种不同的存储方式：顺序存储和链式存储 2.1.顺序存储的线性表称为顺序表，存储元素是连续的。 2.2.链式存储的顺序表称为链表，链表的存储元素不一定是连续的，元素节点存放数据元素以及相邻元素的地址信息 线性结构常见有：数组，队列，链表和栈.
数据结构与算法——知识点总结
记录知识，学习分享
06-02 2万+
本文包含数据结构与算法主要的基本知识点，便于知识的梳理和回顾。 如需详细了解具体知识点请自行结合课本或者网上查阅。 目录 1、概述 2、线性表 3、栈 4、队列 5、串 6、多维数组和广义表 7、树和二叉树 8、图 9、查找 10、排序 1、概述 从 2、线性表 3、栈 4、队列 5、串 6、多维数组和广义表 7、树和二叉树 8、图 9、查找 10、排序 ...
【数据结构】稀疏矩阵的快速转置
ChenZHIHAO_y的博客
04-05 556
稀疏矩阵的快速转置（普通转置 和 快速转置）
数据结构与算法 第二章 数据结构中的线性结构
CodeQingqing的博客
09-03 423
2.1 线性表及其表现 一、什么是线性表 1. 一元多项式的表示 方法1：顺序存储结构直接表示 —— 适用于多项式中每一项的指数较小的情况 用一维数组的各分量表示多项式各项，即数组元素a[i]表示多项式中项xix^ixi的系数aia_iai​；两个多项式相加，就是两个数组对应的分量相加 例1，表示f(x)=4x5−3x2+1f(x)=4x^5-3x^2+1f(x)=4x5−3x2+1，则利用数组可以有如下表示： 下标i 0
《算法和数据结构》题海战术篇
热门推荐
英雄哪里出来
09-12 5万+
刷了 3333 题 算法题 后的一点点经验总结 —— 题不是这么刷的！
【王道考研】王道数据结构与算法详细笔记（全）
强哥的微博
06-08 1万+
线性表是具有相同数据类型的n(n>0)个数据元素的有限序列。(其中n为表长，当n=0时线性表是一个空表。若用L命名线性表，则其一般表示为)1. 存在惟一的第一个元素。2. 存在惟一的最后一个元素。3. 除第一个元素之外，每个元素均只有一个直接前驱。4. 除最后一个元素之外，每个元素均只有一个直接后继1.是线性表中的“第i个”元素线性表中的位序。2.是表头元素;是表尾元素。
数据结构与算法期中练习题答案.doc
05-06
数据结构与算法期中练习题...涵盖了数据结构的基本概念、算法设计、时间复杂度、空间复杂度、抽象数据类型、线性结构、栈、队列、二叉树、稀疏矩阵等知识点，旨在帮助读者更好地理解数据结构与算法的相关概念和技术。
数据结构复习题整理（附答案）.doc
10-20
本资源摘要信息涵盖了数据结构的基础知识点，包括算法、线性结构、非线性结构、链表、栈、队列、二叉树等。 一、算法 * 算法的重要特性：有穷性、确定性、可行性、输入、输出 * 好算法的标准：正确性、可读性、...
数据结构课后习题与答案.doc
09-28
"数据结构课后习题与答案" 本文是数据结构课后习题与答案的知识点总结，...本文涵盖了数据结构的基本概念和各种数据结构的实现方法，以及排序算法和图论的知识点，旨在帮助读者更好地理解和掌握数据结构的相关知识。
数据结构课程设计
06-03
稀疏矩阵转置： 输入稀疏矩阵中每个元素的行号、列号、值，建立稀疏矩阵的三元组存储结构，并将此矩阵转置，显示转置前后的三元组结构。 用头尾链表存储表示法建立广义表，输出广义表，求广义表的表头、广义表的表尾...
数据结构——非线性结构（图）
巧克力布丁的博客
08-26 5419
如果本身就是连通图，则本身就是其连通分量，而非连通图的各个连通图作为其组成部分均为其连通分量强连通图：任意顶点出发可以到达其余任意节点假设一个图有n个节点，如果边数小于n-1，那么此图必是非连通图一个图有n个顶点，并且有大于n-1条边，则此图一定有环顶点不分大小、主次，所以用一个一维数组存储图中顶点的信息边或弧由于是顶点之间的关系，用一个二维数组存储图中边的信息（这个二维数组称为邻接矩阵）性质1：是有向图的一种链式存储结构：将邻接表和逆邻接表整合在一起邻接多重表是无向图的另一种链式存储结构。........
牛客网刷题 | BC118 N个数之和
m0_64000959的博客
06-09 465
目前主要分为三个专栏，后续还会添加： 专栏如下： C语言刷题解析 C语言系列文章 我的成长经历感谢阅读！初来乍到，如有错误请指出，感谢！输入数字N，然后输入N个数，计算这N个数的和。第一行输入一个整数N(0≤N≤50)，第二行输入用空格分隔的N个整数。输出为一行，为第二行输入的“N个整数之和”的计算结果。使用数组的方式 先将用户输入的几个数字分别存起来定义一个变量将它数字的和加起来然后输出 代码 2 ： 输入n个数相加，应该想到循
力扣LCP 08.剧情触发时间
最新发布
Pisasama的博客
06-12 308
【代码】力扣LCP 08.剧情触发时间。
LeetCode 算法：轮转数组c++
小金牛来了
06-09 649
LeetCode 算法：轮转数组c++
线性数据结构和非线性
08-21
数据构根据元素之间的关系可以分为线性数据结构和非线性数据结构。 线性数据结构是指数据元素之间存在一对一的关系，即每个元素只有一个直接前驱和一个直接后继。常见的线性数据结构有数组、链表、栈和队列等。其中，数组是一种连续存储元素的线性结构，链表是一种通过指针链接各个节点的线性结构，栈是一种具有后进先出（LIFO）特性的线性结构，而队列是一种具有先进先出（FIFO）特性的线性结构。 非线性数据结构是指数据元素之间存在一对多或多对多的关系，即每个元素可以有多个直接前驱和直接后继。常见的非线性数据结构有树和图等。树是一种层次关系的非线性结构，其中每个节点可以有多个子节点，而每个子节点只能有一个父节点。图是一种由节点和连接节点的边组成的非线性结构，其中节点之间的关系可以是任意的。 总结起来，线性数据结构中元素之间存在一对一的关系，而非线性数据结构中元素之间存在一对多或多对多的关系。不同类型的数据结构适用于不同的应用场景，选择合适的数据结构可以提高算法效率和解决问题的便利性。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值