数据结构-串、数组、广义表

最新推荐文章于 2024-07-25 02:49:15 发布
最新推荐文章于 2024-07-25 02:49:15 发布
阅读量651 收藏 5
点赞数
分类专栏： XDOJ全网最全 文章标签： 数据结构 算法 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Phage17/article/details/127347797
版权

串、数组、广义表


懒。

XDOJ0224 矩阵相乘

在这里插入图片描述

//xdoj0224.cpp
#include<cstdio>
using namespace std;
//A矩阵2行3列，B矩阵3行2列
int** MartixMultiply(int A[][3],int B[][2],int r,int c){
​
    int **C=new int*[r];
    for(int i=0;i<r;++i){
        C[i]=new int[c];
    }
​
    for(int i=0;i<r;++i){
        for(int j=0;j<c;++j){
            C[i][j]=0;
            for(int k=0;k<c;++k){
                C[i][j]+=A[i][k]*B[k][j];
            }
        }
    }
    return C;
}
int main(){
    int A[2][3];
    int B[3][2];
    for(int i=0;i<2;++i){
        for(int j=0;j<3;++j){
            scanf("%d",&A[i][j]);
        }
    }
    for(int i=0;i<3;++i){
        for(int j=0;j<2;++j){
            scanf("%d",&B[i][j]);
        }
    }
​
    int** C=MartixMultiply(A,B,2,3);
​
    for(int i=0;i<2;++i){
        for(int j=0;j<2;++j){
            printf("%d ",C[i][j]);
        }
        printf("\n");
    }
    return 0;
}

XDOJ0250 螺旋填数

在这里插入图片描述

//xdoj0250.cpp
//xdoj0250.c
#include<stdio.h>
int main(){
    int nums[100][100]={0},n,m,count=1,r=0,c=0;
    scanf("%d%d",&n,&m);
    int total=n*m;
    //四个边界 Right Left Up Down
    int Rlimit=m,Llimit=0,Ulimit=0,Dlimit=n;
​
    //理解为n次螺旋填数，每次填完，边界缩小
    while(count<=total){
        while(c<Rlimit){
            nums[r][c++]=count++;
        }c--;r++;
​
        while(r<Dlimit){
            nums[r++][c]=count++;
        }r--;c--;
​
        while(c>=Llimit){
            nums[r][c--]=count++;
        }c++;r--;
​
        while(r>Ulimit){
            nums[r--][c]=count++;
        }r++;c++;
​
        //每次螺旋之后，边界缩小
        Rlimit--;Llimit++;Ulimit++;Dlimit--;
    }
​
    //输出
    for(int i=0;i<n;i++){
        for(int j=0;j<m;j++){
            printf("%d ",nums[i][j]);
        }
        printf("\n");
    }
​
    return 0;
}

XDOJ0257 公共子串

在这里插入图片描述

//xdoj0257.cpp
//最长公共子串，并计算相似度
/*  注意有空格输入，他妈的
    s h i t o
m   0 0 0 0 0
i   0 0 1 0 0
t   0 0 0 2 0
m   0 0 0 0 0
i   0 0 1 0 0
t   0 0 0 2 0
o   0 0 0 0 3
LCS等价于max，每次给矩阵赋值就刷新一下
*/
#include<cstdio>
#include<iostream>
#include<string>
using namespace std;
int main(){
    int Martix[100][100];
    int LCS=0;
    string S1;
    string S2;
    getline(cin,S1);
    getline(cin,S2);
    int l1=S1.length();
    int l2=S2.length();
    for(int i=0;i<l1;++i){
        if(S1.at(i)>=65 && S1.at(i)<=90){
            S1.at(i)+=32;//是大写字母就改为小写
        }
    }
    for(int i=0;i<l2;++i){
        if(S2.at(i)>=65 && S2.at(i)<=90){
            S2.at(i)+=32;//是大写字母就改为小写
        }
    }
    for(int i=0;i<l2;++i){//i操作s2
        for(int j=0;j<l1;++j){//j操作s1
            if(S2.at(i)==S1.at(j)){
                //字符匹配上了
                if(i==0||j==0){
                    //如果是矩阵的边界，则直接赋值1
                    Martix[i][j]=1;
​
                    if(LCS<Martix[i][j]){
                        LCS=Martix[i][j];//刷新最大值
                    }
                }else{
                    //对角线加1
                    Martix[i][j]=Martix[i-1][j-1]+1;
​
                    if(LCS<Martix[i][j]){
                        LCS=Martix[i][j];//刷新最大值
                    }
                }
            }else{
                //不一样
                Martix[i][j]=0;
            }
        }
    }
    cout<<LCS<<endl;
    //记得三位小数
    printf("%.3lf",2*(double)LCS/(l1+l2));
​
    return 0;
}

