数据结构（链表、矩阵、串、树、图）

最新推荐文章于 2024-03-12 16:31:10 发布
最新推荐文章于 2024-03-12 16:31:10 发布
阅读量796 收藏 2
点赞数 1
分类专栏： 数据结构 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44775784/article/details/107577724
版权

7.7

数据结构

一、基本概念

  • 数据

    是指可以进行操作的具体数据，比如0/1

  • 数据元素

    是数据的基本单位，通常 是被看作一个整体

    由多个数据项或者数据元素组成，其实就是一组数据，比如个人的信息（包含年龄、性别）

  • 数据结构

    各个数据元素之间的关系

    三要素

    1. 逻辑结构

      • 集 合
      • 线性结构
      • 树形结构
      • 图状结构（网状结构）

    2. 物理结构

      其实就是存储结构

      • 顺序存储

        在物理上是连续的

      • 链式存储

        链表

      • 索引存储

        有目录记录 数据所在位置

      • 散列存储

        利用hash值

    3. 数据运算

  • 数据对象

    相同数据结构的集合

  • 数据类型

    值的集合和定义在这集合上的一组操作

  • 抽象数据类型

    抽象的数据组织和相关的运算

二、算法

特性：

  • 输入
  • 输出
  • 有穷性
  • 确定性
  • 可行性

时间复杂度：
在这里插入图片描述

  • ps 求导公式：

    (x^a)'=ax^(a-1)
(a^x)'=a^xlna
(logax)'=1/(x*lna)
(sinx)'=cosx
(cosx)'=-sinx
（uv)'=uv'+u'v
(u+v)'=u'+v'
(u/v)'=(u'v-uv')/v^2

空间复杂度：

  • 原地工作

    是指算法所需要的空间是常数

三、数据结构

1. 线性表

  • 定义 在这里插入图片描述

    线性表是具有相同类型有限个元素的有限序列

  • 分类

    1. 顺序表

      • 相关操作

        插入/删除/查找

        package com.zxc.linearTable.sequence;

/**
 * 功能描述: 顺序表
 * @Author: zxc
 * @Date: 2020/7/18 12:49
 */
public class options {
    /**
     * 功能描述: 添加
     * @Author: zxc
     * @Date: 2020/7/17 20:53
     */
    private int add(int[] t, int i, int e){
        for (int j = array.CURRENT_SIZE+1; j != i; j--) {
            t[j]=t[j-1];
        }
        t[i]=e;
        return e;
    }
    /**
     * 功能描述: 删除
     * @Author: zxc
     * @Date: 2020/7/18 12:03
     */
    private void delete(int[] t,int i){
        if (i<0||i>array.CURRENT_SIZE){
            System.out.println("超出范围");
        }
        for (int j = i; j <array.CURRENT_SIZE ; j++) {
            t[j]=t[j+1];
        }
    }
    /**
     * 功能描述: 展示
     * @Author: 31262
     * @Date: 2020/7/17 20:52
     */
    private void display(int[] T){
        for (int value : T) {
            System.out.print(value + " ");
        }
        System.out.println();
    }

    public static void main(String[] args) {
        options os=new options();
        int[] t =array.T;
        os.display(t);
        os.add(t,2,777);
//        os.delete(t,2);
        os.display(t);
    }


}

    2. 单链表
      在这里插入图片描述

      • 头结点是拿来存放想要存放的相关信息，
        也是为了统一空表和非空表的相关操作

      • 头插法建立单链表

      • 尾插法建立单链表

      • 插入

        前插法：由于需要找到目标元素的前一个元素，所以可能需要遍历链表到前一个，但是前插法可以转成后插法，只需先用后插法再交互元素即可

        后插法

      • 删除

        当给定元素的指针的时候，我们只需要交换元素数据，就可以不用找到前一个元素的指针

    package com.zxc.linearTable.linkedList;

import org.hibernate.validator.constraints.EAN;

import java.util.Scanner;

/**
 * 功能描述: 链表
 * @Author: zxc
 * @Date: 2020/7/18 12:48
 */
public class options {


