数据结构：定长顺序串（SString）基本操作的算法描述（C语言）

已于 2023-04-10 08:20:30 修改
阅读量2.7k 收藏 22
点赞数 5
分类专栏： 数据结构学习记录 文章标签： 数据结构 c语言
于 2023-04-06 22:00:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_70911939/article/details/129993717
版权

作者在学习数据结构时，发现鲜有完全按照 C 语言描述的算法操作，这让习惯于写 .c 而不是 .cpp 的初学者很是头疼。本文将基于 C 语言描述算法操作，如有错漏还望大佬们指正。

文章目录

前言

本文将按照严惠敏所著《数据结构(C语言版)》所做的函数原型声明进行算法描述，由于C语言不支持函数参数中出现取地址符，我将函数参数更改为指针，调用函数时需要使用一级指针。基本操作调用示例将在本文后给出。

2023.4.10   08 : 20 2023.4.10\ 08:20 2023.4.10 08:20 新增了 I n d e x Index Index 的 K M P KMP KMP 算法及其调用示例

一、定长顺序串基本操作的函数声明

//生成一个其值等于 chars 的串 S
extern Status StrAssign(SString* S, char* chars);
//由串 S 复制得串 T
extern Status StrCopy(SString *T, SString S);
//若 S 为空串，则返回 TRUE，否则返回 FAUSE
extern Status StrEmpty(SString S);
//若 S > T，则返回值 > 0；若 S = T，则返回值 = 0；若 S < T，则返回值 < 0
extern int StrCompare(SString S, SString T);
//返回串 S 的元素个数，称为串的长度
extern int StrLength(SString S);
//将 S 清为空串
extern Status ClearString(SString *S);
//用 T 返回由 S1 和 S2 联接而成的新串，如果连接时未截断则返回 TRUE，否则返回 FAUSE
extern Status Concat(SString *T, SString S1, SString S2);
//用 Sub 返回串 S 的第 pos 个字符起长度为 len 的子串
extern Status SubString(SString *Sub, SString S, int pos, int len);
//如果主串 S 中存在和串 T 值相同的子串，则返回它在主串 S 中第 pos 个字符之后第一次出现的位置；否则函数值为 0
extern int Index(SString S, SString T, int pos);
//用串 V 替换主串 S 中出现的所有与串 T 相等的不重叠的子串
extern Status Replace(SString *S, SString T, SString V);
//在串 S 的第 pos 个字符前插入串 T
extern Status StrInsert(SString *S, int pos, SString T);
//从串 S 的第 pos 个字符起长度为 len 的子串
extern Status StrDelete(SString *S, int pos, int len);
//销毁串 S
extern Status DestroyStr(SString *S);
//打印串 S
extern Status PrintStr(SString S);
//模式匹配的的 KMP 算法：如果主串 S 中存在和串 T 值相同的子串，则返回它在主串 S 中第 pos 个字符之后第一次出现的位置；否则函数值为 -1
extern int Index_KMP(SString S, SString T, int pos);
//计算 KMP 算法中串 T 的 next 函数值
extern void get_nextval(SString T, int *nextval);

二、定长顺序串基本操作的完整描述

/* 定长顺序串 */
#include <stdio.h>
#include <stdlib.h>
#define MAXSTRLEN   255
#define OK          0
#define ERROR       1
#define TRUE        0
#define FAUSE       1
#define OVERFLOW    -2

typedef char Elemtype;
typedef int Status;
/*--------串的定长顺序表示--------*/

typedef unsigned char SString[MAXSTRLEN + 1];

//--------定长顺序串的基本操作的函数声明--------