XDOJ0287 求矩阵中的马鞍点

在这里插入图片描述

//xdoj0287.cpp
#include<iostream>
#include<vector>
#include<cstdlib>
using namespace std;
//min: 2 0 8 4
//max: 8 23 13 18
typedef struct Node{
    int i,j,value;
}Node;
int main(){
    int n,m,input[100][100],i=0,j=0,flag=0;//i,j操作，flag标记是否有马鞍点，默认没有
    vector<Node>min;
    vector<Node>max;
    Node* t=(Node*)malloc(sizeof(Node));//临时结点t，用于存贮三元组
    //输入部分 m是行，n是列，但是xdoj给的不清不楚，纯sb
    cin>>m>>n;
    for(i=0;i<m;++i){
        for(j=0;j<n;++j){
            cin>>input[i][j];
        }
    }
    //先按行查找每一行的最小值，把每一行的最小值入min
    for(i=0;i<m;++i){
        t->value=input[i][0];
        t->i=i+1;//在这里赋值，防止第一个就是最小值，导致ij未赋值
        for(j=1,t->j=j;j<n;++j){//t->j=j,不用加一，因为j赋值为1了
            if(t->value>input[i][j]){
                t->value=input[i][j];
                t->i=i+1;
                t->j=j+1;
            }
        }
        min.push_back(*t);
    }
    //再按列查找每一列的最大值，把每一列的最大值入max
    for(i=0;i<n;++i){
        t->value=input[0][i];
        t->j=i+1;//在这里赋值，防止第一个就是最大值，导致ij未赋值
        for(j=1,t->i=j;j<m;++j){
            if(t->value<input[j][i]){
                t->value=input[j][i];
                t->i=j+1;
                t->j=i+1;//注意这里反了一下
            }
        }
        max.push_back(*t);
    }
    //优先行来找马鞍点,也就是min先遍历,先遍历的在内层循环
    for(i=0;i<max.size();++i){//i操作max，j操作min
        for(j=0;j<min.size();++j){
            if(min.at(j).i==max.at(i).i && min.at(j).j==max.at(i).j && min.at(j).value==max.at(i).value){
                //结点相同，则符合马鞍点的定义
                cout<<min.at(j).i<<' '<<min.at(j).j<<' '<<min.at(j).value<<endl;
                flag=1;//输出过，说明有马鞍点
            }
        }
    }
    if(flag==0){
        cout<<"NO";
    }
    return 0;
}

XDOJ0288 求一个顺序串的next函数值

在这里插入图片描述

//xdoj0288.cpp
#include<iostream>
using namespace std;
//注意下面这个next函数是根据一般的情况来的，也就是从1数起，第一二个固定是0，1
//题目是从0数，第一二个固定是-1，0，只要最后输出减一就行了
void Next(char* T,int* next,int Tlength){
    next[1]=0;
    next[2]=1;
    int i=2;
    int j=1;
    while(i<Tlength){
        if(j==0||T[i-1]==T[j-1]){
            ++i;
            ++j;
            next[i]=j;
        }else{
            j=next[j];
        }
    }
}
​
int main(){
    int n,next[100];
    char T[100];
    cin>>n;
    for(int i=0;i<n;++i){
        cin>>T[i];
    }
    Next(T,next,n);
    for(int i=1;i<=n;++i){
        cout<<next[i]-1<<' ';
    }
    return 0;
}

XDOJ0296 中心对称的字符串

在这里插入图片描述

//xdoj0296.cpp
#include<iostream>
using namespace std;
int main(){
    int n;
    char str[100];
    cin>>n;
    for(int i=0;i<n;++i){
        cin>>str[i];
    }
    int i=0,j=n-1;
    while(i<n/2){
        if(str[i++]!=str[j--]){
            cout<<"NO";
            return 0;
        }
    }
    cout<<"YES";
    return 0;
}

