BJFU|数据结构A（22下）实验3——严蔚敏版教材头歌系统

已于 2024-10-01 20:25:50 修改
阅读量1.2k 收藏 36
点赞数 5
文章标签： 数据结构 c++ 算法
于 2023-10-27 14:20:02 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CCCP_lus/article/details/134075227
版权

仅供课外学习使用，任何个人与机构不得利用此文章进行任何形式的作弊。

01基于BF算法的病毒感染检测

#include<iostream>
#include<fstream>
#include<string.h>
using namespace std;
#define MAXSIZE 2000

//- - - - - 串的堆式顺序存储结构- - - - - 
typedef struct
{   
   char *ch;				//若是非空串，则按串长分配存储区，否则ch为NULL   
   int length;			//串的当前长度   
}HString; 

int Index_BF(HString S,HString T,int pos)
{//返回模式T在主串S中第pos个字符开始第一次出现的位置。若不存在，则返回值为0 
 //其中，T非空，1≤pos≤StrLength(S) 
	int i = pos - 1, j = 0;
	while(i < S.length && j < T.length)
	{
		if(S.ch[i] == T.ch[j])
		{
			i++;
			j++;
		}
		else
		{
			i = i - j + 1;
			j = 0;
		}
	}
	if(j >= T.length) 
		return i - T.length + 1;
	else return 0;
} 


bool Virus_detection(HString Virus,HString Person)
{//判断是否匹配，如果可以，返回true，否则返回false 
//模式匹配算法调用Index_BF函数 
	bool flag = false;
	if(Index_BF(Person, Virus, 1))
		return true;
	for(int i = 0; i <= Virus.length; i++)
	{
		char c = Virus.ch[0];
		for(int j = 1; j < Virus.length; j++)
			Virus.ch[j - 1] = Virus.ch[j];
		Virus.ch[Virus.length - 1] = c;
		if(Index_BF(Person, Virus, 1))
		{
			flag = true;
			break;
		}
	}
	return flag;
}

int main()
{
	 int num,m,flag,i,j; char Vir[1000];
    HString Virus,Person;
    char a[MAXSIZE],b[MAXSIZE];//a存入病毒的DNA序列，b存入人的DNA序列
	 while(cin>>a>>b)
	{
	   Virus.ch=new char[1000];
      Person.ch=new char[1000];
	   if(strcmp(a,"0")==0&&strcmp(b,"0")==0)
         break;
	   strcpy(Virus.ch,a);
	   strcpy(Person.ch,b);
      Virus.length=strlen(Virus.ch);
	   Person.length=strlen(Person.ch);
      if(Virus_detection(Virus,Person))
         cout<<"YES"<<endl;
      else
         cout<<"NO"<<endl;

    }//while
	return 0;
}

02基于BF算法的网络入侵检测

#include "iostream"
#include "cstring"
#include<stdlib.h>
using namespace std;


#define MAXLEN 5000			//串的最大长度
typedef struct{   
   char *ch;			//存储串的一维数组
   int length;				//串的当前长度   
}HString;


void InputRule(HString ip[],int n)
{//输入n条规则，并将其中的n个ip地址存放到ip数组 
	for(int i = 0; i < n; i++)
		ip[i].ch = new char[100];
	for(int i = 0; i < n; i++)
	{
		string ss; int a, b;
		getline(cin, ss);
		for(int j = 0; j < (int)ss.length(); j++)
		{
			if(ss[j] == ':' && ss[j - 1] == 'p')
				a = j + 1;
			if(ss[j] == ' ' && ss[j + 1] == 'm')
				b = j - 1;
		}
		for(int j = a, k = 0; j <= b; j++, k++)
		{
			ip[i].ch[k] = ss[j];
			ip[i].length = b - a + 1;
		}
	}
}

void InputLog(HString &log,int m)
{//输入m条日志，并合并存放到log
	delete log.ch;
	log.ch=(char *)malloc(sizeof(char)*10000);
	string s;
	for(int i = 0; i < m; i++)
	{
		string ss;
		getline(cin, ss);
		s += ss;
	}
	for(int i = 0; i < (int)s.length(); i++)
		log.ch[i] = s[i];
	log.length = (int)s.length();
}