//生成一个其值等于 chars 的串 S
extern Status StrAssign(SString* S, char* chars);
//由串 S 复制得串 T
extern Status StrCopy(SString *T, SString S);
//若 S 为空串，则返回 TRUE，否则返回 FAUSE
extern Status StrEmpty(SString S);
//若 S > T，则返回值 > 0；若 S = T，则返回值 = 0；若 S < T，则返回值 < 0
extern int StrCompare(SString S, SString T);
//返回串 S 的元素个数，称为串的长度
extern int StrLength(SString S);
//将 S 清为空串
extern Status ClearString(SString *S);
//用 T 返回由 S1 和 S2 联接而成的新串，如果连接时未截断则返回 TRUE，否则返回 FAUSE
extern Status Concat(SString *T, SString S1, SString S2);
//用 Sub 返回串 S 的第 pos 个字符起长度为 len 的子串
extern Status SubString(SString *Sub, SString S, int pos, int len);
//如果主串 S 中存在和串 T 值相同的子串，则返回它在主串 S 中第 pos 个字符之后第一次出现的位置；否则函数值为 0
extern int Index(SString S, SString T, int pos);
//用串 V 替换主串 S 中出现的所有与串 T 相等的不重叠的子串
extern Status Replace(SString *S, SString T, SString V);
//在串 S 的第 pos 个字符前插入串 T
extern Status StrInsert(SString *S, int pos, SString T);
//从串 S 的第 pos 个字符起长度为 len 的子串
extern Status StrDelete(SString *S, int pos, int len);
//销毁串 S
extern Status DestroyStr(SString *S);
//打印串 S
extern Status PrintStr(SString S);
//模式匹配的的 KMP 算法：如果主串 S 中存在和串 T 值相同的子串，则返回它在主串 S 中第 pos 个字符之后第一次出现的位置；否则函数值为 -1
extern int Index_KMP(SString S, SString T, int pos);
//计算 KMP 算法中串 T 的 next 函数值
extern void get_nextval(SString T, int *nextval);

Status StrAssign(SString* S, char* chars) {
    int len; char* c;
    for (len = 0, c = chars; *c; len++, c++) {
        (*S)[len + 1] = *c;
    }
    (*S)[0] = len;
    return OK;
}// StrAssign

Status StrCopy(SString *T, SString S) {
    for (int i = 1; i <= S[0]; i++) (*T)[i] = S[i];
    (*T)[0] = S[0];
    return OK;
}// StrCopy

Status StrEmpty(SString S) {
    if (S[0]) return FAUSE;
    else return TRUE;
}// StrEmpty

int StrCompare(SString S, SString T) {
    if (S[0] > T[0]) return 1;
    else if (S[0] < T[0]) return -1;
    else {
        for (int i = 1; i <= S[0]; i++) {
            if (S[i] > T[i]) return 1;
            else if (S[i] < T[i]) return -1;
        }
        return 0;
    }
}// StrCompare

int StrLength(SString S) {
    return S[0];
}// StrLength

Status ClearString(SString *S) {
    (*S)[0] = 0;
    return OK;
}// ClearString

Status Concat(SString *T, SString S1, SString S2) {
    int uncut = 0;
    if (S1[0] + S2[0] <= MAXSTRLEN) {
        for (int i = 1; i <= S1[0]; i++) (*T)[i] = S1[i];
        for (int i = S1[0] + 1; i <= S1[0] + S2[0]; i++) (*T)[i] = S2[i - S1[0]];
        (*T)[0] = S1[0] + S2[0]; uncut = TRUE;
    }
    else if (S1[0] < MAXSTRLEN) {
        for (int i = 1; i <= S1[0]; i++) (*T)[i] = S1[i];
        for (int i = S1[0] + 1; i <= MAXSTRLEN; i++) (*T)[i] = S2[i - S1[0]];
        (*T)[0] = MAXSTRLEN; uncut = FAUSE;
    }
    else {
        for (int i = 0; i <= MAXSTRLEN; i++) (*T)[i] = S1[i];
        uncut = FAUSE;
    }
    return uncut;
}// Concat

Status SubString(SString *Sub, SString S, int pos, int len) {
    if (pos < 1 || pos > S[0] || len < 0 || len > S[0] - pos + 1) return ERROR;
    for (int i = 1; i <= len; i++) (*Sub)[i] = S[pos + i - 1];
    (*Sub)[0] = len; return OK;
}// SubString

