`

串的定长顺序存储表示

阅读更多
串的定长顺序存储表示是一种类似于线性表的顺序存储结构,用一组地址连续的存储单元存储串值的字符序列。
在实现时主要实现以下功能:
int Length(SString s);                               //串长

bool StringConcat(SString T, SString s1, SString s2);//用T返回s1和s2连接的串

void PrintString(char T[]);                          //输出

bool StringAssign(SString T,const char str[]);       //生成值为str的串

bool StrCopy(SString T, SString s);                  //将s拷贝到T

bool StrEmpty(SString T);                            //判空

int StrCompare(SString T,SString T1);                //比较

void ClearString(SString T);                         //清除

bool SubString(SString T,SString S,int pos,int len); //返回子串

bool StrInsert(SString S,int pos,SString T);         //插入

bool StrDelete(SString S,int pos,int len);           //删除

但是对于Replace()函数和Index()函数我仍有不懂得地方,故这里不进行编写。

具体的代码如下:
头文件:
#pragma once

#include<iostream>
using namespace std;


#define MAX_STRING_SIZE 8

typedef char SString[MAX_STRING_SIZE+1];

int Length(SString s);                               //串长

bool StringConcat(SString T, SString s1, SString s2);//用T返回s1和s2连接的串

void PrintString(char T[]);                          //输出

bool StringAssign(SString T,const char str[]);       //生成值为str的串

bool StrCopy(SString T, SString s);                  //将s拷贝到T

bool StrEmpty(SString T);                            //判空

int StrCompare(SString T,SString T1);                //比较

void ClearString(SString T);                         //清除

bool SubString(SString T,SString S,int pos,int len); //返回子串

bool StrInsert(SString S,int pos,SString T);         //插入

bool StrDelete(SString S,int pos,int len);           //删除


函数声明:
#include "String.h"

int Length(SString s)
{
return strlen(s);
}

bool StringConcat(SString T, SString s1, SString s2)
{
int t_length = MAX_STRING_SIZE;
int s1_length = Length(s1);
int s2_length = Length(s2);

if(t_length >= s1_length+s2_length)
{
for(int i=0; i<s1_length; ++i)
{
T[i] = s1[i];
}
for(int j=0; j<s2_length; ++j)
{
T[i+j] = s2[j];
}
T[i+j] = '\0';
return true;
}
else if(t_length>s1_length && t_length<s1_length+s2_length)
{
for(int i=0; i<s1_length; ++i)
{
T[i] = s1[i];
}
for(int j=0; j<t_length-s1_length; ++j)
{
T[i+j] = s2[j];
}
T[i+j] = '\0';
return false;

}
else if(t_length < s1_length)
{
for(int i=0;i<t_length;++i)
{
T[i] = s1[i];
}
T[i] = '\0';
}
return true;
}

void PrintString(char T[])
{
cout<<T<<endl;
}

bool StringAssign(SString T,const char str[])
{
for(int i=0;str[i] != '\0';++i)
{
T[i] = str[i];
}
T[i] = '\0';
return true;
}

bool StrCopy(SString T, SString s)
{
int t_length = MAX_STRING_SIZE;
int s_length = Length(s);
if(s_length <= t_length)
{
for(int i = 0;i < s_length;++i)
{
T[i] = s[i];
}
T[i] = '\0';
}
else
{
for(int i = 0;i < t_length;++i)
{
T[i] = s[i];
}
T[i] = '\0';
}
return true;
}

bool StrEmpty(SString T)
{
if(Length(T) == 0)
{
cout<<"串为空"<<endl;
return true;
}
else
{
cout<<"串不为空"<<endl;
return false;
}
}

int StrCompare(SString T,SString T1)
{
for(int i=0,j=0;i<Length(T),j<Length(T1);++i,++j)
{
if(T[i]-'0' > T1[j]-'0')
{
return 1;
}
else if(T[i]-'0' == T1[j]-'0')
{
return 0;
}
else
{
return -1;
}
}
exit(-1);
}

void ClearString(SString T)
{
T[0] = '\0';
}

bool SubString(SString T,SString S,int pos,int len)
{
if(pos > Length(S) || pos < 1 || len < 0 )
{
return false;
}
else if(len > Length(S)-pos+1)
{
cout<<"无法返回,返回原始字符串:";
for(int i=pos-1;i<Length(S);++i)
{
T[i] = S[i];
}
T[i]='\0';
}
else
{
for(int i=pos-1;i<pos+len-1;++i)
{
T[i] = S[i];
}
T[i]='\0';
}
return true;
}

bool StrInsert(SString S,int pos,SString T)
{
if(pos < 1 || pos > Length(S)+1)
{
return false;
}
else
{
for(int i = Length(S);i>=pos-1;--i)
{
S[i+Length(T)] = S[i];
}
for(i  = 0;i < Length(T);++i)
{
S[pos+i-1] = T[i];
}
}
return true;
}

bool StrDelete(SString S,int pos,int len)
{
if(pos < 0 || pos > Length(S)|| len < 0)
{
return false;
}
else if(pos > Length(S)-len+1)
{
S[pos-1] = '\0';
}
else
{
for(int i = pos+len;i <= Length(S)-1;++i)
{
S[i-len] = S[i];
}
S[Length(S)-len] = '\0';
}
return true;
}


测试文件:
#include"String.h"

void main()
{
SString T;
char str[] = "bit";
SString s1 = "hello";
SString s2 = "world";
StrInsert(s1,2,s2);
PrintString(s1);
SubString(T,s1,1,6);
PrintString(T);
StringConcat(T,s1,s2);
PrintString(T);
StrCopy(T,s1);
PrintString(T);
StringAssign(T,str);
PrintString(T);
StrDelete(s2,1,1);
PrintString(s2);
StrEmpty(T);
if(StringAssign(s1,s2)==1)
{
cout<<"前串大于后串"<<endl;
}
else if(StringAssign(s1,s2)==0)
{
cout<<"前串等于后串"<<endl;
}
else
{
cout<<"前串小于后串"<<endl;
}
ClearString(T);
    StrEmpty(T);
}

源码来自 算法:http://www.eyesourcecode.com/forum-algorithm-1.html
希望大家能够指出我的不足,谢谢~我会努力改进的。
1
0
分享到:
评论

相关推荐

    串的基本操作定长顺序存储表示:初始化串、复制串、判断串是否为空、比较两个字符串、计算字符串长度、清空串、连接串、找子串、模式匹配、替换子串、插入和删除子串

    本文将深入探讨“串的基本操作定长顺序存储表示”,包括初始化串、复制串、判断串是否为空、比较两个字符串、计算字符串长度、清空串、连接串、找子串、模式匹配、替换子串、插入和删除子串。 1. **初始化串**: ...

    掌握串的基本处理操作和几种不同的存储结构(定长顺序存储表示、堆分配存储表示和块链存储表示)

    掌握串的基本处理操作和几种不同的存储结构(定长顺序存储表示、堆分配存储表示和块链存储表示)。 二、 实验要求 1、 实现串赋值、串比较、求串长、串联接以及求子串这5种基本操作。 2、 能利用上述实现的基本操作...

    数据结构-基本算法-串定长顺序存储

    数据结构-基本算法-串定长顺序存储(学生时代源码,调试可运行)

    用定长顺序存储结构表示串,求两个串的全部最长公共子串

    在本题目中,任务是使用定长顺序存储结构表示串,并找出两个字符串的最长公共子串。这是一个典型的字符串处理问题,通常在计算机科学和编程领域出现。以下是对这个任务的详细解析: 首先,我们需要理解“定长顺序...

    定长顺序串的基本运算

    - 使用结构体 `seqstring` 来表示定长顺序串。 - 结构体包含两个成员:一个字符数组 `data` 和一个整型变量 `curlen` 用来存储当前字符串的实际长度。 2. **函数定义**: - **`strassign`**:该函数用于将一个...

    数据结构——串实践报告.doc

    1. **实现串的定长顺序存储表示的基本操作**:这通常包括创建新串(`StrAssign`)、复制串(`StrCopy`)、检查串是否为空(`StrEmpty`)等。在提供的代码中,可以看到这些操作的具体实现。 - `StrAssign`函数用于...

    串的定长顺序存储.cpp

    数据结构课本上的关于串的那一章,有时写作业用的啊

    掌握串的基本处理操作和几种不同的存储结构(定长顺序存储表示、堆分配存储表示和块链存储表示)。

    1、 实现串赋值、串比较、求串长、串联接以及求子串这5种基本操作。 2、 能利用上述实现的基本操作完成置换Replace (&S, T, V)以及从串中删除一段子串StrDelete(&S,pos,len)的操作。 3、 以上要求实现的操作不能直接...

    数据结构串的存储结构程序

    在这个程序中,我们使用了顺序存储结构来存储串,即将串存储在一个连续的内存块中。这是一种简单和高效的存储结构,但它也存在一些缺陷,如插入和删除操作的效率较低。在实际应用中,我们可以根据具体情况选择合适的...

    串的顺序存储.zip

    本文将深入探讨串的顺序存储这一主题,主要关注它的概念、实现方式以及优缺点。 顺序存储是数据结构中的一种常见方法,它是指用一组连续的内存单元来存储数据元素。对于串的顺序存储,我们可以直接使用数组(一维...

    数据结构-串

    在这个主题中,我们将深入探讨串的两种主要存储方式——定长顺序存储和堆分配存储,以及它们在实现串的基本操作和模式匹配中的应用。 首先,我们来看“定长顺序存储”。在计算机内存中,串可以被看作是一维数组,每...

    数据结构——线性表顺序存储结构(C++代码)

    顺序存储结构则是线性表的一种常见实现方式,它将线性表中的元素按照一定的顺序存放在一块连续的内存区域中。这种存储方式简单直观,便于进行元素的访问和操作。 在C++中实现线性表的顺序存储结构,通常会定义一个...

    Delphi源码实例演示堆分配与栈分配的不同..rar

    栈是计算机内存中一个特殊区域,它按照后进先出(LIFO)的原则工作,主要用于存储程序运行时的临时变量。例如,函数调用时,函数参数、局部变量等都会被存储在栈上。栈的优点是访问速度快,因为它的分配和释放都非常...

    c语言 数据结构实现之字符串

    串采用定长顺序存储结构(由c4-1.h定义)的基本操作(13个),包括算法4.2,4.3,4.5  实现效果图: #include #include #include // SString是数组,故不需引用类型 #define OK 1 #define TRUE 1 #define FALSE 0 ...

    线性表顺序存储的实现

    在顺序存储的线性表中,元素按照它们在内存中的位置顺序进行排列,这种存储方式简单直观,易于理解和操作。本文将深入探讨线性表顺序存储的实现,以及与其相关的算法和数据结构知识。 首先,顺序存储结构通常采用...

    数据顺序结构存储

    本文将围绕数组的顺序存储进行深入探讨,包括其基本概念、实现原理以及一些典型的操作。 #### 二、数组的顺序存储 数组是一种将相同类型的数据元素按照一定的顺序排列起来的数据结构。在计算机内存中,数组元素是...

    数据结构:第4章 串.ppt

    串的表示和实现有多种方法,常见的有定长顺序存储表示、堆分配存储表示和块链存储表示等。其中,定长顺序存储表示是最常用的方法,它将串的字符序列存储在一块连续的存储单元中,串的长度信息通常存储在数组的第一个...

    线性表的顺序存储结构与操作

    ### 线性表的顺序存储结构与操作 #### 一、基础知识介绍 **线性表**是数据结构中最基本的线性结构之一,它是由n(n≥0)个相同类型的数据元素组成的有限序列。在线性表中,除了第一个元素外,每个元素都有唯一的...

    介绍串的逻辑结构第四章数据结构串

    * 静态存储分配的顺序串:使用定长的字符数组来定义,数组的上界预先给出。 * 动态存储分配的顺序串:在程序执行过程中动态分配一组地址连续的存储单元存放字符序列。 4.2 链式存储 链式存储结构简称链串,链串是...

    线性表的动态分配顺序存储结构(C语言)

    在C语言中,我们通常使用动态分配内存的方式来实现线性表的顺序存储结构,这是因为静态数组在声明时必须指定大小,而动态内存分配则可以在运行时根据实际需求进行调整,提供了更大的灵活性。 线性表的顺序存储结构...

Global site tag (gtag.js) - Google Analytics