int Index_BF(HString S, HString T)
{//简单模式匹配算法,S为主串(目标串)，T为子串(模式串)。
//匹配成功返回主串中所含子串第一次出现的位置，否则返回-1。
	int i = 0, j = 0;
	while(i < S.length && j < T.length)
	{
		if(S.ch[i] == T.ch[j])
		{
			i++;
			j++;   	
		}
		else
		{
			i = i - j + 1;
			j = 0;
		}
   	}
   	if(j >= T.length) 
		return i - T.length;
   	else return -1;
}

int main()
{
	int n,m;
    cin>>n>>m;
    getchar();
    

    HString ip[5000];//ip数组存放n个ip地址 
    InputRule(ip,n);

    HString log;
	 log.ch=(char *)malloc(sizeof(char)*5000);	//这里开小了 
    strcpy(log.ch,"");
    log.length=0;
    InputLog(log,m);
    
    for(int i=0;i<n;i++)
    {
        if(Index_BF(log,ip[i])!= -1)
        {
            cout<<"Intrusion."<<endl;
            return 0;
        }
    }
    cout<<"No Intrusion."<<endl;
    return 0;
    
}

03基于KMP算法的网络入侵检测

#include "iostream"
#include "cstring"
#include<stdlib.h>
using namespace std;


#define MAXLEN 5000			//串的最大长度
typedef struct{   
   char *ch;			//存储串的一维数组
   int length;				//串的当前长度   
}HString;


void InputRule(HString ip[],int n)
{//输入n条规则，并将其中的n个ip地址存放到ip数组 
	for(int i = 0; i < n; i++)
		ip[i].ch = new char[100];
	for(int i = 0; i < n; i++)
	{
		string ss; int a, b;
		getline(cin, ss);
		for(int j = 0; j < (int)ss.length(); j++)
		{
			if(ss[j] == ':' && ss[j - 1] == 'p')
				a = j + 1;
			if(ss[j] == ' ' && ss[j + 1] == 'm')
				b = j - 1;
		}
		for(int j = a, k = 0; j <= b; j++, k++)
		{
			ip[i].ch[k] = ss[j];
			ip[i].length = b - a + 1;
		}
	}
}

void InputLog(HString &log,int m)
{//输入m条日志，并合并存放到log，返回log的length
	delete log.ch;
	log.ch=(char *)malloc(sizeof(char)*10000);
	string s;
	for(int i = 0; i < m; i++)
	{
		string ss;
		getline(cin, ss);
		s += ss;
	}
	for(int i = 0; i < (int)s.length(); i++)
		log.ch[i] = s[i];
	log.length = (int)s.length();
}

void GetNext(HString pattern,int* next)
{//求模式串pattern的next函数值并存入数组next
	next[0] = -1;
	int k = -1;
	for(int q = 1; q <= pattern.length; q++)
	{
		while(k > -1 && pattern.ch[k + 1] != pattern.ch[q])
			k = next[k];
		if(pattern.ch[k + 1] == pattern.ch[q])
			k++;
		next[q] = k;
	}
}

int Index_KMP(HString target,HString pattern,int* next)
{//KMP匹配算法,target为主串，pattern为子串。
//匹配成功返回主串中所含子串第一次出现的位置，否则返回-1。
//调用GetNext函数获取模式串的next数组
	GetNext(pattern, next);
	int k = -1, i = 0;
	for(i = 0; i < target.length; i++)
	{
		while(k > -1 && pattern.ch[k + 1] != target.ch[i])
			k = next[k];
		if(pattern.ch[k + 1] == target.ch[i])
			k++;
		if(k == pattern.length - 1)
			return i - pattern.length + 1;
	}
	return -1;
}

int main()
{
	int n,m;
    cin>>n>>m;
    getchar();
    

    HString ip[5000];//ip数组存放n个ip地址 
    InputRule(ip,n);

    HString log;
	log.ch=(char *)malloc(sizeof(char)*5000);
    strcpy(log.ch,"");
    log.length=0;
    InputLog(log,m);
    
    for(int i=0;i<n;i++)
    {
    	int *next=new int[ip[i].length];
        if(Index_KMP(log,ip[i],next)!= -1)
        {
            cout<<"Intrusion."<<endl;
            return 0;
        }
    }
    cout<<"No Intrusion."<<endl;
    return 0;
    
}

04基于BM算法的网络入侵检测

#include<iostream>
#include<string>
#include "cstring"
using namespace std;