    /**
     * 功能描述: 创建（头插法
     * @Author: zxc
     * @Date: 2020/7/22 21:32
     */
    public void createLinkedList(linkedList list){
        Node node=list.getNode();
        Scanner sr=new Scanner(System.in);
        String t="";
        while(true){
            Node newNode=new Node();
            t=sr.next();
            if (t.equals("x"))break;
            newNode.setText(t);
            if (node.getNext()!=null){
                newNode.setNext(node.getNext());
            }
            node.setNext(newNode);
            node=newNode;
        }
    }


    /**
     * 功能描述: 尾插法
     * @Author: zxc
     * @Date: 2020/7/23 10:47
     */
    public void createLinkedListByTail(linkedList list){
        Node node=list.getNode();
        Scanner sr=new Scanner(System.in);
        String t="";
        while(true){
            Node newNode=new Node();
            t=sr.next();
            if (t.equals("x"))break;
            newNode.setText(t);
            if (node.getNext()!=null){
                newNode.setNext(node.getNext());
            }
            node.setNext(newNode);
        }
    }

    /**
     * 功能描述: 插入
     * @Author: zxc
     * @Date: 2020/7/22 21:38
     */
    public linkedList insert(linkedList list,String text,int i){
        Node newNode=new Node(text);
        Node node=list.getNode();

        for (int j = 0; j < i-1 && node!=null; j++) {
                node=node.getNext();
        }
        assert node != null;
        newNode.setNext(node.getNext());
        node.setNext(newNode);
        return list;
    }
    /**
     * 功能描述: 删除
     * @Author: zxc
     * @Date: 2020/7/22 22:53
     */
    public linkedList delete(linkedList list,int i){
        Node node=list.getNode();

        for (int j = 0; j < i-1 && node!=null; j++) {
            node=node.getNext();
        }
        assert node != null;
        node.setNext(node.getNext().getNext());
        return list;
    }



    /**
     * 功能描述: 展示
     * @Author: zxc
     * @Date: 2020/7/22 22:43
     */
    public void display(linkedList list){
        Node node=list.getNode().getNext();
        while (node!=null){
            System.out.print(node.getText()+"=>");
            node=node.getNext();
        }
    }

    public static void main(String[] args) {
        options os=new options();
        linkedList list=new linkedList();

        os.createLinkedListByTail(list);
//        os.insert(list,"a",1);
//        os.insert(list,"b",2);
//        os.insert(list,"c",3);
//        os.insert(list,"d",4);
//        os.insert(list,"e",5);

//        os.delete(list,2);
        os.display(list);
    }

}

    1. 双向链表

      • 如单项链表一样操作

    2. 循环链表（单/双）

      • 只是给最后一个数据元素的后继指针指向头指针
      package com.zxc.linearTable.doublyLinkedList;

import com.zxc.linearTable.doublyLinkedList.Node;
import com.zxc.linearTable.doublyLinkedList.linkerList;

import java.util.Scanner;

/**
 * 功能描述: 双向链表
 * @Author: zxc
 * @Date: 2020/7/18 12:48
 */
public class options {


    /**
     * 功能描述: 创建（头插法
     * @Author: zxc
     * @Date: 2020/7/22 21:32
     */
    public void createLinkedList(linkerList list){
        Node node=list.getNode();
        Scanner sr=new Scanner(System.in);
        String t="";
        while(true){
            Node newNode=new Node();
            t=sr.next();
            if (t.equals("x")) {
                break;
            }
            newNode.setText(t);
            newNode.setNext(node.getNext());
            newNode.setPre(node);
            node.setNext(newNode);
            if (null!=newNode.getNext()){
                newNode.getNext().setPre(newNode);
            }
            node=newNode;
        }
    }


    /**
     * 功能描述: 尾插法
     * @Author: zxc
     * @Date: 2020/7/23 10:47
     */
    public void createLinkedListByTail(linkerList list){
        Node node=list.getNode();
        Scanner sr=new Scanner(System.in);
        String t="";
        while(true){
            Node newNode=new Node();
            t=sr.next();
            if (t.equals("x"))break;
            newNode.setText(t);
            newNode.setNext(node.getNext());
            newNode.setPre(node);
            node.setNext(newNode);
            if (null!=newNode.getNext())
            newNode.getNext().setPre(newNode);
        }
    }

