链串的实现C++封装

最新推荐文章于 2022-05-12 21:16:26 发布
最新推荐文章于 2022-05-12 21:16:26 发布
阅读量811 收藏 8
点赞数 3
分类专栏： C++学习之路 数据结构 数据结构基础算法 文章标签： 数据结构 class C++ 算法 链串
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/j_anson/article/details/49051129
版权

链串的实现比顺序串稍复杂，但都大同小异，若掌握好有关链表的操作，则也非常简单。本文将先给出链串的算法，最后给出完整例子。

链串算法说明

定义链串的数据节点类

//数据节点
class Node
{
public:
	char data;
	class Node *next;
};


定义链串类，尾插法生成新串，私有数据成员为Node *S; 

	//生成串(尾插法实现)
	void StrAssign(char str[]){
		int i;
		Node *r, *p;
		S = (Node *)malloc(sizeof(Node));
		r = S;
		//生成链
		for (i = 0; str[i] != '\0'; i++){
			p = (Node *)malloc(sizeof(Node));
			p->data = str[i];
			r->next = p;
			r = p;
		}
		r->next = NULL;
	}

链串的构造和析构，构造函数无需做任何其他的事，析构函数中销毁链串 

	//构建
	String(){}
	//析构
	~String(){
		Node *pre = S, *p = pre->next;
		while (p != NULL){
			free(pre);
			pre = p;
			p = p->next;
		}
		free(p);
	}

复制串 

	//复制串
	void StrCopy(String *str){
		Node *r, *p;
		Node *t = str->GetS()->next;
		S = (Node *)malloc(sizeof(Node));
		r = S;
		while (t != NULL){
			p = (Node *)malloc(sizeof(Node));
			p->data = t->data;
			r->next = p;
			r = p;
			t = t->next;
		}
		r->next = NULL;
	}


判断是否相等 

	//是否相等
	bool isEqual(String *str){
		Node *p = S->next, *t = str->GetS()->next;
		//遍历判断
		while (p != NULL&&t != NULL&&p->data == t->data){
			p = p->next;
			t = t->next;
		}
		//若满足条件则相等
		if (p == NULL&&t == NULL){
			return true;
		}
		//否则不相等
		else{
			return false;
		}
	}
求串长度 

	//串长度
	int StrLength(){
		int i = 0;
		Node *p = S->next;
		//头结点不存储数据
		while (p != NULL){
			i++;
			p = p->next;
		}
		return i;
	}

串拼接 

	//串拼接,尾插法建立新串，返回其地址
	Node * Concat(String *t){
		Node *str, *p = S->next, *r, *q;
		str = (Node *)malloc(sizeof(Node));
		r = str;
		//复制S串
		while (p != NULL){
			q = (Node *)malloc(sizeof(Node));
			q->data = p->data;
			r->next = q;
			r = q;
			p = p->next;
		}
		//复制t串
		p = t->GetS()->next;
		while (p != NULL){
			q = (Node *)malloc(sizeof(Node));
			q->data = p->data;
			r->next = q;
			r = q;
			p = p->next;
		}
		r->next = NULL;
		return str;
	}
求子串 

	//求子串，返回串S中从位置i开始开始的j个字符，参数不正确时饭后空串，尾插法生成新串，返回地址
	Node * SubStr(int i, int j){
		Node *str, *r, *p, *q = S->next;
		int k = 0;
		str = (Node *)malloc(sizeof(Node));
		r = str;
		//下标处理，不合法返回空串
		if (i <= 0 || i > StrLength() || j <= 0 || i + j - 1 > StrLength()){
			r->next = NULL;
			return str;
		}
		else{
			//定位到位置i
			for (k = 0; k < i - 1; k++){
				q = q->next;
			}
			//复制字符，产生新串
			for (k = 0; k < j;k++){
				p = (Node *)malloc(sizeof(Node));
				p->data = q->data;
				r->next = p;
				r = p;
				q = q->next;
			}
			r->next = NULL;
			return str;
		}
	}