#define ASCII_SIZE 256     //ASCII码共256位，可表示所有字符，作为坏字符数组的大小
#define MAXLEN 5000			//串的最大长度
typedef struct{   
   char *ch;				   //存储串的一维数组
   int length;				   //串的当前长度   
}HString;

void InputRule(HString ip[],int n)
{//将输入的n个ip地址存放到ip数组
	for(int i = 0; i < n; i++)
		ip[i].ch = new char[100];
	for(int i = 0; i < n; i++)
	{
		string ss; int a, b;
		getline(cin, ss);
		for(int j = 0; j < (int)ss.length(); j++)
		{
			if(ss[j] == ':' && ss[j - 1] == 'p')
				a = j + 1;
			if(ss[j] == ' ' && ss[j + 1] == 'm')
				b = j - 1;
		}
		for(int j = a, k = 0; j <= b; j++, k++)
		{
			ip[i].ch[k] = ss[j];
			ip[i].length = b - a + 1;
		}
	}
}

void InputLog(HString &log,int m)
{//将输入的m条日志合并存放到log，返回log的总长度
	delete log.ch;
	log.ch=(char *)malloc(sizeof(char)*10000);
	string s;
	for(int i = 0; i < m; i++)
	{
		string ss;
		getline(cin, ss);
		s += ss;
	}
	for(int i = 0; i < (int)s.length(); i++)
		log.ch[i] = s[i];
	log.length = (int)s.length();
}

void getBC(HString pattern,int *bc)
{//得到坏字符bc数组
	for (int i = 0; i < ASCII_SIZE; i++)
	{
		bc[i] = -1;
	}

	for (int i = 0; i < pattern.length; i++)
	{
		bc[(int)pattern.ch[i]] = i;
	}
}

void getGS(HString pattern,int *suffix,bool *prefix)
{//得到好后缀gs，其中suffix为int类型数组存储后缀字符对应前面的位置，prefix为bool类型数组存储是否存在匹配的前缀字符串
//suffix和prefix共同构成好后缀数组
//	suffix = new int[MAXLEN];
//	prefix = new bool[MAXLEN];
	int n = pattern.length;
	for (int i = 0; i < n - 1; i++)
	{
		suffix[i] = -1;
		prefix[i] = false;
	}

	for (int i = 0; i < n - 1; i++)
	{
		int j = i;
		int k = 0;
		while (j >= 0 && pattern.ch[j] == pattern.ch[n - 1 - k])
		{
			j--;
			k++;
			suffix[k] = j + 1;
		}
		if (j == -1)
			prefix[k] = true;
	}
}

int getGSMove(int *suffix,bool *prefix,int bc_pos,int pattern_length)
{//利用suffix和prefix数组，返回好后缀移动的次数
//bc_pos表示坏字符BC的位置（后一位为好后缀起点位置）
	int len = pattern_length - bc_pos - 1;
	if (suffix[len] != -1)
	{
		return bc_pos + 1 - suffix[len];
	}

	for (int i = bc_pos + 2; i < pattern_length; i++)
	{
		if (prefix[pattern_length - i])
			return i;
	}
	return 0;
}

int Index_BM(HString str,HString pattern)
{//在str.ch中匹配pattern.ch，匹配成功返回主串中所含子串第一次出现的位置，否则返回-1。
//分别求坏字符数组bc和好字符数组suffix、prefix，分别计算两个策略的移动位数，取大值作为最终移动位数
	int n = str.length;
	int m = pattern.length;
	int bc[ASCII_SIZE];
	int* suffix = new int[m];
	bool* prefix = new bool[m];

	getBC(pattern, bc);
	getGS(pattern, suffix, prefix);

	int i = 0;
	while (i <= n - m)
	{
		int j = 0;
		for (j = m - 1; j >= 0; j--)
		{
			if (pattern.ch[j] != str.ch[i + j])
				break;
		}
		if (j < 0)
		{
			delete suffix;
			delete prefix;
			return i;
		}
		else     
		{
			int numBc = j - bc[(int)str.ch[i + j]];
			int numGs = 0;
			if (j < m - 1)
			{
				numGs = getGSMove(suffix, prefix, m, j);
			}
			i += numBc > numGs ? numBc : numGs;
		}
	}
	delete suffix;
	delete prefix;
	return -1;
}