XDOJ0309 矩阵加法运算

在这里插入图片描述

//xdoj0309.cpp
#include<iostream>
#include<list>
#include<cstdlib>
using namespace std;
typedef struct Node{
    int x,y,v;
}Node;
list<Node>B1;
list<Node>B2;
list<Node>B;
​
void MartixAdd(){
    //B用于存储结果 按照行小的先压入， 总体分为行相等，行1大，行2大
    list<Node>::iterator p1=B1.begin();
    list<Node>::iterator p2=B2.begin();
​
    while(p1!=B1.end() && p2!=B2.end()){
        //遍历俩个链表
        if(p1->x==p2->x){
            if(p1->y == p2->y){
                //坐标相同，实行相加
                if(p1->v + p2->v == 0){
                    //坐标相同，但是和为0，故无视
                    ;
                }else{
                    //和不为0，压入B
                    Node* s=(Node*)malloc(sizeof(Node));
                    s->x=p1->x;
                    s->y=p1->y;
                    s->v=p1->v+p2->v;
                    B.push_back(*s);
                }
                //坐标一样，俩迭代器都后移
                ++p1;
                ++p2;
            }else if(p1->y > p2->y){
                //列小的压入
                B.push_back(*p2);
                ++p2;
            }else if(p1->y < p2->y){
                B.push_back(*p1);
                ++p1;
            }
        }else if(p1->x > p2->x){
            //B1结点行比B2当前结点行 大，先入B2的结点
            B.push_back(*p2);
            ++p2;
        }else if(p1->x < p2->x){
            //入p1结点
            B.push_back(*p1);
            ++p1;
        }
    }//while
    //没完，可能有一个没遍历完
    if(p1==B1.end() && p2==B2.end()){
        //都遍历完，则返回
        return;
    }else{
        if(p1==B1.end()){
            while(p2!=B2.end()){
                B.push_back(*p2);
                ++p2;
            }
        }else if(p2==B2.end()){
            while(p1!=B1.end()){
                B.push_back(*p1);
                ++p1;
            }
        }
        return;
    }
}
​
int main(){
    int n,m,t;
    
    list<Node>::iterator p1;//p1迭代器遍历B1
    list<Node>::iterator p2;
    list<Node>::iterator p3;
    cin>>n>>m;
​
    //输入部分
    for(int i=0;i<n;++i){
        for(int j=0;j<m;++j){
            cin>>t;
            if(t==1){
                Node* s=(Node*)malloc(sizeof(Node));
                s->x=i;
                s->y=j;
​
                B1.push_back(*s);
            }
        }
    }
    for(p1=B1.begin();p1!=B1.end();p1++){
        cin>>t;
        (*p1).v=t;
    }
​
    for(int i=0;i<n;++i){
        for(int j=0;j<m;++j){
            cin>>t;
            if(t==1){
                Node* s=(Node*)malloc(sizeof(Node));
                s->x=i;
                s->y=j;
​
                B2.push_back(*s);
            }
        }
    }
    for(p2=B2.begin();p2!=B2.end();p2++){
        cin>>t;
        (*p2).v=t;
    }
​
    //处理部分，相当于俩个链表x，y相同的运算，不同的合并，类似多项式加法
    MartixAdd();
​
    p3=B.begin();
    for(int i=0;i<n;++i){
        for(int j=0;j<m;++j){
            if(p3==B.end()){
                cout<<"0 ";
                continue;
            }else{
                if(i==p3->x&&j==p3->y){
                    cout<<"1 ";
                    ++p3;
                }else{
                    cout<<"0 ";
                }
            }
        }
        cout<<endl;
    }
    p3=B.begin();
    while(p3!=B.end()){
        cout<<p3->v<<' ';
        ++p3;
    }
​
    return 0;
}
Iamnotphage
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构之数组，串，广义表
jcjbusbjk的博客
06-07 60
Loc(i,j,k)的计算 特殊矩阵存储 存储对称方阵时最多只需存储n(n+1)/2个元素 下三角矩阵： Loc(i,j)=(i+1)∗i/2+jLoc(i,j)=(i+1)*i/2+jLoc(i,j)=(i+1)∗i/2+j 上三角矩阵： Loc(i,j)=n+(n−1)+(n−2)+...+(n−i+1)Loc(i,j)=n+(n-1)+(n-2)+...+(n-i+1)Loc(i,j)=n+(n−1)+(n−2)+...+(n−i+1) =(2n−i−1)∗i/2+j=(2n-i-1)*i/2+j=(
数据结构——数组、广义表
m0_56046092的博客
08-18 212
数组 特点 数组的特点：结构固定，定义后维数和维界不变。数组可以是多维，但存储空间是一维的，所以重点在解决映射关系。注意数组中元素位置的计算。 三维数组按页优先的顺序存储 特殊矩阵的压缩存储 1.对称矩阵压缩为只用存储下/下三角（包括对角线元素） 个元素←→ n(n+1)/2元素 a[i][j] ←→ b[k]数组下标0开始 2.三角矩阵的压缩 n²个元素←→ n(n+1)/2+1元素,常数c共享一个元素存储空间故+1 3.对角矩阵的压缩存储 当b＝1时称为三对角矩阵。其压缩地址计算公式如下：k=2
数据结构：串、数组和广义表
qq_63042305的博客
10-17 1565
学习数据结构后总结了串，数组和广义表的基础内容,如存储结构，和相关的基本算法（如KMP算法与BF算法）
第四章 串、数组和广义表
weixin_42705436的博客
11-17 389
一、串的定义和实现 1.串的定义 串——零个和任意多个字符组成的有限序列称为串。 计算机上非数值处理的对象基本都是字符串 串相等：串长度相等，对应位置字符都相等。 2.串的顺序存储 类似于线性表的顺序存储结构，用一组地址连续的存储单元存储串值的字符序列。按照预定义的大小，为每个预定义的串变量分配一个固定长度的存储区。 #define MAXLEN 255 typedef struct{ char ch[MAXLEN+1]; int length; }SString; 3.串的链式存储 顺序串的插入和删
《数据结构》-第四章 串、数组和广义表(知识点总结)
大家一起进步叭
07-29 5755
第四章 串、数组和广义表 本章对串、数组和广义表这几类特殊的线性表进行讨论，也可看做为线性表的扩充。串的特殊性体现在数据元素是一个字符，即是内容受限的线性表，数组与广义表的特殊性为线性表的数据元素自身又是一个数据结构。 对于应试，本章内容较为容易掌握，相对于其他章节所占比分较少，往往以选择或填空题出现，对算法题目主要出现在对BF算法和KMP算法理解上。 【考点】①串的重点考点为串的模式匹配算法； ②数组的主要考点为数组下标与存储地址计算和特殊矩阵的压缩存储...
串、数组和广义表
Hyh的博客
03-23 487
串 串中元素逻辑关系与线性表相同，串可以采用与线性表相同的存储结构。 顺序存储结构：顺序串 链式存储结构：链串 串的顺序存储结构 //串的顺序存储结构 #define MAXLEN 255 typedef struct{ char ch[MAXLEN + 1]; //存储串的一维数组 int length; //串的当前长度 }SString; ...
数据结构-串、数组和广义表-PPT
02-04
"数据结构-串、数组和广义表-PPT" 本节，我们将详细介绍数据结构中串、数组和广义表的定义、特点和操作。 串的定义 串是一种特殊的线性表，其特殊性体现在数据元素是一个字符，也就是说，串是一种内容受限的...
数据结构实验报告-数组和广义表.doc
10-10
数据结构实验报告-数组和广义表.doc
数据结构-数组与广义表.ppt
07-11
本章主要讨论了两种特定的数据结构：数组和广义表。这两种结构都是线性表的扩展，允许更复杂的数据组织。 数组是一种基本的数据结构，它由n（n>1）个相同数据类型的元素组成，这些元素在内存中占据连续的地址空间。...
数据结构 串、数组和广义表 专讲
12-22
计算机上的非数值处理对象基本上是字符串数据。在较早的程序设计语言中,字符串是作为... 数组和广义表是与线性表有所区别的数据结构。它们可以看成是线性表在下述含义上的扩展:线性表中的元素本身也是一个数据结构。
数据结构-C语言版：DS05-数组和广义表.ppt
06-06
数据结构-C语言版：DS05-数组和广义表.ppt
数据结构_练习 第4章 串、数组和广义表
热门推荐
Cynical丶Gary_博客
01-08 3万+
1．选择题 （1）串是一种特殊的线性表，其特殊性体现在（  ）。   A．可以顺序存储               B．数据元素是一个字符       C．可以链式存储               D．数据元素可以是多个字符若 答案：B （2）串下面关于串的的叙述中，（  ）是不正确的？  A．串是字符的有限序列          B．空串是由空格构成的串 C
基本数据结构（数组、串、广义表）
LinJM-机器视觉
12-26 2889
数组 多维数组的概念与存储 二维数组也可叫做矩阵，它可以看作是由n个行向量和m个列向量所组成的向量，a[n][m]，总共n*m个数组元素。 对于二维数组a[n][m]，为能根据它的数组元素的下标得出在相应一维数组中对应的下标，需要区分2种存储方式，即行优先顺序和列优先顺序。 特殊矩阵压缩存储 对称矩阵 三角矩阵 对角矩阵 稀疏矩阵 稀疏矩阵（sparse matrix）是矩阵中的一种特殊情况，其非零元素的个数远远小于零元素的个数。 只存储矩阵中极少数的非零元素<row,column, value> 稀疏矩阵
数据结构串、数组和广义表
chongyang_的博客
11-08 1万+
文章目录四、串、数组和广义表4.1、串的定义4.2、案例引入4.3、串的类型定义、存储结构及其运算4.3.1、串的抽象类型定义4.3.2、串的存储结构4.3.3、串的模式匹配算法4.4、数组4.5、广义表第四章小结第四章习题 四、串、数组和广义表 4.1、串的定义 串即字符串，是由零个或多个字符组成的有限序列，是数据元素为单个字符的特殊线性表。 串是内容受限的线性表,它限定了表中的元素为字符 串长：串中字符个数（n≥0）. n=0 时称为空串 空白串：由一个或多个空格符组成的串 子串：串S中任意个连续.
串、数组、广义表 知识点总结
l218623的博客
02-08 3048
目录 串 串的定义 相关概念 空串与空格串的区别 串的类型定义 串的存储结构 存储密度的计算 数组 数组特点 数组的基本操作 数组的抽象数据类型 数组基本操作: 二维数组 二维数组元素位置的计算 三维数组 三维数组元素位置的计算 n维数组元素位置的计算 特殊矩阵的压缩存取 压缩对象：一些特殊矩阵，如:对称矩阵，对角矩阵，三角矩阵，稀疏矩阵等。对...
数据结构--串、数组、广义表
qq_46338854的博客
05-09 753
串 串（String）:零个或多个任意字符组成的有限序列 空串用∅表示 子串：一个串中任意个连续字符组成的子序列（含空串）称为该串的子串 真子串是指不包含自身的所有子串 几个术语 子串：串中任意个连续字符组成的子序列称为该串的子串 主串：包含子串的串相应的称为主串 字符位置：字符在序列中的序号为该字符在串中的位置 子串位置：子串第一个字符在主串中的位置 空格串：由一个或多个空格组成的串，与空串不同 串相等：当且仅当两个串的长度相等并且各个对应位置上的字符都相同时，这两个串才是相等的。 串的顺序存储结
串、数组、广义表（详细）
z_h666的博客
08-16 1359
串、数组、广义表 串 串的定义和特点 定义 零个或多个任意字符组成的有限序列 有关术语 子串：一个串中任意个连续字符串组成的子序列（含空串） 真子串：指不包含自身的所有子串 主串：包含子串的串相应地称为主串 字符位置：字符在序列中的序号为该字符在串中的位置 子串位置：子串第一个字符在主串中的位置 空格串：有一个或多个空格组成的串 串相等：当且仅当两个串的长度相等并且各个对应位置上的字符都相等 串的操作 串的存储 串中元素逻辑关系与线性表相同，可以采用顺序和链式 串的顺序存储结构（数组
数据结构(5.3_3)——由遍历序列构造二叉树
最新发布
m0_65240792的博客
07-25 166
若只给出一棵二叉树的前/中/后/层 序遍历序列中的一种，不能唯一确定一棵二叉树 例：前序遍历序列：DAEFBCHGI 中序遍历序列：DAEFBCHGI
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值