插入串 

	//插入串s1到串S的位置i开始处，尾插法产生新串，参数不正确时返回空串，返回新串地址
	Node * InsertStr(String *s1, int i){
		Node *q = S->next, *r, *p, *str;
		int j;
		str = (Node *)malloc(sizeof(Node));
		r = str;
		//下标不合法，返回空串
		if (i <= 0 || i > StrLength()){
			r->next = NULL;
			return str;
		}
		//产生新串
		else{
			//复制S前i个字符
			for (j = 0; j < i - 1; j++){
				p = (Node *)malloc(sizeof(Node));
				p->data = q->data;
				r->next = p;
				r = p;
				q = q->next;
			}
			//插入串s1
			Node *sq = s1->GetS()->next;
			while (sq != NULL){
				p = (Node *)malloc(sizeof(Node));
				p->data = sq->data;
				r->next = p;
				r = p;
				sq = sq->next;
			}
			//复制S串剩下所有字符
			while (q != NULL){
				p = (Node *)malloc(sizeof(Node));
				p->data = q->data;
				r->next = p;
				r = p;
				q = q->next;
			}
			r->next = NULL;
			return str;
		}
	}

删除串 

	//删除串,将串S中从位置i开始的j个字符删除,生成新串并返回地址，参数错误时返回空串
	Node * DeleteStr(int i, int j){
		Node *str, *q = S->next, *r, *p;
		str = (Node *)malloc(sizeof(Node));
		r = str;
		//下标不合法，返回空串
		if (i <= 0 || i > StrLength() || j<0 || i + j - 1>StrLength()){
			r->next = NULL;
			return str;
		}
		//生成新串
		else{
			int k;
			//插入S前i个字符
			for (k = 0; k < i - 1; k++){
				p = (Node *)malloc(sizeof(Node));
				p->data = q->data;
				r->next = p;
				r = p;
				q = q->next;
			}
			//跳过j个节点
			for (k = 0; k < j; k++){
				q = q->next;
			}
			//插入剩下所有
			while (q != NULL){
				p = (Node *)malloc(sizeof(Node));
				p->data = q->data;
				r->next = p;
				r = p;
				q = q->next;
			}
			r->next = NULL;
			return str;
		}
	}

替换串 

	//替换串,将S串中位置i开始的j个字符替换成串t，产生新串，返回地址，参数不正确时返回空串
	Node * ReplaceStr(int i, int j, String *t){
		Node *str, *r, *p, *q = S->next;
		str = (Node *)malloc(sizeof(Node));
		r = str;
		//下标不合法，返回空串
		if (i <= 0 || i > StrLength() || j<0 || i + j - 1>StrLength()){
			r->next = NULL;
			return str;
		}
		//产生新串
		else{
			int k;
			//插入串S前i个字符
			for (k = 0; k < i - 1; k++){
				p = (Node *)malloc(sizeof(Node));
				p->data = q->data;
				r->next = p;
				r = p;
				q = q->next;
			}
			//插入串t
			Node *pt = t->GetS()->next;
			while (pt != NULL){
				p = (Node *)malloc(sizeof(Node));
				p->data = pt->data;
				r->next = p;
				r = p;
				pt = pt->next;
			}
			//跳过S中j个字符
			for (k = 0; k < j; k++){
				q = q->next;
			}
			//插入S中剩下所有
			while (q != NULL){
				p = (Node *)malloc(sizeof(Node));
				p->data = q->data;
				r->next = p;
				r = p;
				q = q->next;
			}
			r->next = NULL;
			return str;
		}
	}

输出串 

	//输出串——无参数（类私有数据）
	void DisplayStr(){
		Node *p = S->next;
		while (p != NULL){
			cout << p->data;
			p = p->next;
		}
		cout << endl;
	}
	//输出串——有参数（接收局部变量产生的串）
	void DisplayStr(Node *str){
		Node *p = str->next;
		while (p != NULL){
			cout << p->data;
			p = p->next;
		}
		cout << endl;
	}

获取链串的串首地址函数，该函数不属于链串的算法，但在C++封装后可方便访问 

	//获取串首地址
	Node * GetS(){
		return S;
	}