int main()
{
	 int n,m;
    cin>>n>>m;
    getchar();
    HString ip[5000];	//ip数组存放n个ip地址 
    InputRule(ip,n);	   //输入n行规则，从规则中找到所有的ip地址，保存至ip数组中

    HString log;
	 log.ch=(char *)malloc(sizeof(char)*5000);
    strcpy(log.ch,"");	//将log.ch初始化为空字符串
    log.length=0;
    InputLog(log,m);	//输入m行日志，将m行日志合并为1个长日志并保存至log中，返回长日志log的长度
    
    for(int i=0;i<n;i++)
    {
        if(Index_BM(log,ip[i])!=-1)		//返回值不为-1则匹配成功
        {
            cout<<"Intrusion."<<endl;
            return 0;
        }
    }
    cout<<"No Intrusion."<<endl;
    return 0;

}

05统计字符出现的频度

#include<iostream>
#include<cstring>
using namespace std;
void Count(string c,int b[])
{//统计字符出现的频度
	for(int i = 0; i < (int)c.length(); i++)
	{
		if(isdigit(c[i]))
		{
			b[(int)c[i] - 48]++;
		}
		else
		{
			b[(int)c[i] - 65 + 10]++;
		}
	}
	for(int i = 0; i < 36; i++)
	{
		if(b[i])
		{
			if(i < 10)
				cout << i << ":" << b[i] << endl;
			if(i >= 10)
			{
				char c = (char)(i + 65 - 10);
				cout << c << ":" << b[i] << endl;
			}
		}
	}
}

int main()
{
    string c;     //存储输入的字符串
    while(cin>>c)
    {
        if(c=="0") break;
        int *b=new int[36]{0};        	//存储对应字符的个数
        Count(c,b);
    }
    return 0;
}

06递归实现字符串的逆序存储

#include<iostream>
#include<cstring>
#define MAXSIZE 100
using namespace std;
void Reverse(char *a,int n)
{//递归实现字符串的逆序存储
	if((int)strlen(a) / 2 == n)
		return ;
	else
	{
		char t;
		t = a[n - 1];
		a[n - 1] = a[(int)strlen(a) - n];
		a[(int)strlen(a) - n] = t;
		Reverse(a, --n);
	}
}

int main()
{
	char a[MAXSIZE];
	while(cin>>a)
	{
		if(strcmp(a,"0")==0) break;
		int i=0;
		while(a[i]!='\0') i++;  //统计字符数
		Reverse(a,i);
		cout<<a<<endl;  //输出字符数组
	}
	return 0;
}

07字符串的插入

#include<iostream>
#define MAXSIZE 100
using namespace std;
void Insert(char s[],char t[],int pos,int LenS,int LenT)
{//字符串的插入
	for(int i = LenS - 1 + LenT; i >= pos - 1 + LenT; i--)
		s[i] = s[i - LenT];
	for(int i = pos - 1, j = 0; j < LenT; i++, j++)
		s[i] = t[j];
	s[LenS + LenT] = '\0';
	cout << s << endl;
}

int main()
{
    int pos;
    while(cin>>pos)    	              //输入插入位置pos
    {
        if(pos<=0) break;
        char s[MAXSIZE],t[MAXSIZE];
        cin>>s>>t;            	     //输入字符串s和t
        int LenS=0,LenT=0;
        while(s[LenS]!='\0') LenS++;  //求字符串s的长度LenS
        while(t[LenT]!='\0') LenT++;  //求字符串t的长度LenT
        if(pos>LenS) break;           //插入位置非法
        Insert(s,t,pos,LenS,LenT);
    }
    return 0;
}

08查找子串第一次出现的位置

#include<iostream>
#include<string.h>
using namespace std;
int strstr(string s1,string s2)
{//查找子串第一次出现的位置
	int i = 0, j = 0;
	while(i < (int)s1.length() && j < (int)s2.length())
	{
		if(s1[i] == s2[j])
		{
			i++;
			j++;   	
		}
		else
		{
			i = i - j + 1;
			j = 0;
		}
   	}
   	if(j >= (int)s2.length()) 
		return i - s2.length();
   	else return -1;
}

using namespace std;

int main()
{
	string s1, s2;
	while(cin>>s1>>s2)
	{
	    if (s1=="0"&&s2=="0") break;
        int pos=strstr(s1,s2);
        cout<<pos<<endl;
	}
	return 0;
}