    /**
     * 功能描述: 插入
     * @Author: zxc
     * @Date: 2020/7/22 21:38
     */
    public linkerList insert(linkerList list,String text,int i){
        Node newNode=new Node();
        Node node=list.getNode();

        for (int j = 0; j < i-1 && node!=null; j++) {
                node=node.getNext();
        }
        assert node != null;
        newNode.setText(text);
        newNode.setNext(node.getNext());
        newNode.setPre(node.getPre());
        node.getNext().setPre(newNode);
        node.setNext(newNode);
        return list;
    }
    /**
     * 功能描述: 删除
     * @Author: zxc
     * @Date: 2020/7/22 22:53
     */
    public linkerList delete(linkerList list,int i){
        Node node=list.getNode();

        for (int j = 0; j < i-1 && node!=null; j++) {
            node=node.getNext();
        }
        assert node != null;
        if (node.getNext().getNext()!=null){
            node.getNext().getNext().setPre(node);
        }
        node.setNext(node.getNext().getNext());
        return list;
    }



    /**
     * 功能描述: 展示
     * @Author: zxc
     * @Date: 2020/7/22 22:43
     */
    public void display(linkerList list){
        Node node=list.getNode().getNext();
        while (node!=null){
            System.out.print(node.getText()+"=>");
            node=node.getNext();
        }
        System.out.println();
    }

    public static void main(String[] args) {
        options os=new options();
        linkerList list=new linkerList();

        os.createLinkedList(list);
        os.display(list);

        os.insert(list,"a",3);
//        os.insert(list,"b",2);
//        os.insert(list,"c",3);
//        os.insert(list,"d",4);
//        os.insert(list,"e",5);

        os.delete(list,2);
        os.display(list);
    }

}

    3. 静态链表

      就是用数组表示链表，

    • 常见操作

      1. 最值

        /**
 * 功能描述: 寻找最小值
 * @Author: zxc
 * @Date: 2020/7/23 13:47
 */
public int findMin(linkedList list){
    Node node=list.getNode().getNext();
    int min=Integer.parseInt(node.getText());
    while (node!=null){
        if (Integer.parseInt(node.getText())<min){
            min=Integer.parseInt(node.getText());
        }
        node=node.getNext();
    }
    return min;
}
/**
 * 功能描述: 寻找最大值
 * @Author: zxc
 * @Date: 2020/7/23 13:47
 */
public int findMax(linkedList list){
    Node node=list.getNode().getNext();
    int max=Integer.parseInt(node.getText());
    while (node!=null){
        if (Integer.parseInt(node.getText())>max){
            max=Integer.parseInt(node.getText());
        }
        node=node.getNext();
    }
    return max;
}

      2. 逆置

        /**
 * 功能描述: 逆置
 * @Author: zxc
 * @Date: 2020/7/23 14:16
 */
public void reserve(linkedList list){
    Node header=new Node();
    Node temp;
    Node node=list.getNode();
    while (node.getNext()!=null){
        temp=node.getNext();
        node.setNext(node.getNext().getNext());
        temp.setNext(header.getNext());
        header.setNext(temp);
    }
    list.setNode(header);
}

      3. 有序归并

        /**
 * 功能描述: 有序归并
 * @Author: zxc
 * @Date: 2020/7/23 14:32
 */
public linkedList orderlyMerging(linkedList l1,linkedList l2){
    linkedList re=new linkedList();
    Node n1=l1.getNode().getNext();
    Node n2=l2.getNode().getNext();
    Node n3=re.getNode();
    int s1=Integer.parseInt(l1.getNode().getText());
    int s2=Integer.parseInt(l2.getNode().getText());
    for (;n1!=null&&n2!=null;){
        if (Integer.parseInt(n1.getText())<Integer.parseInt(n2.getText())){
            n3.setNext(n1);
            n1=n1.getNext();
        }else{
            n3.setNext(n2);
            n2=n2.getNext();
        }
        n3=n3.getNext();
    }
    while(n1!=null){
        n3.setNext(n1);
        n1=n1.getNext();
    }
    while(n2!=null){
        n3.setNext(n2);
        n2=n2.getNext();
    }
    return re;
}
2. 栈

  • 定义

    只允许在一端进行拿/取的数据结构