以上便是链串的所有算法的实现，下面给出C++封装的完整例子 

/*
链式存储串的实现
*/
#include<iostream>
using namespace std;
const int MAX_N = 100;
//数据节点
class Node
{
public:
	char data;
	class Node *next;
};

//链串
class String
{
public:
	//构建
	String(){}
	//析构
	~String(){
		Node *pre = S, *p = pre->next;
		while (p != NULL){
			free(pre);
			pre = p;
			p = p->next;
		}
		free(p);
	}
	//生成串(尾插法实现)
	void StrAssign(char str[]){
		int i;
		Node *r, *p;
		S = (Node *)malloc(sizeof(Node));
		r = S;
		//生成链
		for (i = 0; str[i] != '\0'; i++){
			p = (Node *)malloc(sizeof(Node));
			p->data = str[i];
			r->next = p;
			r = p;
		}
		r->next = NULL;
	}

	//复制串
	void StrCopy(String *str){
		Node *r, *p;
		Node *t = str->GetS()->next;
		S = (Node *)malloc(sizeof(Node));
		r = S;
		while (t != NULL){
			p = (Node *)malloc(sizeof(Node));
			p->data = t->data;
			r->next = p;
			r = p;
			t = t->next;
		}
		r->next = NULL;
	}

	//是否相等
	bool isEqual(String *str){
		Node *p = S->next, *t = str->GetS()->next;
		//遍历判断
		while (p != NULL&&t != NULL&&p->data == t->data){
			p = p->next;
			t = t->next;
		}
		//若满足条件则相等
		if (p == NULL&&t == NULL){
			return true;
		}
		//否则不相等
		else{
			return false;
		}
	}
	//串长度
	int StrLength(){
		int i = 0;
		Node *p = S->next;
		//头结点不存储数据
		while (p != NULL){
			i++;
			p = p->next;
		}
		return i;
	}
	//串拼接,尾插法建立新串，返回其地址
	Node * Concat(String *t){
		Node *str, *p = S->next, *r, *q;
		str = (Node *)malloc(sizeof(Node));
		r = str;
		//复制S串
		while (p != NULL){
			q = (Node *)malloc(sizeof(Node));
			q->data = p->data;
			r->next = q;
			r = q;
			p = p->next;
		}
		//复制t串
		p = t->GetS()->next;
		while (p != NULL){
			q = (Node *)malloc(sizeof(Node));
			q->data = p->data;
			r->next = q;
			r = q;
			p = p->next;
		}
		r->next = NULL;
		return str;
	}
	//求子串，返回串S中从位置i开始开始的j个字符，参数不正确时饭后空串，尾插法生成新串，返回地址
	Node * SubStr(int i, int j){
		Node *str, *r, *p, *q = S->next;
		int k = 0;
		str = (Node *)malloc(sizeof(Node));
		r = str;
		//下标处理，不合法返回空串
		if (i <= 0 || i > StrLength() || j <= 0 || i + j - 1 > StrLength()){
			r->next = NULL;
			return str;
		}
		else{
			//定位到位置i
			for (k = 0; k < i - 1; k++){
				q = q->next;
			}
			//复制字符，产生新串
			for (k = 0; k < j;k++){
				p = (Node *)malloc(sizeof(Node));
				p->data = q->data;
				r->next = p;
				r = p;
				q = q->next;
			}
			r->next = NULL;
			return str;
		}
	}
	//插入串s1到串S的位置i开始处，尾插法产生新串，参数不正确时返回空串，返回新串地址
	Node * InsertStr(String *s1, int i){
		Node *q = S->next, *r, *p, *str;
		int j;
		str = (Node *)malloc(sizeof(Node));
		r = str;
		//下标不合法，返回空串
		if (i <= 0 || i > StrLength()){
			r->next = NULL;
			return str;
		}
		//产生新串
		else{
			//复制S前i个字符
			for (j = 0; j < i - 1; j++){
				p = (Node *)malloc(sizeof(Node));
				p->data = q->data;
				r->next = p;
				r = p;
				q = q->next;
			}
			//插入串s1
			Node *sq = s1->GetS()->next;
			while (sq != NULL){
				p = (Node *)malloc(sizeof(Node));
				p->data = sq->data;
				r->next = p;
				r = p;
				sq = sq->next;
			}
			//复制S串剩下所有字符
			while (q != NULL){
				p = (Node *)malloc(sizeof(Node));
				p->data = q->data;
				r->next = p;
				r = p;
				q = q->next;
			}
			r->next = NULL;
			return str;
		}
	}
	//删除串,将串S中从位置i开始的j个字符删除,生成新串并返回地址，参数错误时返回空串
	Node * DeleteStr(int i, int j){
		Node *str, *q = S->next, *r, *p;
		str = (Node *)malloc(sizeof(Node));
		r = str;
		//下标不合法，返回空串
		if (i <= 0 || i > StrLength() || j<0 || i + j - 1>StrLength()){
			r->next = NULL;
			return str;
		}
		//生成新串
		else{
			int k;
			//插入S前i个字符
			for (k = 0; k < i - 1; k++){
				p = (Node *)malloc(sizeof(Node));
				p->data = q->data;
				r->next = p;
				r = p;
				q = q->next;
			}
			//跳过j个节点
			for (k = 0; k < j; k++){
				q = q->next;
			}
			//插入剩下所有
			while (q != NULL){
				p = (Node *)malloc(sizeof(Node));
				p->data = q->data;
				r->next = p;
				r = p;
				q = q->next;
			}
			r->next = NULL;
			return str;
		}
	}
	//替换串,将S串中位置i开始的j个字符替换成串t，产生新串，返回地址，参数不正确时返回空串
	Node * ReplaceStr(int i, int j, String *t){
		Node *str, *r, *p, *q = S->next;
		str = (Node *)malloc(sizeof(Node));
		r = str;
		//下标不合法，返回空串
		if (i <= 0 || i > StrLength() || j<0 || i + j - 1>StrLength()){
			r->next = NULL;
			return str;
		}
		//产生新串
		else{
			int k;
			//插入串S前i个字符
			for (k = 0; k < i - 1; k++){
				p = (Node *)malloc(sizeof(Node));
				p->data = q->data;
				r->next = p;
				r = p;
				q = q->next;
			}
			//插入串t
			Node *pt = t->GetS()->next;
			while (pt != NULL){
				p = (Node *)malloc(sizeof(Node));
				p->data = pt->data;
				r->next = p;
				r = p;
				pt = pt->next;
			}
			//跳过S中j个字符
			for (k = 0; k < j; k++){
				q = q->next;
			}
			//插入S中剩下所有
			while (q != NULL){
				p = (Node *)malloc(sizeof(Node));
				p->data = q->data;
				r->next = p;
				r = p;
				q = q->next;
			}
			r->next = NULL;
			return str;
		}
	}
	//输出串——无参数（类私有数据）
	void DisplayStr(){
		Node *p = S->next;
		while (p != NULL){
			cout << p->data;
			p = p->next;
		}
		cout << endl;
	}
	//输出串——有参数（接收局部变量产生的串）
	void DisplayStr(Node *str){
		Node *p = str->next;
		while (p != NULL){
			cout << p->data;
			p = p->next;
		}
		cout << endl;
	}
private:
	Node *S;