CresCent_Charles
关注
专栏目录
BJFU_OJ系统数据结构习题目录
雪地行进
11-27 2万+
欢迎登录北京林业大学OJ系统 http://www.bjfuacm.com 持续补充中 黑色标题意味代码未完成 204基于顺序存储结构的图书信息表的创建和输出 205基于顺序存储结构的图书信息表的排序 206基于顺序存储结构的图书信息表的修改 207基于顺序存储结构的图书信息表的逆序存储 208基于顺序存储结构的图书信息表的最贵图书的查找 209基于顺序存储结构的图书信息表的最爱图书的查找 210...
BJFU_数据结构习题_239猴子选大王
雪地行进
10-12 1662
239猴子选大王 描述 一堆猴子都有编号，编号是1，2，3 …m，这群猴子（m个）按照1~m的顺序围坐一圈，从第1开始数，每数到第n个，该猴子就要离开此圈，这样依次下来，直到圈中只剩下最后一只猴子，则该猴子为大王。利用单向循环链表模拟此过程，依次输出出圈的猴子编号。 输入 多组数据，每组数据占一行，包括两个数据m和n。m代表猴子个数，n代表步数，m=0且n=0时输入结束。 输出 依次输出出圈的猴子...
KMP算法之病毒检测
浦柳人的博客
04-16 6291
什么是KMP算法？ KMP算法是一种改进的字符串匹配算法，由D.E.Knuth，J.H.Morris和V.R.Pratt同时发现，因此人们称它为克努特——莫里斯——普拉特操作（简称KMP算法）。KMP算法的关键是利用匹配失败后的信息，尽量减少模式串与主串的匹配次数以达到快速匹配的目的。具体实现就是实现一个next()函数，函数本身包含了模式串的局部匹配信息。时间复杂度O(m+n)。 （通俗的说就是...
数据结构：串：第2关：基于KMP算法的网络入侵检测
qq_74118294的博客
10-26 1521
Snort自1998年被发明以来，历经数年的迭代更新，Snort已成为一个具有多平台(Multi-Platform)、实时(Real-Time)流量分析、网络IP数据包(Pocket)记录等特性的强大的网络入侵检测/防御系统(Network Intrusion Detection/Prevention System)，即NIDS/NIPS。输出一行，若检在网络日志中检测到任何一条检测规则中的ip地址，则输出“Intrusion.”，反之输出“No Intrusion.”。
KMP算法解决病毒检测问题
m0_59089055的博客
10-28 1903
你知道了串的匹配算法，如何解决实际问题呢？ 可以进来看看
KMP(字符串匹配)算法
08-20
程序开发过程中的字符串匹配算法很多，这里出了算法的程序源代码，包括C#，C++, Delphi代码,大家直接下载就可以拷贝到自己程序中使用。
数据结构实验1必做部分OJ版-配套实验
06-12
1. 数据结构实验目的和要求：该文件描述了一系列数据结构实验的必做部分，这些实验是针对《数据结构（C语言版）》一书的相关章节内容设计的。实验的目的在于加深学习者对数据结构中线性表操作的理解和应用，特别是...
BJFU_数据结构习题_214基于链式存储结构的图书信息表的创建和输出
雪地行进
10-10 3958
214基于链式存储结构的图书信息表的创建和输出 描述 定义一个包含图书信息（书号、书名、价格）的链表，读入相应的图书数据来完成图书信息表的创建，然后统计图书表中的图书个数，同时逐行输出每本图书的信息。 输入 输入n+1行，其中前n行是n本图书的信息（书号、书名、价格），每本图书信息占一行，书号、书名、价格用空格分隔，价格之后没有空格。最后第n+1行是输入结束标志：0 0 0（空格分隔的三个0）。其...
[详细完整版]数据结构习题.pdf
07-11
数据结构是计算机科学中的核心概念，它涉及到如何高效地组织和管理数据，以便于执行各种操作。本习题集主要涵盖了栈、队列、串（字符串）等基础数据结构的相关知识。 1. 栈和队列是两种常用的数据结构，它们的共同...
数据结构BF和KMP算法
04-12
BF和KMP算法过程#include #include using namespace std; #define N 80 void main() { char S[N],T[N]; int i,j,count=0; cout<<"请输入长串S:"; gets(S); cout<<"请输入子串T:"; gets(T); i=0;j=0; while(count!=strlen(T)&&i<(strlen(S))) { if(S[i]==T[j]) {i++;j++,count++;} else {i++;j=0;count=0;} }
实验五 结构体和指针
weixin_51502608的博客
07-05 313
实验五 结构体和指针 1 实验目的 （1）学习如何使用结构体的指针作为函数的参数，通过传地址的方式，在被调用函数中修改主调函数中的多个结构体变量的方法。 （2）学习如何把逻辑结构相同的部分抽象为函数，以提高代码的可重用性，达到提高程序的可维护性的目的。 2 实验内容 2.1 模拟画图功能 问题描述 模拟计算机的画图功能，能够模拟画圆和长方形的功能。程序主要功能如下： ① 提供一个如下的主菜单。 \1. Circle (圆) \2. Rectangle (长方形) \0. Exit (退出)
基于K-means聚类算法的入侵检测系统的设计
qq_33270873的博客
10-30 5852
基于K-means聚类算法的入侵检测系统的设计   今天给大家讲述的是K-means聚类算法在入侵检测系统中的应用首先，介绍一下 聚类算法 将认识对象进行分类是人类认识世界的一种重要方法，比如有关世界的时间进程的研究，就形成了历史学，有关世界空间地域的研究，则形成了地理学。 又如在生物学中，为了研究生物的演变，需要对生物进行分类，生物学家根据各种生物的特征，将它们归属于不同的界、门、纲、
编程题实训-串
a61233的博客
11-11 4454
医学研究者最近发现了某些新病毒，通过对这些病毒的分析，得知它们的DNA序列都是环状的。现在研究者收集了大量的病毒DNA和人的DNA数据，想快速检测出这些人是否感染了相应的病毒。为方便研究，研究者将人的DNA和病毒的DNA均表示成由一些小写字母组成的字符串，然后检测某种病毒的DNA序列是否在患者的DNA序列中出现过，如果出现过，则此人感染了病毒，否则没有感染。注意：人的DNA序列是线性的，而病毒的DNA序列是环状的。请使用BF算法检测人是否感染相应病毒。
采用 KMP 算法编程实现病毒感染检测算法
xiepeng1013的博客
04-12 5368
采用 KMP 算法编程实现病毒感染检测算法
基于字符串模式匹配算法的病毒感染检测问题（KMP算法）
Cap07博客
11-15 7683
头文件（tou.h）： void get_next(char T[], int next[]); int Index_KMP(char S[], char T[]); void move1(char a[]); void transform(char a[]); void Judge(char S[], char T[]); 头文件中函数的实现（tou.cpp）： #define _CRT_SECURE_NO_WARNINGS #include<stdio.h> #incl
力扣LeetCode-回溯法
weixin_56005963的博客
02-16 641
回溯法 基本知识 1. 思想 穷举所有可能，选出想要的答案。 2. 解决的问题 组合问题：N个数中按一定规则找出k个数的集合； 切割问题：一个字符串按一定规则有几种切割方式； 子集问题：一个N个数的集合中有多少符合条件的子集； 排列问题：N个数按一定规则全排列，有几种排列方式； 棋盘问题：N皇后，解数独； 3. 模板 void backtracking(参数){ if(终止条件){ 存放结果; return...
（JAVA）队列 和 符号表 两种数据结构的实现
最新发布
ZunXin_2580的博客
09-27 617
如果想要清晰的认识队列或者符号表是怎样的结构，那么就来看看这篇文章吧！！
[数据结构] 二叉树题目(一)
nmbg11的博客
09-27 479
leetcode有关二叉树的相关题目. 翻转二叉树. 相同的树. 对称二叉树.
bjfu数据结构图书管理系统
09-09
bjfu数据结构图书管理系统是一个基于线性表的图书信息管理系统。它包括了创建和输出图书信息表、排序、修改、逆序村春、最贵图书的查找、最爱图书的查找、最佳位置图书的查找、新图书的入库、旧图书的出库、图书去重等常用的基本操作。该系统使用了顺序存储结构和链式存储结构来实现。 该系统的设计参考了《数据结构习题解析与实验指导》一书中的第一个实验。 其中，图书去重的实现是通过遍历图书信息表，对于重复的图书进行删除。具体的实现代码如下： ``` void DeleteRepeatInformation(table *T) { int flag; for(int i=0;i<T->length;i++){ for(int j=i+1;j<T->length;j++){ if(strcmp(T->date[i].name,T->date[j].name)==0){ DeleteInformation(T,j+1); j=j-1; } } } } ``` 该函数会删除重复的图书，保留第一本出现的图书。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

CresCent_Charles

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值