int Index(SString S, SString T, int pos) {
    if (pos > 0) {
        int n = StrLength(S), m = StrLength(T), i = pos;
        SString sub;
        while (i <= n - m + 1) {
            SubString(&sub, S, i, m);
            if (StrCompare(sub, T) != 0) ++i;
            else return i;
        }
    }
    return 0;
}// Index

Status Replace(SString *S, SString T, SString V) {
    int pos = Index(*S, T, 1);
    if (!pos) return ERROR;
    StrDelete(S, pos, T[0]);
    StrInsert(S, pos, V);
    return OK;
}// Replace

Status StrInsert(SString* S, int pos, SString T) {
    if ((*S)[0] + T[0] > MAXSTRLEN) exit(OVERFLOW);
    SString tmp;
    for (int i = 1; i <= (*S)[0] - pos + 1; i++) tmp[i] = (*S)[pos + i - 1];
    tmp[0] = (*S)[0] - pos + 1;
    for (int i = 1; i <= T[0]; i++) 
        (*S)[pos + i - 1] = T[i];
    for (int i = 1; i <= tmp[0]; i++) (*S)[pos + T[0] + i - 1] = tmp[i];
    (*S)[0] = (*S)[0] + T[0];
    return OK;
}// StrInsert

Status StrDelete(SString* S, int pos, int len) {
    for (int i = 0; i <= (int)(*S)[0] - pos - len; i++) 
        (*S)[pos + i] = (*S)[pos + len + i];
    (*S)[0] -= len;
    return 0;
}// StrDelete

Status DestroyStr(SString *S) {
    free(S);
    return OK;
}// DestroyStr

Status PrintStr(SString S) {
    for (int i = 1; i <= S[0]; i++) {
        printf("%c", S[i]);
    }
    printf("\n");
    return OK;
}// PrintList

int Index_KMP(SString S, SString T, int pos) {
    int i = pos, j = 1;
    int next[MAXSTRLEN + 1];
    get_nextval(T, next);
    while (i <= S[0] && j <= T[0]) {
        if (j == 0 || S[i] == T[j]) { ++i; ++j; }
        else j = next[j];
    }
    if ((j > T[0])) return (i - T[0]);
}// Index_KMP

void get_nextval(SString T, int *nextval) {
    * nextval = (long int)malloc(MAXSTRLEN * sizeof(int));
    int i = 1; nextval[1] = 0; int j = 0;
    while (i < T[0]) {
        if (j == 0 || T[i] == T[j]) {
            ++i; ++j;
            if (T[i] != T[j]) nextval[i] = j;
            else nextval[i] = nextval[j];
        }
        else j = nextval[j];
    }
}// get_nextval

三、调用示例

int main() {
    char chars[MAXSTRLEN + 1] = {0};
    SString S, T, P;
    printf("Please enter a string: ");
    scanf("%s", chars);
    StrAssign(&S, chars);
    printf("The resulting string: ");
    PrintStr(S);
    StrCopy(&T, S);
    printf("StrCopy(&T, S): ");
    PrintStr(T);
    printf("StrCompare(S, T): result = %d\n", StrCompare(S, T));
    printf("StrLength(S): %d\n", StrLength(S));
    Concat(&P, S, T);
    printf("Concat(&P, S, T): P = ");
    PrintStr(P);
    char chars1[MAXSTRLEN + 1] = { 0 }, chars2[MAXSTRLEN + 1] = { 0 };
    SString S, T;
    printf("Index_KMP: Please enter chars1: ");
    scanf("%s", chars1);
    printf("Index_KMP: Please enter chars2: ");
    scanf("%s", chars2);
    StrAssign(&S, chars1);
    StrAssign(&T, chars2);
    printf("Index_KMP: result = %d\n", Index_KMP(S, T, 1));
    return 0;
}

终端输出结果如下：