	//获取串首地址
	Node * GetS(){
		return S;
	}
};
int main()
{
	int i, n, locate, strlength;
	char a[MAX_N];
	//生成串
	cout << "Create String." << endl;
	cout << "Input Length:";
	cin >> n;
	cout << "Input " << n << " characters." << endl;
	for (i = 0; i < n; i++){
		cin >> a[i];
	}
	a[i] = '\0';
	String str1;
	str1.StrAssign(a);
	//输出串
	cout << "Diaplay String." << endl;
	str1.DisplayStr();
	//拷贝串
	cout << "Copy String." << endl;
	cout << "Input n:";
	cin >> n;
	cout << "Input " << n << " characters." << endl;
	for (i = 0; i < n; i++){
		cin >> a[i];
	}
	a[i] = '\0';
	String str2;
	str2.StrAssign(a);
	str1.StrCopy(&str2);
	str1.DisplayStr();
	//是否相等
	cout << "Is Equal." << endl;
	cout << "Input n:";
	cin >> n;
	cout << "Input " << n << " characters." << endl;
	for (i = 0; i < n; i++){
		cin >> a[i];
	}
	a[i] = '\0';
	str2.StrAssign(a);
	if (str1.isEqual(&str2)){
		cout << "YES." << endl;
	}
	else{
		cout << "NO." << endl;
	}
	//串长度
	cout << "String Length." << endl;
	cout << str1.StrLength() << endl;
	//连接串
	cout << "Concat String." << endl;
	cout << "Input n:" << endl;
	cin >> n;
	cout << "Input " << n << " characters." << endl;
	for (i = 0; i < n; i++){
		cin >> a[i];
	}
	a[i] = '\0';
	str2.StrAssign(a);
	str1.DisplayStr(str1.Concat(&str2));
	//获取子串
	cout << "Get SubStr." << endl;
	cout << "Input locate, string length:";
	cin >> locate >> strlength;
	str1.DisplayStr(str1.SubStr(locate, strlength));
	//插入串
	cout << "Insert String." << endl;
	cout << "Input n:";
	cin >> n;
	cout << "Input " << n << " characters." << endl;
	for (i = 0; i < n; i++){
		cin >> a[i];
	}
	a[i] = '\0';
	str2.StrAssign(a);
	cout << "Input locate:";
	cin >> locate;
	str1.DisplayStr(str1.InsertStr(&str2,locate));
	//删除串
	cout << "Delete String." << endl;
	cout << "Input locate,string length:";
	cin >> locate >> strlength;
	str1.DisplayStr(str1.DeleteStr(locate, strlength));
	//替换串
	cout << "Replace String." << endl;
	cout << "Input n:";
	cin >> n;
	cout << "Input " << n << " characters." << endl;
	for (i = 0; i < n; i++){
		cin >> a[i];
	}
	a[i] = '\0';
	str2.StrAssign(a);
	cout << "input locate, string length:";
	cin >> locate >> strlength;
	str1.DisplayStr(str1.ReplaceStr(locate, strlength, &str2));
	return 0;
}

