精华内容
下载资源
问答
  • 串存储结构及其实现

    千次阅读 2019-03-15 09:39:10
    数据结构中,字符串要单独用一种存储结构来存储,称为串存储结构。这里的串指的就是字符串。 严格意义上讲,串存储结构也是一种线性存储结构,因为字符串中的字符之间也具有"一对一"的逻辑关系。只不过,...

    本文转自: http://data.biancheng.net/view/175.html

    介绍

    数据结构中,字符串要单独用一种存储结构来存储,称为串存储结构。这里的串指的就是字符串。

    严格意义上讲,串存储结构也是一种线性存储结构,因为字符串中的字符之间也具有"一对一"的逻辑关系。只不过,与之前所学的线性存储结构不同,串结构只用于存储字符类型的数据。

    数据结构中,根据串中存储字符的数量及特点,对一些特殊的串进行了命名,比如说:

    • 空串:存储 0 个字符的串,例如 S = “”(双引号紧挨着);
    • 空格串:只包含空格字符的串,例如 S = " "(双引号包含 5 个空格);
    • 子串和主串:假设有两个串 a 和 b,如果 a 中可以找到几个连续字符组成的串与 b 完全相同,则称 a 是 b 的主串,b 是 a 的子串。例如,若 a = “shujujiegou”,b = “shuju”,由于 a 中也包含 “shuju”,因此串 a 和串 b 是主串和子串的关系;

    需要注意的是,空格串和空串不同,空格串中含有字符,只是都是空格而已。另外,只有串 b 整体出现在串 a 中,才能说 b 是 a 的子串,比如 “shujiejugou” 和 “shuju” 就不是主串和子串的关系。

    另外,对于具有主串和子串关系的两个串,通常会让你用算法找到子串在主串的位置。子串在主串中的位置,指的是子串首个字符在主串中的位置。

    例如,串 a = “shujujiegou”,串 b = “jiegou”,通过观察,可以判断 a 和 b 是主串和子串的关系,同时子串 b 位于主串 a 中第 6 的位置,因为在串 a 中,串 b 首字符 ‘j’ 的位置是 6。

    串存储结构的具体实现

    存储一个字符串,数据结构包含以下 3 种具体存储结构:

    • 定长顺序存储:实际上就是用普通数组(又称静态数组)存储。例如 C 语言使用普通数据存储字符串的代码为 char a[20] = “data.biancheng.net”;
    • 堆分配存储:用动态数组存储字符串;
    • 块链存储:用链表存储字符串;

    定长顺序存储结构

    顺序存储结构(顺序表)的底层实现用的是数组,根据创建方式的不同,数组又可分为静态数组和动态数组,因此顺序存储结构的具体实现其实有两种方式。

    通常所说的数组都指的是静态数组,如 str[10],静态数组的长度是固定的。与静态数组相对应的,还有动态数组,它使用 malloc 和 free 函数动态申请和释放空间,因此动态数组的长度是可变的。

    串的定长顺序存储结构,可以简单地理解为采用 “固定长度的顺序存储结构” 来存储字符串,因此限定了其底层实现只能使用静态数组

    使用定长顺序存储结构存储字符串时,需结合目标字符串的长度,预先申请足够大的内存空间。

    例如,采用定长顺序存储结构存储 “data.biancheng.net”,通过目测得知此字符串长度为 18(不包含结束符 ‘\0’),因此我们申请的数组空间长度至少为 18,用 C 语言表示为:

    char str[18] = "data.biancheng.net";
    

    下面这段 C 语言代码给大家完美地展示了使用定长顺序存储结构存储字符串:

    #include<stdio.h>
    int main()
    {
        char str[20]="data.biancheng.net";
        printf("%s\n",str);
        return 0;
    }
    

    堆分配存储结构

    串的堆分配存储,其具体实现方式是采用动态数组存储字符串。

    通常,编程语言会将程序占有的内存空间分成多个不同的区域,程序包含的数据会被分门别类并存储到对应的区域。拿 C 语言来说,程序会将内存分为 4 个区域,分别为堆区、栈区、数据区和代码区,其中的堆区是本节所关注的。

    与其他区域不同,堆区的内存空间需要程序员手动使用 malloc 函数申请,并且在不用后要手动通过 free 函数将其释放。

    C 语言中使用 malloc 函数最多的场景是给数组分配空间,这类数组称为动态数组。例如:

    char * a = (char*)malloc(5*sizeof(char));
    

    此行代码创建了一个动态数组 a,通过使用 malloc 申请了 5 个 char 类型大小的堆存储空间。

    动态数组相比普通数组(静态数组)的优势是长度可变,换句话说,根据需要动态数组可额外申请更多的堆空间(使用 relloc 函数):

    a = (char*)realloc(a, 10*sizeof(char));
    

    通过使用这行代码,之前具有 5 个 char 型存储空间的动态数组,其容量扩大为可存储 10 个 char 型数据。

    下面给大家举一个完整的示例,以便对串的堆分配存储有更清楚地认识。该程序可实现将两个串(“data.bian” 和 “cheng.net”)合并为一个串:

    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    int main()
    {
        char * a1 = NULL;
        char * a2 = NULL;
        a1 = (char*)malloc(10 * sizeof(char));
        strcpy(a1, "data.bian");//将字符串"data.bian"复制给a1
        a2 = (char*)malloc(10 * sizeof(char));
        strcpy(a2, "cheng.net");
        int lengthA1 = strlen(a1);//a1串的长度
        int lengthA2 = strlen(a2);//a2串的长度
        //尝试将合并的串存储在 a1 中,如果 a1 空间不够,则用realloc动态申请
        if (lengthA1 < lengthA1 + lengthA2) {
            a1 = (char*)realloc(a1, (lengthA1 + lengthA2+1) * sizeof(char));
        }
        //合并两个串到 a1 中
        for (int i = lengthA1; i < lengthA1 + lengthA2; i++) {
            a1[i] = a2[i - lengthA1];
        }
        //串的末尾要添加 \0,避免出错
        a1[lengthA1 + lengthA2] = '\0';
        printf("%s", a1);
        //用完动态数组要立即释放
        free(a1);
        free(a2);
        return 0;
    }
    

    注意,程序中给 a1 和 a2 赋值时,使用了 strcpy 复制函数。这里不能直接用 a1 =“data.biancheng”,程序编译会出错,报错信息为 “没有 malloc 的空间不能 free”。因为 strcpy 函数是将字符串复制到申请的存储空间中,而直接赋值是字符串存储在别的内存空间(本身是一个常量,放在数据区)中,更改了指针 a1 和 a2 的指向,也就是说,之前动态申请的存储空间虽然申请了,结果还没用呢就丢了。

    块链存储结构

    串的块链存储,指的是使用链表结构存储字符串。

    本节实现串的块链存储使用的是无头节点的单链表。当然根据实际需要,你也可以自行决定所用链表的结构(双向链表还是单链表,有无头节点)。

    我们知道,单链表中的 “单” 强调的仅仅是链表各个节点只能有一个指针,并没有限制数据域中存储数据的具体个数。因此在设计链表节点的结构时,可以令各节点存储多个数据。

    在这里插入图片描述
    从图 2 可以看到,使用链表存储字符串,其最后一个节点的数据域不一定会被字符串全部占满,对于这种情况,通常会用 ‘#’ 或其他特殊字符(能与字符串区分开就行)将最后一个节点填满。

    链表各节点存储数据个数的多少可参考以下几个因素:

    1. 串的长度和存储空间的大小:若串包含数据量很大,且链表申请的存储空间有限,此时应尽可能的让各节点存储更多的数据,提高空间的利用率(每多一个节点,就要多申请一个指针域的空间);反之,如果串不是特别长,或者存储空间足够,就需要再结合其他因素综合考虑;
    2. 程序实现的功能:如果实际场景中需要对存储的串做大量的插入或删除操作,则应尽可能减少各节点存储数据的数量;反之,就需要再结合其他因素。

    以上两点仅是目前想到影响节点存储数据个数的因素,在实际场景中,还需结合实现环境综合分析。

    这里给出一个实现串的块链存储的 C 语言程序,以加深初学者对此字符串存储方式的认识:

    #include<stdio.h>
    #include<stdlib.h>
    #include<string.h>
    #define linkNum 3//全局设置链表中节点存储数据的个数
    typedef struct Link {
        char a[linkNum]; //数据域可存放 linkNum 个数据
        struct Link * next; //代表指针域,指向直接后继元素
    }link; // nk为节点名,每个节点都是一个 link 结构体
    link * initLink(link * head, char * str);
    void displayLink(link * head);
    int main()
    {
        link * head = NULL;
        head = initLink(head, "data.biancheng.net");
        displayLink(head);
        return 0;
    }
    //初始化链表,其中head为头指针,str为存储的字符串
    link * initLink(link * head, char * str) {
        int length = strlen(str);
        //根据字符串的长度,计算出链表中使用节点的个数
        int num = length/linkNum;
        if (length%linkNum) {
            num++;
        }
        //创建并初始化首元节点
        head = (link*)malloc(sizeof(link));
        head->next = NULL;
        link *temp = head;
        //初始化链表
        for (int i = 0; i<num; i++)
        {
            int j = 0;
            for (; j<linkNum; j++)
            {
                if (i*linkNum + j < length) {
                    temp->a[j] = str[i*linkNum + j];
                }          
                else
                    temp->a[j] = '#';
            }
            if (i*linkNum + j < length)
            {
                link * newlink = (link*)malloc(sizeof(link));
                newlink->next = NULL;
                temp->next = newlink;
                temp = newlink;
            }
        }
        return head;
    }
    //输出链表
    void displayLink(link * head) {
        link * temp = head;
        while (temp) {
            for (int i = 0; i < linkNum; i++) {
                printf("%c", temp->a[i]);
            }
            temp = temp->next;
        }
    }
    

    BF算法(串模式匹配算法)

    串的模式匹配算法,通俗地理解,是一种用来判断两个串之间是否具有"主串与子串"关系的算法。

    主串与子串:如果串 A(如 “shujujiegou”)中包含有串 B(如 “ju”),则称串 A 为主串,串 B 为子串。主串与子串之间的关系可简单理解为一个串 “包含” 另一个串的关系。

    实现串的模式匹配的算法主要有以下两种:

    1. 普通的模式匹配算法;
    2. 快速模式匹配算法;

    BF算法原理
    普通模式匹配算法,其实现过程没有任何技巧,就是简单粗暴地拿一个串同另一个串中的字符一一比对,得到最终结果。

    例如,使用普通模式匹配算法判断串 A(“abcac”)是否为串 B(“ababcabacabab”)子串的判断过程如下:
    在这里插入图片描述
    BF算法实现
    BF 算法的实现思想是:将用户指定的两个串 A 和串 B,使用串的定长顺序存储结构存储起来,然后循环实现两个串的模式匹配过程,C 语言实现代码如下:

    #include <stdio.h>
    #include <string.h>
    //串普通模式匹配算法的实现函数,其中 B是伪主串,A是伪子串
    int mate(char * B,char *A){
        int i=0,j=0;
        while (i<strlen(B) && j<strlen(A)) {
            if (B[i]==A[j]) {
                i++;
                j++;
            }else{
                i=i-j+1;
                j=0;
            }
        }
        //跳出循环有两种可能,i=strlen(B)说明已经遍历完主串,匹配失败;j=strlen(A),说明子串遍历完成,在主串中成功匹配
        if (j==strlen(A)) {
            return i-strlen(A)+1;
        }
        //运行到此,为i==strlen(B)的情况
        return 0;
    }
    int main() {
        int number=mate("ababcabcacbab", "abcac");
        printf("%d",number);
        return 0;
    }
    

    注意,在实现过程中,我们借助 i-strlen(A)+1 就可以得到成功模式匹配所用的次数,也就是串 A 移动的总次数。

    BF算法时间复杂度
    该算法最理想的时间复杂度 O(n),n 表示串 A 的长度,即第一次匹配就成功。

    BF 算法最坏情况的时间复杂度为 O(nm),n 为串 A 的长度,m 为串 B 的长度。例如,串 B 为 “0000000001”,而串 A 为 “01”,这种情况下,两个串每次匹配,都必须匹配至串 A 的最末尾才能判断匹配失败,因此运行了 nm 次。

    展开全文
  • 11.串的基本概念与串存储结构.ppt
  • 数据结构中,字符串要单独用一种存储结构来存储,称为串存储结构。这里的串指的就是字符串。 严格意义上讲,串存储结构也是一种线性存储结构,因为字符串中的字符之间也具有"一对一"的逻辑关系。只不过,...

    数据结构中,字符串要单独用一种存储结构来存储,称为串存储结构。这里的串指的就是字符串。

    严格意义上讲,串存储结构也是一种线性存储结构,因为字符串中的字符之间也具有"一对一"的逻辑关系。只不过,与之前所学的线性存储结构不同,串结构只用于存储字符类型的数据。

    无论学习哪种编程语言,操作最多的总是字符串。数据结构中,根据串中存储字符的数量及特点,对一些特殊的串进行了命名,比如说:

    • 空串:存储 0 个字符的串,例如 S = ""(双引号紧挨着);
    • 空格串:只包含空格字符的串,例如 S = "     "(双引号包含 5 个空格);
    • 子串和主串:假设有两个串 a 和 b,如果 a 中可以找到几个连续字符组成的串与 b 完全相同,则称 a 是 b 的主串,b 是 a 的子串。例如,若 a = "shujujiegou",b = "shuju",由于 a  中也包含 "shuju",因此串 a 和串 b 是主串和子串的关系;

    需要注意的是,空格串和空串不同,空格串中含有字符,只是都是空格而已。另外,只有串 b 整体出现在串 a 中,才能说 b 是 a 的子串,比如 "shujiejugou" 和 "shuju" 就不是主串和子串的关系。

    另外,对于具有主串和子串关系的两个串,通常会让你用算法找到子串在主串的位置。子串在主串中的位置࿰

    展开全文
  • 存储结构 的模式匹配算法 1.存储结构 的定长顺序存储表示 //定长顺序存储表示结构体定义如下: typedef struct { char str[maxsize+1]; int length; }str; //maxsize为已经定义的常量,表示...

    本节学习脉络

    • 串的存储结构
    • 串的模式匹配算法

    1.串的存储结构

    在这里插入图片描述

    • 串的定长顺序存储表示

    在这里插入图片描述

    //定长顺序存储表示结构体定义如下:
    typedef struct
    {
       char str[maxsize+1];
       int length;
     }str;
     //maxsize为已经定义的常量,表示串的最大长度,str数组长度定义为maxsize+1是因为多出一个‘\0’作为结束标记
    
    • 串的变长分配存储表示

      即动态分配存储表示,特点是在程序执行过程中根据需要动态分配。这种存储方式在使用时需要用函数malloc()来分配一个长度为length,类型为char型的连续存储空间,分配的空间可以用函数free()释放掉。用函数malloc()分配存储空间如果成功,则返回一个指向起始地址的指针,作为串的基地址,这个地址由ch指针指向,如果分配失败,则返回NULL。

    //其结构体定义如下:
    typedef struct
    {
      char *ch;  //指向动态分配存储区首地址的字符指针
      int length;//串长度
    }str;
    
    • 串的链式存储表示

    在这里插入图片描述

    • 基于顺序存储的一些常用基本操作

    在这里插入图片描述

    在这里插入图片描述
    在这里插入图片描述

    在这里插入图片描述
    在这里插入图片描述

    2.串的模式匹配算法

    在这里插入图片描述

    在这里插入图片描述

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    附上代码

    //第一种方法
    #include <stdio.h> 
     
    //pos是从1开始的一个下标
    int index_force(char * s, char * t)
    {
     
       int i=0;
        int j=0;
        while(s[i]!='\0' && t[j]!='\0') {	//主串或者模式串遍历完成
            if(s[i]==t[j]) {				//如果主串和模式串对应位置的值相等,则比较后面的字符
                ++i;
                ++j;
            }
            else {							//如果不相等,则模式串需要回朔到第一个字符,而主串则从下一个字符开始
                i=i-j+1;
                j=0;
            }
        }
        if(t[j]=='\0') {					//如果循环是由于模式串遍历完了而结束的,说明找到了对应子串的位置
            return i-j+1;
        }
        else  {								//否则,主串不包含模式串
            return 0;
        }
    }
    int main (void){						//用于测试的主函数 
    	char *p="abcdefgh";					//主串 
    	char *q="fg";						//模式串 
    	int index;
    	index=index_force(p,q);
    	printf("%d\n",index);				//输出结果 
    }
    
    
    //第二种方法
    #include <stdio.h>
    #include <string.h>
    
    int  index (char S[],char T[]){
         int  i=1,j=1;//下标从1开始
         int  lenS,lenT; 
         lenS=strlen(S)-1;//主串S实际长度
         lenT=strlen(T)-1;//子串T实际长度
    
         while ( i<=lenS && j<=lenT ){//i<S且j<T时循环
            if ( S[i] == T [j] ){//若两字符相等,则匹配下一位
                    ++i;
                    ++j;
            }
            else //S[i] != T[j] 两字符不相等
            {
                    i=i-(j-1)+1; //主串回到上次匹配的下一位
                    j=1; //子串从头开始匹配
                    //注: j-1 是这次循环中 主串较起始位置移动的字符数量 i-(j-1) 即这次循环的主串字符初始的位置 i-(j-1)+1 即下一次循环开始i的位置
            }
         }
        if ( j>lenT )  return i-lenT; //若j超出子串的下标 匹配成功
        else return 0; //否则 匹配失败
    }
    int main()
    {
        char S[]=" Mynameisbruceforce";//主串
        char T[]=" bruce";//子串
        int pos; //位置
        pos = index(S,T);
        printf("%d",pos);
        return 0;
    
    }
    
    

    这节的内容就整理完毕,之后会更新KMP算法(串的最后一讲哦!)2020.9.21.

    展开全文
  • 字符操作可谓是常见中的常见,usual中的usually,不好意思先秀一把英文。 使用C语言数组实现字符的操作,还是便于兄弟们理解字符在内存中的组织与操作的。 代码如下,精华都在注释中 #include <stdio.h>...

    点此查看全部文字教程、视频教程、源代码

    1. 串的概念

    字符串操作可谓是常见中的常见,usual中的usually,不好意思先秀一把英文。

    串可以通过一组连续地址存储,即为串的顺序存储。

    也可以通过链表存储,即为串的链式存储。

    2. 顺序存储代码实现

    使用C语言数组实现字符串的操作,还是便于兄弟们理解字符串在内存中的组织与操作的。代码如下,精华都在注释中

    #include <stdio.h>
    #define MAX_LENGTH 100
    /*
     * 主题:使用数组实现字符串操作实例
     * 作者:熊猫大大
     * 时间:2020-01-15
     */
    
    //字符串结构体
    typedef struct{
    	char content[MAX_LENGTH];//内容部分,最后一位存储'\0',所以实际字符串内容长度是MAX_LENGTH-1
    	int length;//实际长度
    }String;
    
    //打印字符串
    void printStr(String *str) 
    {
    	printf("str:%s\n",str->content);
    }
    
    //请空字符串
    void clearStr(String *str) 
    {
    	str->content[0] = '\0';
    	str->length = 0;
    }
    
    //返回字符串长度
    int getStrLength(String *str)
    {
    	return str->length;
    }
    
    //判断字符串是否为空 是1 否0
    int isEmpty(String *str) 
    {
    	if (str->length == 0) 
    	{
    		return 1;
    	}
    	else 
    	{
    		return 0;
    	}
    }
    
    //添加字符
    int appendChar(String *str,char c) 
    {
    	if (str->length < MAX_LENGTH - 1) 
    	{
    		str->content[str->length] = c;
    		str->length++;
    		str->content[str->length] = '\0';
    		return 1;
    	}
    	else //长度不足,返回失败0
    	{
    		return 0;
    	}
    }
    
    //插入字符,index从0开始,注意需要将后面的字符全部向后挪一个位置
    int insertChar(String *str,int index,char c) 
    {
    	int i;
    	if (str->length < MAX_LENGTH - 1)
    	{
    		for (i = str->length; i >= index; i--) //从最后一个'\0'开始都向后移动一个位置
    		{
    			str->content[i+1] = str->content[i];
    		}
    		str->content[index] = c;//将插入元素放入指定位置
    		return 1;
    	}
    	else //长度不足,返回失败0
    	{
    		return 0;
    	}
    }
    
    //删除指定位置元素,index从0开始,直接从后面往前覆盖即可
    int deleteChar(String *str,int index) 
    {
    	int i;
    	for (i = index; i <= str->length; i++) 
    	{
    		str->content[i ] = str->content[i+1];
    	}
    	return 1;
    }
    
    //将str2连接到str1
    int concat(String *str1,String *str2) 
    {	
    	int i = 0;
    	int leftLength = MAX_LENGTH - 1 - str1->length;//剩余可用长度
    	if (leftLength < str2->length) {//长度不足返回失败
    		return 0;
    	}
    	//依次取出str2中元素追加到str1
    	for (i = 0; i < str2->length; i++) 
    	{
    		appendChar(str1,str2->content[i]);
    	}
    	return 1;
    }
    
    int main() 
    {
    	//str1测试
    	String str1;
    	clearStr(&str1);
    	printf("str1清空后:\n");
    	printStr(&str1);
    	printf("str1是否为空?\n");
    	printf("%d\n", isEmpty(&str1));
    	printf("str1当前长度:\n");
    	printf("%d\n", getStrLength(&str1));
    	appendChar(&str1, 'a');
    	appendChar(&str1, 'b');
    	appendChar(&str1, 'c');
    	printf("str1添加abc后:\n");
    	printStr(&str1);
    	insertChar(&str1, 0, 'x');
    	printf("str1插入x后:\n");
    	printStr(&str1);
    	deleteChar(&str1,1);
    	printf("str1删除a后:\n");
    	printStr(&str1);
    	//str2测试
    	String str2;
    	clearStr(&str2);
    	appendChar(&str2, 'e');
    	appendChar(&str2, 'f');
    	appendChar(&str2, 'g');
    	printf("str2添加efg后:\n");
    	printStr(&str2);
    	//str1连接str2
    	concat(&str1, &str2);
    	printf("str1连接str2后:\n");
    	printStr(&str1);
    }
    

    3. 链式存储代码实现

    实际上将线性表的数据区域的数据类型int改为char,不就是一个链式存储的字符串么。

    直接附上链接:链式存储线性表

    展开全文
  • 一、定义(“逻辑结构”) (一)的定义 ,即字符(String)是由零个或多个字符组成的有限序列。一般记为S = ‘a1a2······an’ (n ≥0) 其中,S是名,单引号括起来的字符序列是的值;ai可以是字母...
  • 1. 串是什么,串存储结构的3种实现方法 数据结构中,字符串要单独用一种存储结构来存储,称为串存储结构。这里的串指的就是字符串。 严格意义上讲,串存储结构也是一种线性存储结构,因为字符串中的字符之间也具有...
  • (或字符)是由零个或多个字符组成的有限序列。 表示方法:S=“a1a2…an” 其中:S是名,双引号括起来的字符序列是值;ai(1 <= i <= n)可以是字母、数字或其他字符;n为的长度。 将值引起来的双...
  • 简介:串存储结构(newLine) 码头: 副官: 船长,接下来我们上船出海,探索一下这片海域,开拓一条新航线吧! 参考手册: 字符串 扬帆启航 码头上岸 简介:串存储结构(newLine)码头:海域等级 Lv1...
  • 字符str1、str2连接,分别用定长存储、堆存储、块链存储实现,不能直接调用函数库中自带的连接函数。 字符str1、str2连接,三种存储方式一、定长存储 一、定长存储 #include<iostream> using namespace ...
  • 存储结构

    2019-06-02 22:03:26
    存储结构与线性表相同,分为两种。 1.的顺序存储结构 的顺序存储结构是用一组地址连续的存储单元来存储串中的字符序列的。按照预定义的大小,为每个定义的变量分配一个固定长度的存储区。一般是用定长...
  • 33-的链式存储结构和基本操作

    千次阅读 2018-06-22 20:10:03
    1. 的链式存储结构   的链式存储结构与线性表是相似的,但是在链式存储结构中每个节点的数据域可以是一个字符,或者多个字符。如果每个节点的数据域是以一个字符存储的话,由于内存对齐的的影响下,链的...
  • 存储结构(堆)

    2020-06-12 20:05:27
    存储结构(堆) 一、堆简介         的堆存储结构,与定长顺序存储结构类似,都是用一维数组地址连续的存储单元存储串的字符序列,不同的是堆存储空间是在...
  • 代码如下: void subString(char s[],int start,long count,char t[]) { long i,j,length=strlen(s); if(start<1 || start>length) { printf("The copy position is wrong!... }else if(start+count-1>...
  • 是一种特殊的线性表,所以先得搞清楚线性表的顺序、链式存储,在其基础上便可以清楚分析特殊线性表的存储结构:栈、队列、 顺序:结构体里面定义一个数组+长度等辅助信息 链式:结构体里面定义一个元素数据类型+...
  • 1.的顺序存储结构 1.1的定长顺序存储结构 #define MAXLEN 6 typedef struct{ char ch[MAXLEN+1]; //用来存储串的一维数组 int length; //的当前长度 }SString; 1.2的堆式顺序存储结构 typedef struct{ ...
  • 主要介绍了C语言实现数据结构串(堆分配存储表示法)实例详解的相关资料,需要的朋友可以参考下
  • 类定义: #include<iostream> constexpr auto MaxSize = 50; using namespace std; ...class SqString { ...//存放字符,这里假设分配的空间足够使用,即实现中不考虑空间不足的情况...//将字符常量赋值给 void
  • 关于的索引结构,看来很多网站发觉都是一些简单描述,华而不实,看完马春江老师编的《数据结构》,我重新整理了《数据结构之-的索引存储》,和大家分享。 感谢马春江老师以及罗浩、张顺、王帅林同学的帮助。
  • 的定义 (string)(或字符)是由零个或多个字符组成的有限序列,一般记为, s=“a1,a2…an”(n≥0) n为字符的长度 零个字符的称为空串,其长度也为0 中任意个连续的字符组成的子序列称为该的...
  • 的顺序存储结构

    千次阅读 2020-03-23 11:59:57
    定长顺序串 1.定义:定长顺序串是将串设计成一种静态结构类型,串的存储分配...定长顺序串存储结构 #include <stdio.h> #define MAXLEN 40 /*MAXLEN 表示串的最大长度*/ typedef struct { char ch[MAXLEN]; /...
  • 4.2的顺序存储结构

    2020-06-02 11:28:45
    1)定长顺序串存储结构 定长顺序串类型定义如下: #define MAXLEN 40 typedef struct { /*串结构定义*/ char ch[ MAXLEN]; int len; }SString; 其中 MAXLEN 表示串的最大长度,ch 是存储字符串的一维数组,每...
  • 串结构之定长顺序存储(C语言版)
  • :由零个或多个字符组成的有限系列,又名叫字符。 例如: s = "a1a2a3...an"(n>=0),其中s是的名称,用双引号(或者单引号)括起来的字符序列部分是的值。其中引号部分不属于的内容,双引号里面可以是...
  • http://blog.csdn.net/zhonghuan1992钟桓2014年8月31日浅谈python字符串存储形式记录一下自己今的天发现疑问而且给出自己现有知识有的回答。长话短说,用过python的人对于 == 和 is 应该不陌生,可是这里我还是介绍...
  • 字符和字符的常见存储结构

    千次阅读 2017-04-13 22:49:06
    继续接去年的常见数据结构和算法总结 系列随笔记录 一、计算机里进行非数值处理的对象基本上是字符数据,比处理浮点和整数都要复杂 string定义:由 0 个或多个 字符 组成的 有限的 序列,通常记为:s =...
  • 我们知道,顺序存储结构(顺序表)的底层实现用的是数组,根据创建方式的不同,数组又可分为静态数组和动态数组,因此顺序存储结构的具体实现其实有两种方式。...的定长顺序存储结构,可以简单地理解为采用...
  • 本项目使用顺序存储的方式存储两个字符,并对这两个进行模式匹配 其中第一个输入的字符为目标,第二个输入的字符为模式 输出为模式(子串)在目标(主)中的位置; 若第二次输入的并非第一次...
  • 定长数据基本操作 插入位置pos将分为两部分 有三种情况 情况一:插入后总长大于原长 情况二:插入后总长等于原长 第三种:小于 的模式匹配 目的: 主要是消除了主指针的回溯,从而使算法效率有了某种程度的...
  • 数 据 结 构 课 程 设 计 设计题目 存储表示及基本操作 学生姓名 专业班级 课题名称 存储表示及基本操作 院 系 年级专业 学 号 姓 名 成 绩 1课题设计目的 1掌握的基本存储结构 2掌握的基本运算及其实现...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 833,415
精华内容 333,366
关键字:

串存储结构