在这里插入图片描述

  • 分类

    1. 顺序存储

      利用数组来实现顺序存储元素，再加上一个top指针指向栈顶元素，方便进行进栈、出栈的操作

      package com.zxc.stack.linear;

/**
 * 功能描述: 栈
 * @Author: zxc
 * @Date: 2020/7/24 10:56
 */
public class options {
    /**
     * 功能描述: 初始化顺序空栈
     * @Author: zxc
     * @Date: 2020/7/24 10:57
     */
    public void initStack(linearStack stack){
        stack.top=-1;
    }

    /**
     * 功能描述: 判断栈空
     * @Author: zxc
     * @Date: 2020/7/24 10:59
     */
    boolean stackEmpty(linearStack s){
        return s.top == -1;
    }

    /**
     * 功能描述: 进栈
     * @Author: zxc
     * @Date: 2020/7/24 11:01
     */
    boolean push(linearStack stack,int x){
        if (stack.top==stack.MAX_SIZE-1){
            return false;
        }
        stack.data[++stack.top]=x;
        return true;
    }

    /**
     * 功能描述: 出栈
     * @Author: zxc
     * @Date: 2020/7/24 11:09
     */
    public int pop(linearStack stack){
        if (stack.top==-1){
            return -1;
        }
        return stack.data[stack.top--];
    }
    /**
     * 功能描述: 展示
     * @Author: zxc
     * @Date: 2020/7/24 11:09
     */
    public void display(linearStack stack){
        for (int i = 0; i <= stack.top; i++) {
            System.out.print(stack.data[i]+"=>");
        }
        System.out.println();
    }
    /**
     * 功能描述: 获取栈顶元素
     * @Author: zxc
     * @Date: 2020/7/24 11:18
     */
    public int getTop(linearStack stack){
        return stack.data[stack.top];
    }


    public static void main(String[] args) {
        linearStack stack=new linearStack();
        options os=new options();
        os.initStack(stack);

        os.push(stack,1);
        System.out.println(os.getTop(stack));
        os.push(stack,2);
        os.push(stack,3);
        System.out.println(os.getTop(stack));
        os.push(stack,4);


        System.out.println(os.pop(stack));
        os.display(stack);
    }
}

      tips:共享栈 使用两个指针，相当于是将两个栈的栈底链接起来，能更有效的利用空间，就比如我们拿羽毛球 球桶，可以从底部拿出来

    在这里插入图片描述

    1. 链式存储

      和链表类似，但是没有头结点，指针直接指向了栈顶元素，方便进行栈顶的元素操作

在这里插入图片描述

3.队列

  • 定义

    可以简单理解为，只能在队列一端进行删除，另一端进行插入的表

  • 分类

    1. 顺序存储

      还是利用数组来进行实现，可以发现这个和之前讲的栈有点相像，只不过是多了一个队头的指针，
      （特别需要注意的是，front指针是队头指针 直接指向队头，rear是队尾指针 直接指向的是队尾元素的后一位，这是为了后续操作的方便性）

      在这里插入图片描述

    这里特别提出来一个问题，当我们不断地进行入栈出栈的操作后，front和rear会不断地被往后推移，最终会导致rear被推到数组的尾部，如下：

在这里插入图片描述

这就会有小伙伴说，直接判断它溢出不就解决了？当front处于很数组前几位时，的确可以，但是当front也被推送到数组尾部附近时，会造成前面大量空间的浪费（可以称为假溢出）。

为了解决这个问题，引出了循环队列。

也就是把存储队列的顺序队列逻辑上视为环，如下：

在这里插入图片描述

那么如何做呢？其实可以通过取余的操作

  • front指针移动

    （q.front+1）%MaxSize

  • rear指针移动

    （q.rear+1）%MaxSize

  • 队列长度

    (q.rear-q.front+MaxSize)%MaxSize

判断循环队列是否满/空

因为循环队列，所以队空和队满的情况变得一样，有以下几种解决办法：

  1. 牺牲一个存储单元

在这里插入图片描述

  1. 增加一个变量代表元素的个数

    也就是增加一个位置的数，表示队列所在的元素个数

  2. 增加tag标识

    因为 队列空 是由出队操作引起；

    ​ 队列满 是由入队操作引起；

    所以，我们针对操作后设置一个变量 tag标记该操作是入队还是出队