Please enter a string: abcde
The resulting string: abcde
StrCopy(&T, S): abcde
StrCompare(S, T): result = 0
StrLength(S): 5
Concat(&P, S, T): P = abcdeabcde
Index_KMP: Please enter chars1: samples
Index_KMP: Please enter chars2: sam
Index_KMP: result = 0

总结

以上是定长顺序串的基本操作的算法描述，更多数据结构的算法描述还在更新中，敬请关注作者专栏。

Jun from a nut shell
关注
  • 5
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
定长顺序串的基本运算
12-20
这是数据库里面的一个小程序，关于字符串的定长问题的一个程序
【STL】STL之string详解
热门推荐
行码棋
02-26 1万+
C++STL之string详解
C++STL详解（一）—— string类
2021dragon的博客
06-14 5893
文章目录C++STL详解（一） —— sring类一、string的定义方式二、string的插入三、string的拼接四、string的删除五、string的查找六、string的比较七、string的替换八、string的交换九、string的大小和容量十、string中元素的访问十一、string中运算符的使用十二、string中与迭代器相关的函数 C++STL详解（一） —— sring类 本次内容大纲： 一、string的定义方式 string类实现了多个构造函数的重载，常用的构造函数如下： st
定长顺序串的基本操作
franboe的博客
12-11 5353
定长顺序串采用的是数组方法进行存储，空间分配一次完成，可以实行如下的基本操作 #include #include using namespace std; #define MAXSTRLEN 200 #define TRUE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define INFEASIBLE -1 #define OVERFL
定长串的基本操作
weixin_30275415的博客
12-01 238
串的定长顺序存储表示 即用一组地址连续的存储单元存储串中的字符序列。 串的定长存储用定长数组表述如下： #define MaxStrlen 255//预定串的最大长度为255 typedef unsigned char SString[MaxStrlen+1]//0号单元存放串的长度 串的实际长度可以预定长度范围内任意，超过预定长度的部分则被舍去，称 之为 截断 。 定长串常用基...
顺序串的基本操作(C实现)
m0_61395860的博客
02-11 7244
一、概念 顺序结构的存储空间都是事先定义的，顺序串也不例外，故也可成为 定长顺序串，它的存储类型是字符串的char类型。 二、具体实现 1.结构体定义 #include<stdio.h> #include<stdlib.h> #include<string.h> #define true 1 #define false 0 #define max 20 typedef struct { char data[max]; int length; }SString
数据结构 定长串的基本操作
05-17
数据结构中定长串的一些基本操作 （创建，输出，插入，删除，复制，求串长等操作）
数据结构-基本算法-串定长顺序存储
05-21
数据结构-基本算法-串定长顺序存储(学生时代源码，调试可运行)
c语言 数据结构实现之字符串
01-20
串采用定长顺序存储结构(由c4-1.h定义)的基本操作(13个)，包括算法4.2，4.3，4.5  实现效果图： #include #include <string> #include // SString是数组，故不需引用类型 #define OK 1 #define TRUE 1 #define ...
学习资料分享：数据结构及算法经典算法C代码实现
09-21
学习资料分享：数据结构及算法经典算法C代码实现，学算法，学C语言，一步到位，看着一个就够了，里面有各种算法的实现和问题的求解答案。全都是C代码，可以直接在编辑器中运行，边学边看边练，相信你一定是最牛的，...
串的基本操作定长顺序存储表示：初始化串、复制串、判断串是否为空、比较两个字符串、计算字符串长度、清空串、连接串、找子串、模式匹配、替换子串、插入和删除子串
06-05
串的基本操作定长顺序存储表示：初始化串、复制串、判断串是否为空、比较两个字符串、计算字符串长度、清空串、连接串、找子串、模式匹配、替换子串、插入和删除子串
数据结构（C语言描述）学习笔记.zip
最新发布
12-30
这些代码不仅能帮助你理解数据结构的基本概念，而且能让你明白如何在实际情况中应用这些数据结构。 笔记：详细且系统的笔记，涵盖了数据结构的各个方面，从基础概念到复杂的数据结构如堆、B树等。这些笔记有助于你...
顺序串的算法
weixin_44077170的博客
09-13 167
#include #include<stdio.h> #include using namespace std; const int Max=50; typedef class bunch { public: char a[Max]; int length; }sqString; void creat(sqString &str,char t[]); //创建...
定长顺序串一些操作
Will的专栏
08-10 722
SString.h#ifndef SSTRING_H_H #define OK 0 #define ERROR -1 #define MAX_LENGTH 255 typedef unsigned char SString[MAX_LENGTH + 1]; //第0个位置存放串的长度 int sstr_assign(SString, const char*); int sstr_print(SString); int sstr_copy(SString, SString); int sstr
顺序串算法
PANCHUNYU123456789的博客
11-10 1169
[cpp] view plain copy   /*   * Copyright (c)2016,烟台大学计算机与控制工程学院   * All rights reserved.   * 文件名称：项目3.cpp   * 作    者：泮春宇   * 完成日期：2016年10月18日   * 版 本 号：v1.0    *问题描述：采用顺序存储方式存储串，实
YTU 3007: 顺序串的基本运算
weixin_30951231的博客
04-11 145
3007: 顺序串的基本运算 时间限制:1 Sec内存限制:128 MB 提交:1解决:1 题目描述 编写一个程序，实现顺序串的各种基本运算，主函数已给出，请补充每一种方法。 1、建立串s="abcdefghefghijklmn",和串s1="xyz"; 2、输出串s； 3、输出串s的长度； 4、在串s的第九...
【数据结构】串（定长顺序串、堆串、块链串）的存储结构及基本运算（C语言）
weixin_51450101的博客
01-24 4224
目录串的基本概念定长顺序串代码+注释运行结果堆串代码+注释运行结果块链串 串的基本概念 字符串（String）是由零个或多个字符组成的有限序列。记为 S = ‘a1a2…an’（n>0） 其中，S是串的名字，用单引号括起来的字符序列是串的值，每个 ai（1<=i<=n）可以是字母、数字或其它字符。n是串中字符的个数，称为串的长度，n=0时的串称为空串。 子串：串中任意个连续的字符组成的子序列称为该串的子串。 主串：包含子串的串称为主串。 子串在主串中的位置：通常将字符在串中的序号称为该字符
（C语言）定长串的基本操作
JC_ZQ_Fighting的博客
10-19 507
定长串的下标为0的数组分量闲置不用，从下标为1的分量开始存储 //定长串.cpp #include<stdio.h> #include<string.h> #define MAXLEN 255 typedef struct{ char ch[MAXLEN+1]; int length; }SString, *string; //串的初始化 void initString(string s){ s->length = 0; } //串的赋值 void scanfSt.
串采用定长顺序存储结构的基本操作
heiazb的专栏
11-19 3461
#include "stdafx.h" #include #include #include #include using namespace std; #define MAX_STRLEN  256 #define MAXSTRLEN 40 // 用户可在255以内定义最大串长（1个字节） typedef char SString[MAXSTRLEN + 1]; /
sstring和string
07-27
String和StringBuilder是Java中的两个字符串类。它们之间最大的区别在于String的内容是不可修改的，而StringBuilder的内容可以修改。\[2\]如果需要频繁修改字符串的情况下，建议使用StringBuilder。另外，String和StringBuilder之间不能直接转换，但可以通过一些方法实现转换。将String转换为StringBuilder可以使用StringBuilder的构造方法或append()方法，而将StringBuilder转换为String可以调用toString()方法。\[2\]此外，如果一个String对象已经被创建过了，那么在创建新的String对象时，会从String Pool中取得引用。只有String是不可变的，才能使用String Pool。\[3\] #### 引用[.reference_title] - *1* *2* *3* [String详解](https://blog.csdn.net/crazy_xieyi/article/details/124753245)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^koosearch_v1,239^v3^insert_chatgpt"}} ] [.reference_item] [ .reference_list ]

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值