测试结果







J_Anson
关注
专栏目录
C++数据结构 ---- 链串
Jade1998
07-13 509
环境配置 codeblocks windows10 项目结构 代码 LinkStringClass.h #ifndef _LINKSTRINGCLASS_H_ #define _LINKSTRINGCLASS_H_ #include <iostream> class LinkStringNode { public: char data; LinkStringN...
简单实现基于C++的COM组件创建与DLL封装
the_best_me_andu的博客
02-19 4120
简单实现基于C++的COM组件创建与DLL封装，包括组件、COM、COM组件、DLL等基本概念与关系，使用C++进行COM组件创建与DLL封装调用等的简单实现。
c++实现的一个链式串
anwenling5845的博客
09-27 337
链式串类LinkString源码: #pragma once class StringNode { public: char element; StringNode *next; }; class LinkString { public: LinkString(void) { top = n...
第八周项目二C/C++数据结构之自建算法库——链串
JING727708672的博客
10-19 361
/* *Copyright(c)2017,烟台大学计算机与控制工程学院 *All rights reserved. *作 者：高晶 *完成日期：2017年10月19日 *版 本 号：v1.0 *问题描述:自建算法库——链串 */ 链串算法库采用程序的多文件组织形式，包括两个文件： 1.头文件：liString.h，包含定义链串数据结构的代码、宏定义、要实现算法的函数的声明； #i
链串实现功能（初始化、判断空串、串的赋值、串的连接、获取子串）
weixin_30950887的博客
05-10 353
#include<stdio.h>#include<stdlib.h> typedef struct Node{ char ch; struct Node *next;}linkstr; //初始化int Initlinkstr(linkstr *sl){ sl = (linkstr *)malloc(sizeof(linkstr)); if(sl != NULL){ ...
C++实现链串的基本数据结构
m0_56644364的博客
05-12 551
链串
C++ 链接mysql 代码 简易封装和简单的一些使用方法
04-23
通过这种方式，C++开发者可以轻松地与MySQL数据库进行交互，实现数据的读写和管理。不过，请确保在使用后关闭数据库连接，避免资源泄露。同时，记得对敏感信息如用户名和密码进行安全处理，避免明文存储。
用C++开源库cryptopp 封装的Aes对称加密
03-12
本篇文章将深入探讨如何使用C++开源库Cryptopp来封装Aes对称加密，并且特别关注如何在Android和Java平台上实现该功能。 Cryptopp是一个强大的、免费的C++类库，提供了多种加密、解密、哈希和伪随机数生成算法，包括...
mysql c++ 封装类
11-18
MySQL C++ 封装类是将MySQL数据库的接口与C++编程语言相结合，提供一个更加友好、方便的接口供开发者使用。在Windows环境下，这样的封装类通常会编译成动态链接库（DLL），使得其他C++项目可以方便地调用其中的函数...
Linux下c++封装好的百度车牌识别库，只支持二进制数据输入
10-27
本文将详细解析如何在Ubuntu 16.04.4上使用C++封装百度车牌识别库，并重点讲解涉及的技术点。 首先，标题中的"Linux下c++封装好的百度车牌识别库"意味着开发者已经编写了一个C++库，该库能够调用百度的车牌识别API...
链式串的实现 数据结构
11-29
数据结构课程设计 链式串的实现 c语言实现
字符串封装
06-21
为满足string库函数的功能，自己创建函数，并封装在一起，满足字符串的各项功能。
实现链串的各种基本运算的算法c语言,!实现链串各种基本运算的算法
weixin_39985820的博客
05-25 437
/*algo4-2.cpp*/#include#includetypedef struct snode{char data;struct snode *next;}LiString;void StrAssign(LiString * &s,char t[]){int i;LiString *r,*p;s=(LiString *)malloc(sizeof(LiString));s->...
链串的表示和实现（C语言）
mu66mu的博客
01-15 1182
/* * linkstr.c * * Created on: 2019年1月13日 * Author: Jinjin */ /*解决Symbol 'NULL' could not be resolved问题*/ #ifndef NULL #define NULL ((void *) 0) #endif /**/ typedef struct node { char ...
链串的部分功能实现
hinson0710的博客
11-03 153
#include <iostream> #include <malloc.h> #include <stdio.h> #include <cstring> using namespace std; typedef struct snode { char data; struct snode *next; }LinkStrNode; void StrAssign(LinkStrNode *&s,char cstr[])//生成串儿 {...
串 链式实现
yuweilong000的专栏
08-21 505
#ifndef STR_H_INCLUDED #define STR_H_INCLUDED struct node {     char data;     struct node*next; }; typedef struct node* str; str Initial(str t)              //初始化 {     return NULL;
《数据结构》-链串的表示和实现
tyustli
02-23 290
#include <string.h> #include <malloc.h> #include <stdio.h> #include <stdlib.h> #define TRUE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define INFEASIBLE -1 typedef int ...
字符串的封装
春秋繁露
04-27 5059
这里的代码主要实现了字符串常用的所有操作，在不使用库函数的前提下，自己实现库函数的功能，可以很好的锻炼自己的编程能力和逻辑思维能力。
【练习】块链串的实现
time-space的博客
10-22 2815
为了方便串的操作，当以链表存储串值时，除表头指针外，还可附设一个尾指针来指示链表中的最后一个结点，并给出当前串的长度。这样的串存储结构称为块链结构。
C++封装：静态/动态链接库实战与MFC应用
总结来说，C++封装的动态链接库和静态链接库技术在C++编程中扮演着至关重要的角色，开发者需要根据项目需求选择合适的方法来实现代码的复用和性能优化。理解和熟练掌握这些概念对于构建高效、模块化的软件至关重要。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值