在这里插入图片描述

  1. 链式存储

    一般还是采用带有头结点的队列

tips:有可能的出栈和入栈序列，只需要尝试就好了

  1. 双端队列

    允许两端都允许出队和入队的操作

在这里插入图片描述

  • 相关应用

    1. 括号匹配：

在这里插入图片描述

  1. 表达式求值

在这里插入图片描述

 中缀转后缀，利用栈进行实现

在这里插入图片描述

4. 矩阵和数组

数组只需知道它的物理存储地址是连续存储的

下面重点介绍矩阵：

  • 定义

    矩阵可以简单的理解为二维数组

  • 压缩存储

    指多个值相同的元素只分配一个空间，对零元素不进行分配

    特殊矩阵 是指具有许多的相同矩阵元素或者零元素，且分布具有一定性的规律的矩阵

    特殊矩阵的分类：

    1. 对称矩阵

      对于矩阵中的任意元素，都有Aij=Aji
      在这里插入图片描述

      所以对称矩阵只需存储接近一半多一点的元素

    2. 三角矩阵

      对于一个矩阵，上三角或者下三角都是相同的元素，在这里插入图片描述

    3. 三对角矩阵

    4. 稀疏矩阵

      零元素是非常多的

在这里插入图片描述

5. 串

  • 定义

    是由0个或多个字符组成的有序序列，且以\0表示字符串截至

]

概念解释
子串在串中的任意个连续的字符

  • 分类

    1. 顺序存储

    2. 堆分配存储

    3. 块链存储

在这里插入图片描述

  • 串的匹配模式

  • KMP算法

矩阵：

  • 定义

    矩阵可以简单的理解为二维数组

  • 压缩存储

    指多个值相同的元素只分配一个空间，对零元素不进行分配

    特殊矩阵 是指具有许多的相同矩阵元素或者零元素，且分布具有一定性的规律的矩阵

    特殊矩阵的分类：

    1. 对称矩阵

      对于矩阵中的任意元素，都有Aij=Aji[外链图片转存中…(img-IEq5kujS-1595655913307)]

      所以对称矩阵只需存储接近一半多一点的元素

    2. 三角矩阵

      对于一个矩阵，上三角或者下三角都是相同的元素，[外链图片转存中…(img-Bnf6fbY6-1595655913308)]

    3. 三对角矩阵

    4. 稀疏矩阵

      零元素是非常多的

      [外链图片转存中…(img-5BqUA0Cl-1595655913309)]

5. 串

  • 定义

    是由0个或多个字符组成的有序序列，且以\0表示字符串截至

    [外链图片转存中…(img-QFMAEXy8-1595655913310)]

    概念解释
    子串在串中的任意个连续的字符

  • 分类

    1. 顺序存储

    2. 堆分配存储

    3. 块链存储

      [外链图片转存中…(img-rtnrjzF0-1595655913311)]

  • 串的匹配模式

  • KMP算法

6.树

----------------------------------------------------- 在更

多喝热水z
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
稀疏矩阵（十字链表操作）
05-08
数据结构稀疏矩阵实验课程设计 /********function definition********/ int init_matrix(crosslist &one) {//initialization one.row_size=0; one.colum_size=0; one.non_zero_amount=0; one.rhead=NULL; one.chead=NULL; return OK; }//init_matrix int creat_matrix(crosslist &one) {//assignment int i;//as count in the loop element news,temp; /*input row size ,colum size and non zero amount*/ printf("Input the row size of the matrix:"); scanf("%d",&one.row_size); printf("Input the colum size of the matrix:"); scanf("%d",&one.colum_size); printf("Input the non zero amount of the matrix:"); scanf("%d",&one.non_zero_amount); /*allocate memory and the first memory not use*/ one.rhead=(element*)malloc(sizeof(element)*(one.row_size+1)); assert(one.rhead!=NULL);//assert have space one.chead=(element*)malloc(sizeof(element)*(one.colum_size+1)); assert(one.chead!=NULL); /*set all the pointer to NULL*/ for(i=1;i<=one.row_size;i++) one.rhead[i]=NULL; for(i=1;i<=one.colum_size;i++) one.chead[i]=NULL; printf("/**************************************/\n"); /*assignment*/ for(i=1;irow); }while(news->row>one.row_size); do {//insure the colum script is valid printf("Input the script of the colum:"); scanf("%d",&news->colum);
数据结构(链表、链栈、链队列、二叉树、图)
热门推荐
attitude_yu
05-02 1万+
本文用于总结数据结构(链表、链栈、链队列、二叉树、图)的创建方式与遍历方式！！！ 本目录代码已上传至github中！！！ 1. 链表 1. 线性表顺序存储和链式存储的优缺点？ 顺序存储： a.不需要增加额外的存储空间，快速存取指向位置的元素； b.在插入和删除过程中，需要移动大量元素； c.需要预先分配存储空间； 链式存储： a.插入删除操作时间为O(1); b.用任意位置的存储单元存...
数据结构——网状关系
最新发布
m0_72168217的博客
03-12 1888
佛洛依德算法 十字链表法
Python的链表、树、图等数据结构
yangzixuan_0608的博客
12-02 878
一、python实现链表，并实现链表的增删改查 1、python中没有现成的这种数据类型，所以我们需要实现一个Node类来定义这种数据结构 2、定义SinCycLinkedlist作为链表的构造类，可以实现链表的增删改查； #!/usr/bin/env python # -*- coding: utf-8 -*- class Node: def __init__(self, ini...
数据结构 串 树
qq_29258361的博客
03-08 468
串的模式匹配：KMP树：完全二叉树--按顺序排列节点，叶子节点只可能出现在最下面两层。叶子结点数= 度为二的节点数加1顺序存储这种一对多的关系会有不变，使用链式存储二叉链表：一个节点有一个左孩子指针，一个右孩子指针。遍历： 前序遍历---根左右          中序遍历：左根右          后序遍历：左右根线索二叉树：指向前驱和后继指针加上。设立ltag 和rtag，当值为0 时指向该节点...
数据结构知识点(链表、递归、树图)
fengel_cs的专栏
03-21 643
1. 数据结构与算法 一个可执行的程序分为数据的存储，数据的操作，能被计算机识别的程序语言。 数据的存储分为个体的存储和个体与个体关系的存储，个体的存储可以忽略(比如存储器存储)，个体与个体关系的存储即数据结构，个体与个体关系存储不一样，数据的操作也就不一样(泛型除外)。 数据的操作也就是算法，算法分为狭义算法和广义算法，狭义算法是与数据的存储方式密切相关；广义算法与数据的存储方式无关，比如...
数据结构综合课设稀疏矩阵的完全链表表示及其运算.docx
03-26
2、输入要求：的数据在程序运行的时候由用户提供，先由用户输入稀疏矩阵的行数、列数和非零元个数。再根据非零元个数，输入这些非零元，还需要用户为这些非零元输入行、列和非零元的值。这样，一个稀疏矩阵就输入...
Java数据结构之稀疏矩阵定义与用法示例
08-28
主要介绍了Java数据结构之稀疏矩阵定义与用法,结合实例形式分析了java稀疏矩阵的定义、运算、转换等相关操作技巧,需要的朋友可以参考下
数据结构（严蔚敏_吴伟民）【可运行课程代码】
02-18
本资源为《数据结构（严蔚敏_吴伟民）》一书的【课程代码】（敲黑板，并不是电子书），共有45个实验的代码，所有代码均可执行（并含有20%代码注释），代码风格和... 例如排序算法、字符串、链表、树、图、稀疏矩阵等
数据结构 采用十字链表表示稀疏矩阵
01-17
采用十字链表表示稀疏矩阵，并实现矩阵的乘法运算 要求：要检查有关运算的条件，并对错误的条件报警。
数据结构总结（自学、期末复习或考研备用）.pdf
01-16
第一章绪论、算法衡量指标、第二章线性表、顺序表、链表、第三章栈和队、栈、栈的应用举例、队列、循环队列、第四章串、串的模式匹配、第五章数组和广义表、稀疏矩阵的压缩存储方法:、广义表、第六章树和二叉树、...
图的搜索，数据结构有关系矩阵和边链表两种，
05-14
我自己写的图的遍历，有边链表和关系矩阵两种 分别是用到栈和队列两种辅助存储
矩阵链表（Matrix Chain Multiplication）
unclever_mine的博客
03-13 660
#include &lt;iostream&gt;#include&lt;vector&gt;#include&lt;map&gt;#include&lt;string&gt;#include&lt;algorithm&gt;#include&lt;cstdio&gt;#include&lt;stack&gt;using namespace std;//#define LOCALstruct Ma
数据结构 顺序表与链表
qq_38362049的博客
07-13 305
数据元素是数据的基本单位 数据元素不能再分 原子项 数据元素可以再分 组合项若干数据项组成一个数据元素数据项是数据的最小单位算法 ：有穷性 确切性 输入项 输出项 可行性时间复杂度 ： O（1） O（logn） O（n） O（nlogn）O（n2）O（n3）O（2n）O（n！）线性表中所有元素的数据类型都是相同的一：综述程序 = 算法 + 数据结构数据结构 = 结构定义 + 结构操作*1.顺序...
用链表实现矩阵的逆置，旋转（简单创新解法）
JamieJi的博客
03-28 684
正常实现矩阵的变换我们都是通过将矩阵通过二维数组的方式存储，在输出端控制好输出的内容来实现矩阵的相应变换，并不会改变数组的存放。但当题目要求使用链表而不是数组方式存储时，题目就会变难很多。 但本文提出一种思想将链表标上数组的序号即可讲问题简单化 在构建结构体时多设两个整型变量x，y来标号 typedef struct LNode{ int x; int y; int data; struc...
【数据结构】链表总结
weixin_62357106的博客
02-06 546
链表的知识总结
十字链表表示矩阵c语言,十字链表的定义及C语言描述
weixin_33454551的博客
05-21 501
十字链表常用于表示稀疏矩阵，可视作稀疏矩阵的一种链式表示，因此，这里以稀疏矩阵为背景介绍十字链表。不过，十字链表的应用远不止稀疏矩阵，一切具有正交关系的结构，都可用十字链表存储。1、存储方式(a)稀疏矩阵中每个非0元素对应一个十字链表结点，每个结点的结构为 其中各字段的含意为：row──元素在稀疏矩阵中的行号col──元素在稀疏矩阵中的列号val──元素值down──指向同列中下一个非0元素结点r...
D3 v4.x入门（1-13）—— 矩阵树图探究
我不是水哥
08-15 3372
 矩阵树图和之前的区域分布图其实有点像，看图说话~   相比于区域分布，矩阵树图多个了纬度叫做权重，括号里的数值就是权重，权重越大，占的区域越大。源码如下。 关于这个系列有什么想要讨论的问题可以+Q 380205984 发邮件什么的我一般都懒得回，QQ邮件的打开速度太慢了~ &lt;template&gt; &lt;div id='svgContainer' style=""&gt;...
多重链表表示矩阵中，为什么可以说第i行的head和第i列的head实际上是同一个结点？
Zlucien的博客
03-10 1411
最近在复习数据结构与算法，准备好好看看这块的内容，看网课，老师的ppt中有个题目是这个。在网上查了答案，也有自己的点理解： 是这样的，我们假设每个Head节点的Down域是左面的，Right是右面的，当然中间的叫MId。 这是我们会发现在每一个Head行节点的Right总是指向每一行的Term节点，这个时候Down没有利用。 同理，每一个Head列节点总是指向每一列的Term节点，...
数据结构稀疏矩阵十字链表
08-14
稀疏矩阵十字链表是一种用于表示稀疏矩阵的数据结构。在稀疏矩阵中，大部分元素都是0，只有少数非零元素。这种情况下，使用二维数组来存储整个矩阵会浪费大量的空间。 稀疏矩阵十字链表通过使用链表的方式来存储非零元素，从而节省空间。它将矩阵分为两个链表：行链表和列链表。每个非零元素都用一个节点表示，并且该节点包含了元素的值、所在的行号和列号，以及分别指向同一行和同一列中下一个非零元素的指针。 这种数据结构的优点是能够高效地进行稀疏矩阵的插入、删除和查找操作，同时节省了存储空间。不过，由于需要维护两个链表，所以在更新操作时需要更多的时间和空间开销。 你还有其他关于稀疏矩阵十字链表的问题吗？

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值