数据结构串操作源代码
实验三串基本操作的编程实现
实验三串基本操作的编程实现引言:串是由零个或多个字符组成的有限序列,是一种非常基础也非常重要的数据结构。
在本实验中,我们将学习串的基本操作,并使用C语言来实现这些操作。
1.实验目的:-掌握串的基本操作,包括串的初始化、判空、求长度、复制和拼接等操作;-学会使用C语言编程实现串的基本操作。
2.实验内容:本实验主要包括以下几个串的基本操作的编程实现。
2.1串的初始化操作在C语言中,我们可以使用字符数组来表示一个串。
以下是一个串的初始化操作的实现代码:```c#include <stdio.h>void InitString(char s[], char str[])int i;for (i = 0; str[i] != '\0'; i++)s[i] = str[i];}s[i]='\0';int maichar s[20];char str[] = "Hello, World!";InitString(s, str);printf("Initialized string: %s\n", s);return 0;```2.2串的判空操作判空操作即判断一个串是否为空串。
如果一个串的长度为0,则表示该串为空串。
以下是一个判空操作的实现代码示例:```c#include <stdio.h>#include <stdbool.h>bool IsEmptyString(char s[])return s[0] == '\0';int maichar s[20] = ""; // 空串if (IsEmptyString(s))printf("The string is empty.\n");} elseprintf("The string is not empty.\n");}return 0;```2.3串的长度操作求串的长度,即求一个串中字符的个数。
数据结构 串 实验报告
实验报告实验名称:串实验目的:(1)、熟悉C语言的上机环境,进一步掌握C语言的结构特点;(2)、掌握串的定义及C语言实现;(3)、掌握串的模式匹配及C语言实现;(4)、掌握串的各种基本操作;实验步骤:(1)、建立链串类型(2)、实现匹配过程中需考虑的链表的特征。
实验内容:4.一个字符串中的任意一个子序列,若子序列中各字符值均相同,则成为字符平台。
写一算法,输入任意以字符串S,输出S中长度最大的所有字符平台的起始位置及所含字符。
注意,最大字符平台有可能不止一个。
实验数据记录:(源代码及执行过程)#include<stdio.h>#include<stdlib.h>#define Maxsize 20#define n 100typedef struct Node{int element[Maxsize];int front;int rear;}Queue;int EnterQueue(Queue *Q,int x){if((Q->rear+1)%Maxsize == Q->front){printf("队列已满!\n");return 0;}Q->element[Q->rear] = x;Q->rear = (Q->rear+1)%Maxsize;return 1;}int DeleQueue(Queue *Q,int *x){if(Q->front == Q->rear){printf("队列为空!\n");return 0;}*x = Q->element[Q->front];Q->front = (Q->front+1)%Maxsize;return 1;}int Donull(Queue *Q){while(Q->front != Q->rear){Q->element[Q->front] = 0;Q->front = (Q->front+1)%Maxsize;}Q->front = Q->rear = 0;if(Q->front == Q->rear){return 1;}else{return 0;}}int main(void){char str[n];int i=0,j=1,k=1,ch,p=1,flag=1;Queue *Q;Q = (Queue *)malloc(sizeof(Queue));Q->front = Q->rear = 0;printf("请输入字符串:");gets(str);while('\0' != *(str+i)){ while(*(str+i+1) == *(str+i)){if(flag){p = i;flag = 0;}i++;j++;}if(flag){p = i;}if(j >= k){if(j > k){Donull(Q);k = j;}if(EnterQueue(Q ,j) == 0)break;if(EnterQueue(Q,p+1) == 0)break;if(EnterQueue(Q,*(str+i)) == 0)break;}j=1;i++;flag = 1;} while(Q->front < Q->rear){DeleQueue(Q,&j);DeleQueue(Q,&k);DeleQueue(Q,&ch);printf("%-10d",k);for(i = 0; i < j; i++){printf("%c",ch);}printf("\n");}printf("\n");system("pause");}。
数据结构上机实验源代码
数据结构上机实验源代码栈的应用十进制数转换为八进制数,逆序输出所输入的数实验代码://stack.h,头文件class stack{public:stack();bool empty()const;bool full()const;error_code gettop(elementtype &x)const;error_code push(const elementtype x);error_code pop();private:int count;elementtype data[maxlen];};stack::stack(){count=0;}bool stack::empty()const{return count==0;}bool stack::full()const{return count==maxlen;}error_code stack::gettop(elementtype &x)const{if(empty())return underflow;else{x=data[count-1];return success;}}error_code stack::push(const elementtype x){if(full())return overflow;data[count]=x;count++;return success;}error_code stack::pop(){if(empty())return underflow;count--;return success;}//主程序#include<iostream.h>enum error_code{overflow,underflow,success};typedef int elementtype;const int maxlen=20;#include"stack.h"void read_write() //逆序输出所输入的数{stack s;int i;int n,x;cout<<"please input num int n:";cin>>n;for(i=1;i<=n;i++){cout<<"please input a num:";cin>>x;s.push(x);}while(!s.empty()){s.gettop(x);cout<<x<<" ";s.pop();}cout<<endl;}void Dec_to_Ocx(int n) //十进制转换为八进制{stack s1;int mod,x;while(n!=0){mod=n%8;s1.push(mod);n=n/8;}cout<<"the ocx of the dec is:";while(!s1.empty()){s1.gettop(x);cout<<x;s1.pop();}cout<<endl;}void main(){int n;// read_write();cout<<"please input a dec:";cin>>n;Dec_to_Ocx(n);}队列的应用打印n行杨辉三角实验代码://queue.hclass queue{public:queue(){count=0;front=rear=0;}bool empty(){return count==0;}bool full(){return count==maxlen-1;}error_code get_front(elementtype &x){if(empty())return underflow;x=data[(front+1)%maxlen];return success;}error_code append(const elementtype x){if(full())return overflow;rear=(rear+1)%maxlen;data[rear]=x;count++;return success;}error_code serve(){if(empty())return underflow;front=(front+1)%maxlen;count--;return success;}private:int count;int front;int rear;int data[maxlen];};//主程序#include<iostream.h>enum error_code{overflow,underflow,success};typedef int elementtype;const int maxlen=20;#include"queue.h"void out_number(int n) //打印前n行的杨辉三角{int s1,s2;int i;int j;int k;queue q;for(i=1;i<=(n-1)*2;i++)cout<<" ";cout<<"1 "<<endl;q.append(1);for(i=2;i<=n;i++){s1=0;for(k=1;k<=(n-i)*2;k++)cout<<" ";for(j=1;j<=i-1;j++){q.get_front(s2);q.serve();cout<<s1+s2<<" ";q.append(s1+s2);s1=s2;}cout<<"1 "<<endl;q.append(1);}}void main(){int n;cout<<"please input n:";cin>>n;out_number(n);}单链表实验实验目的:实验目的(1)理解线性表的链式存储结构。
数据结构实验报告串
一、实验目的1. 理解串的概念和性质;2. 掌握串的基本操作,如连接、赋值、求长度、定位等;3. 熟悉串的两种存储结构:顺序存储和链式存储;4. 能够实现串的简单应用,如字符串匹配、子串查找等。
二、实验环境1. 操作系统:Windows 102. 编程语言:C++3. 开发环境:Visual Studio 2019三、实验内容1. 串的定义和性质2. 串的顺序存储结构3. 串的链式存储结构4. 串的基本操作5. 字符串匹配算法6. 子串查找算法四、实验步骤1. 定义串的数据结构```cpp#define MAX_SIZE 100typedef struct {char data[MAX_SIZE];int length;} StrString;```2. 实现串的基本操作```cpp// 初始化串void InitString(StrString &S) {S.length = 0;}// 赋值操作void AssignString(StrString &S, StrString T) { for (int i = 0; i < T.length; i++) {S.data[i] = T.data[i];}S.length = T.length;}// 求长度操作int Length(StrString S) {return S.length;}// 定位操作int Index(StrString S, StrString T, int pos) { int i, j;i = pos;for (j = 0; j < T.length && i < S.length; j++, i++) { if (S.data[i] != T.data[j]) {i = i - j;j = 0;}}if (j == T.length) {return i - T.length + 1;}return 0;}```3. 实现字符串匹配算法```cpp// 字符串匹配算法(KMP算法)int KMPMatch(StrString S, StrString T) {int i, j;int next[T.length];// 构建next数组for (i = 1, j = 0; i < T.length; i++) {while (j > 0 && T.data[i] != T.data[j]) {j = next[j - 1];}if (T.data[i] == T.data[j]) {j++;}next[i] = j;}// 匹配过程i = 0;j = 0;while (i < S.length && j < T.length) { if (S.data[i] == T.data[j]) {i++;j++;} else if (j > 0) {j = next[j - 1];} else {i++;}}if (j == T.length) {return i - j;}return 0;}```4. 实现子串查找算法```cpp// 子串查找算法(朴素算法)int SubStringMatch(StrString S, StrString T) {int i, j;for (i = 0; i <= S.length - T.length; i++) {j = 0;while (j < T.length && S.data[i + j] == T.data[j]) {j++;}if (j == T.length) {return i;}}return 0;}```五、实验结果与分析1. 初始化串、赋值操作、求长度操作、定位操作均能正常执行,符合预期。
数据结构与算法实验源代码
数据结构与算法实验源代码数据结构与算法实验源代码1.实验目的本实验旨在通过实践,加深对数据结构与算法的理解与应用能力,掌握数据结构和算法的基本概念与原理,并能够运用所学知识解决实际问题。
2.实验材料●一台已安装好编译器的计算机●数据结构与算法实验源代码文件3.实验环境配置在实验开始之前,必须确保计算机上已安装好以下环境:●编译器(可以是C++、Java等)●数据结构与算法实验源代码文件4.实验内容及步骤4.1 实验一:线性表4.1.1 实验目的通过实现线性表的相关操作,加深对线性表及其操作的理解,并能够灵活应用。
4.1.2 实验步骤1.实现线性表的初始化函数2.实现线性表的插入操作3.实现线性表的删除操作4.实现线性表的查找操作5.实现线性表的排序操作6.实现线性表的输出操作7.编写测试代码,对线性表进行测试4.1.3 实验结果与分析进行若干测试用例,验证线性表的正确性,并分析算法的时间复杂度与空间复杂度。
4.2 实验二:栈与队列4.2.1 实验目的通过实现栈与队列的相关操作,加深对栈与队列的理解,并掌握栈与队列的应用场景。
4.2.2 实验步骤1.实现栈的初始化函数2.实现栈的入栈操作3.实现栈的出栈操作4.实现栈的查看栈顶元素操作5.实现队列的初始化函数6.实现队列的入队操作7.实现队列的出队操作8.实现队列的查看队首元素操作4.2.3 实验结果与分析进行若干测试用例,验证栈与队列的正确性,并分析算法的时间复杂度与空间复杂度。
(继续添加实验内容及步骤,具体根据实验项目和教学要求进行详细分析)5.实验附件本文档所涉及的实验源代码文件作为附件随文档提供。
6.法律名词及注释6.1 版权:著作权法所规定的权利,保护作品的完整性和原创性。
6.2 开源:指软件可以被任何人免费使用、分发和修改的一种软件授权模式。
(继续添加法律名词及注释)。
数据结构24点游戏源代码
#include<stdio.h>#include<string.h>#include<stdlib.h>#include<time.h>#define OPSETSIZE 7#define STACK_INIF_SIZE 50#define STACKINCREMENT 10int number[2][4];enum{eNumber = 0, //操作数eOperator = 1 //算子};int oper[7]={43,45,42,47,40,41,35};char OPSET[OPSETSIZE]={'+' , '-' , '*' , '/' ,'(' , ')' , '#'};typedef struct sqlist{int bol;//bol 是0 时,num-ch是一个数字;bol 是1 时num_ch 运算符int num_ch;struct sqlist *next;}sqlist;//线性表typedef struct sqstack{int *base;int *top;int stacksize;}sqstack;//栈的定义unsigned char Prior[7][7] = {// 课本表3.1 算符间的优先关系'>','>','<','<','<','>','>','>','>','<','<','<','>','>','>','>','>','>','<','>','>','>','>','>','>','<','>','>','<','<','<','<','<','=',' ','>','>','>','>',' ','>','>','<','<','<','<','<',' ','='};int init_sq(sqlist *l){//初始化链表l=(sqlist*)malloc(sizeof(sqlist));if(l==NULL){exit(-2);}l->next=NULL;return 1;}int insert_sq(sqlist **p,int e,int bl){//链表插入操作sqlist *q;q=(sqlist*)malloc(sizeof(sqlist));q->num_ch=e;q->bol=bl;q->next=NULL;(*p)->next=q;(*p)=(*p)->next;return 1;}int check(sqlist l)//保证输入的数字是给出的四个数字{int right=1,find=0,i;sqlist *q=&l;q=q->next ;for (;q->next!=NULL;q=q->next){if(q->bol==1){if(q->num_ch <=39||q->num_ch>57||q->num_ch==44||q->num_ch==46){ right=0;printf("%c不是有效的运算符!\n");}}else {find=0;for(i=0;i<4;i++){if(number[1][i]==0&&number[0][i]==q->num_ch ){number[1][i]=1;find=1;break;}}if(find==0){printf("%d 不在给出的四个数字中!\n",q->num_ch );right=0;}}}//end forfor (i=0;i<4;i++){if(number[1][i]==0){printf("%d没有用上!\n",number[0][i]);right=0;}}return right;}int chang(char *s,sqlist *l){//将用户的输入转化为单链表int t=0;unsigned int i=0;int bl,ch;int a1,a2,a;sqlist *p=l;for (;i<strlen(s);i++){if(s[i]>47&&s[i]<58&&t==0){a1=(int)s[i]-48;t++;}else if(s[i]>47&&s[i]<58&&t==1){a2=(int)s[i]-48;a=a1*10+a2;t++;}else if(s[i]<48&&s[i]>39&&s[i]!=44&&s[i]!=46){if(t==1){bl=0;insert_sq(&p,a1,bl);t=0;}else if(t==2){bl=0;insert_sq(&p,a,bl);t=0;}bl=1;ch=(int)s[i];insert_sq(&p,ch,bl);t=0;}else {printf("%c不是有效的运算符!\n",s[i]);}} //end fori=strlen(s)-1;if(s[i]>47&&s[i]<58){if(s[i-1]>47&&s[i-1]<58){bl=0;insert_sq(&p,a,bl);}else {bl=0;insert_sq(&p,a1,bl);}}bl=1;a=35;insert_sq(&p,a,bl);return (check(*l));}int Operate(int a,int theta, int b){//计算switch(theta) {case 43: return a+b;case 45: return a-b;case 42: return a*b;case 47:{if(b==0){return -2000;}if (a%b==0){return a/b;}else {//printf("不能为小数\n");return -10000;}}default : return 0;}}int ReturnOpOrd(char op,char* TestOp)// precede()函数调用求优先级{int i;for(i=0; i< OPSETSIZE; i++){if (op == TestOp[i]) return i;}return 0;}char precede(char Aop, char Bop){return Prior[ReturnOpOrd(Aop,OPSET)][ReturnOpOrd(Bop,OPSET)];}int initstack(sqstack *s){(s)->base = (int*)malloc(STACK_INIF_SIZE*sizeof(int));if((s)->base==NULL) exit(-2);(s)->top=(s)->base;(s)->stacksize = STACK_INIF_SIZE;return 1;}int gettop(sqstack *s){ //取得栈顶元素int e;if(s->top==s->base){printf("栈空,无法取得栈顶元素!\n");return 0;}e=*(s->top-1);return e;}int push(sqstack *s,int e){ //压栈if(s->top-s->base>=s->stacksize){s->base=(int*)realloc(s->base,(s->stacksize+STACKINCREMENT)*sizeof(int));if(!s->base) exit(-2);s->stacksize+= STACKINCREMENT;}*(s->top++)=e;return 1;}int pop(sqstack *s,int *e){ //出栈if(s->top==s->base){printf("栈空,出栈错误!\n");return 0;}*e=*(--s->top);return 1;}int EvaluateExpression(char* MyExpression) { // 算法3.4----计算表达式的值// 算术表达式求值的算符优先算法。
数据结构三元组c语言源代码
数据结构三元组c语言源代码数据结构三元组C语言源代码在计算机科学领域,数据结构是一种组织和存储数据的方式,它可以让我们更高效地管理和处理数据。
在数据结构中,三元组是一种常用的结构,它由三个元素组成,分别对应于一个事物的不同方面。
在C 语言中,我们可以使用结构体来实现三元组。
首先,我们需要定义一个结构体来表示三元组。
在下面的代码中,我们定义了一个名为`triple`的结构体,它有三个成员变量分别为`a`,`b`和`c`。
```ctypedef struct {int a;double b;char c;} triple;```这个结构体中,`a`表示整型变量,`b`表示双精度浮点型变量,`c`表示字符型变量。
我们可以根据需要更改这些类型,以便适应特定的数据需求。
接下来,我们可以使用三元组结构体来创建存储数据的具体实例。
在下面的代码片段中,我们定义了一个名为`example`的三元组,它的第一,二,三个元素分别为1、3.14和'A'。
```ctriple example = { 1, 3.14, 'A' };```我们还可以定义一个函数来根据用户提供的数据创建一个新的三元组实例。
在下面的代码片段中,我们创建了一个名为`create_triple`的函数,并定义一个名为`new_triple`的三元组变量,它的元素根据用户输入而定。
```ctriple create_triple() {triple new_triple;printf("请输入一个整数:");scanf("%d", &new_triple.a);printf("请输入一个双精度浮点数:");scanf("%lf", &new_triple.b);printf("请输入一个字符:");scanf(" %c", &new_triple.c);return new_triple;}```最后,我们可以在程序中使用定义好的结构体和函数来处理我们的数据。
《数据结构》的全部代码实现C语言
/* c1.h (程序名) */#include<string.h>#include<ctype.h>#include<malloc.h> /* malloc()等*/#include<limits.h> /* INT_MAX等*/#include<stdio.h> /* EOF(=^Z或F6),NULL */#include<stdlib.h> /* atoi() */#include<io.h> /* eof() */#include<math.h> /* floor(),ceil(),abs() */#include<process.h> /* exit() *//* 函数结果状态代码*/#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEASIBLE -1/* #define OVERFLOW -2 因为在math.h中已定义OVERFLOW的值为3,故去掉此行*/ typedef int Status; /* Status是函数的类型,其值是函数结果状态代码,如OK等*/ typedef int Boolean; /* Boolean是布尔类型,其值是TRUE或FALSE *//* algo2-1.c 实现算法2.1的程序*/#include"c1.h"typedef int ElemType;#include"c2-1.h"/*c2-1.h 线性表的动态分配顺序存储结构*/#define LIST_INIT_SIZE 10 /* 线性表存储空间的初始分配量*/#define LISTINCREMENT 2/* 线性表存储空间的分配增量*/typedef struct{ElemType*elem; /* 存储空间基址*/int length; /* 当前长度*/int listsize; /* 当前分配的存储容量(以sizeof(ElemType)为单位) */}SqList;#include"bo2-1.c"/* bo2-1.c 顺序表示的线性表(存储结构由c2-1.h定义)的基本操作(12个) */ Status InitList(SqList*L) /* 算法2.3 */{ /* 操作结果:构造一个空的顺序线性表*/(*L).elem=(ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemType));if(!(*L).elem)exit(OVERFLOW); /* 存储分配失败*/(*L).length=0; /* 空表长度为0 */(*L).listsize=LIST_INIT_SIZE; /* 初始存储容量*/return OK;}Status DestroyList(SqList*L){ /* 初始条件:顺序线性表L已存在。
顺序串的基本操作
《数据结构》实验#include<stdio.h>#include<string.h>#define maxnum 100typedef struct{char str[maxnum];int length;}SString;void creat(SString &s){printf("请输入主串s:\n");gets(s.str);s.length=strlen(s.str);}void Strcopy(SString &t,SString &f){int i;printf("请输入串f:\n");gets(f.str);f.length=strlen(f.str);for(i=0;i<f.length;i++){t.str[i]=f.str[i];}printf("字符串复制成功!\n");}int Strcompare(SString s,SString &t){ int i,j,k;i=0;j=0;printf("请输入要比较的串:\n");gets(t.str);t.length=strlen(t.str);while(i<s.length&&j<t.length){if(s.str[i]==t.str[i]){i++;j++;}else{return k=s.str[i]-t.str[i];}}if(j==t.length)return k=s.length-t.length;else i++;j++;return k;}void concat(SString &sub,SString s,SString &t){ int i,j;printf("请输入要联接的串:\n");gets(t.str);t.length=strlen(t.str);if(s.length+t.length<maxnum) {for(i=0;i<s.length;i++)sub.str[i]=s.str[i];for(j=0;j<t.length;j++)sub.str[j+s.length]=t.str[j]; sub.length=s.length+t.length; }else if(s.length<maxnum){for(i=0;i<s.length;i++)sub.str[i]=s.str[i];for(j=0;j<maxnum-s.length;j++) sub.str[j+s.length]=t.str[j]; sub.length=maxnum;}else{for(i=0;i<maxnum;i++)sub.str[i]=s.str[i];sub.length=maxnum;}}void Insert(SString &s,SString &t){ int i,j,k;t.length=strlen(t.str);printf("请输入要插入的位置:\n"); scanf("%d",&j);for(i=j-1;i<s.length;i++){s.str[i+t.length]=s.str[i];}for(k=0,i=j-1;i<j+t.length-1;i++) {s.str[i]=t.str[k];k++;}s.length+=t.length;printf("字符串插入成功:\n");}void Delete(SString &s){int i,j,len;printf("请输入要删除的位置:\n"); scanf("%d",&j);printf("请输入要删除串的长度:\n"); scanf("%d",&len);for(i=j-1+len;i<s.length;i++){s.str[i-len]=s.str[i];}s.length-=len;}void print(SString &s){int i;for(i=0;i<s.length;i++){printf("%c ",s.str[i]);}}void main(){SString s,a,b,c,d,e,f;int x;char y;creat(s);do{printf("请输入要操作的项:\n");printf("*****************************************\n");printf("* 2字符串的复制。
数据结构与算法实验源代码
数据结构与算法实验源代码数据结构与算法实验源代码一、实验目的本实验旨在通过编写数据结构与算法的实验源代码,加深对数据结构与算法的理解,并提高编程能力。
二、实验环境本实验使用以下环境进行开发和测试:- 操作系统:Windows 10- 开发工具:IDEA(集成开发环境)- 编程语言:Java三、实验内容本实验包括以下章节:3.1 链表在本章节中,我们将实现链表数据结构,并实现基本的链表操作,包括插入节点、删除节点、查找节点等。
3.2 栈和队列在本章节中,我们将实现栈和队列数据结构,并实现栈和队列的基本操作,包括入栈、出栈、入队、出队等。
3.3 树在本章节中,我们将实现二叉树数据结构,并实现二叉树的基本操作,包括遍历树、搜索节点等。
3.4 图在本章节中,我们将实现图数据结构,并实现图的基本操作,包括广度优先搜索、深度优先搜索等。
3.5 排序算法在本章节中,我们将实现各种排序算法,包括冒泡排序、插入排序、选择排序、快速排序、归并排序等。
3.6 搜索算法在本章节中,我们将实现各种搜索算法,包括线性搜索、二分搜索、广度优先搜索、深度优先搜索等。
四、附件本文档附带实验源代码,包括实现数据结构和算法的Java源文件。
五、法律名词及注释5.1 数据结构(Data Structure):是指数据对象中数据元素之间的关系。
包括线性结构、树形结构、图形结构等。
5.2 算法(Algorithm):是指解决问题的一系列步骤或操作。
算法应满足正确性、可读性、健壮性、高效性等特点。
5.3 链表(Linked List):是一种常见的数据结构,由一系列节点组成,每个节点包含一个数据元素和一个指向下一个节点的指针。
5.4 栈(Stack):是一种遵循后进先出(LIFO)原则的有序集合,用于存储和获取数据。
5.5 队列(Queue):是一种遵循先进先出(FIFO)原则的有序集合,用于存储和获取数据。
5.6 树(Tree):是由节点组成的层级结构,其中一种节点作为根节点,其他节点按照父子关系连接。
数据结构源代码(全)
/*顺序表的操作#include<iostream>#include<stdlib.h>using namespace std;Release 13.12 rev 9501 (2013/12/25 19:25:45) gcc 4.7.1 Windows/unicode - 32 bit #define MAX_SIZE 100typedef struct{int *emel;int lenth;}Sq;void init(Sq &l);void create(Sq &l);void trval(Sq &l);void find_value(Sq &l);void find_position(Sq &l);void insert(Sq &l);void dele(Sq &l);int main(){Sq l;init(l);create(l);trval(l);find_value(l);find_position(l);insert(l);trval(l);dele(l);trval(l);return 0;}void init(Sq &l){l.emel =new int[MAX_SIZE];if(l.emel ==NULL){cout<<"\t申请空间失败!"<<endl;exit(1);}l.lenth=0;cout<<"\t成功申请空间!该顺序表的长度目前为:"<<l.lenth<<endl; }void create(Sq &l){cout<<"\t请输入你想输入元素的个数:";int x;cin>>x;if((x<1)&&(x>MAX_SIZE)){cout<<"\t你说输入的数不在范围里"<<endl;return;}int i;for(i=0;i<x;i++){cin>>l.emel[i];}l.lenth=x;cout<<"\t成功赋值!"<<endl;}void trval(Sq &l){int i;cout<<"l(";for(i=0;i<l.lenth;i++){cout<<l.emel[i]<<" ";}cout<<")"<<" 该顺序表现在的长度为:"<<l.lenth<<endl;}void find_value(Sq &l){int x,t=0;cout<<"\t请输入你要查找的值:";cin>>x;int i;for(i=0;i<l.lenth;i++){if(l.emel[i]==x){t=1;cout<<"\t成功找到该元素,它是顺序表的第"<<i+1<<"个元素!"<<endl;}}if(t==0){cout<<"\t无该元素!"<<endl;}}void find_position(Sq &l){int x;cout<<"\t请输入你要查找的位置:";cin>>x;int i;if((x<1)||(x>l.lenth)){cout<<"\t输入的值不在范围内!"<<endl;return;}for(i=1;i<=l.lenth;i++){if(i==x){cout<<"\t成功找到该元素,该值是"<<l.emel[i-1]<<endl;}}}void insert(Sq &l){int i,x,y;cout<<"\t请输入你要插入的位置";cin>>x;cout<<"\t请输入你要插入的值";cin>>y;if((x<1)||(x>l.lenth)){cout<<"\t输入的值不在范围内!"<<endl;return;}if(x==l.lenth){l.emel[l.lenth]=y;l.lenth=l.lenth+1;return;}for(i=l.lenth;i>=x;i--){l.emel[i]=l.emel[i-1];}l.emel[x-1]=y;l.lenth=l.lenth+1;}void dele(Sq &l){int i,x;cout<<"\t请输入你要删除位置:";cin>>x;if((x<1)||(x>l.lenth)){cout<<"\t输入的值不在范围内!"<<endl;return;}for(i=x-1;i<=l.lenth;i++){l.emel[i]=l.emel[i+1];}l.lenth=l.lenth-1;}成功申请空间!该顺序表的长度目前为:0请输入你想输入元素的个数:3852成功赋值!l(8 5 2 ) 该顺序表现在的长度为:3请输入你要查找的值:5成功找到该元素,它是顺序表的第2个元素!请输入你要查找的位置:3成功找到该元素,该值是2请输入你要插入的位置3请输入你要插入的值10l(8 5 2 10 ) 该顺序表现在的长度为:4请输入你要删除位置:3l(8 5 10 ) 该顺序表现在的长度为:3--------------------------------Process exited with return value 0Press any key to continue . . .*//*#include<stdio.h>#include<stdlib.h>typedef struct Link{int num;struct Link *next;}L;L* creat(L* head){head=(L *)malloc(sizeof(L));if(head==NULL){printf("头节点申请失败!\n");exit(-1);}head->next=NULL;return head;}void insert(L* head){int x,i;printf("请输入你想输入数据的个数:");scanf("%d",&x);L *p,*q;p=head;for(i=0;i<x;i++){q=(L *)malloc(sizeof(L));if(q==NULL){printf("新点申请失败!\n");exit(-1);}printf("请输入值:");scanf("%d",&q->num);q->next=NULL;p->next=q;p=q;}}void print(L* head){L *p;p=head->next;while(p!=NULL){printf("值为:%d\n",p->num);p=p->next;}}int main(){L *head;head=creat(head);printf("成功创建头节点!!!\n");insert(head);printf("成功输入数据!!!\n");print(head);return 0;}*//*线性表的操作#include<stdio.h>#include<stdlib.h>typedef struct Link{int num;struct Link *next;}L;L* creat(L* head){head=(L *)malloc(sizeof(L));if(head==NULL){printf("头节点申请失败!\n");exit(-1);}head->next=NULL;return head;}void init(L* head){int x,i;printf("请输入你想输入数据的个数:");scanf("%d",&x);L *p,*q;p=head;for(i=0;i<x;i++){q=(L *)malloc(sizeof(L));if(q==NULL){printf("新点申请失败!\n");exit(-1);}printf("请输入值:");scanf("%d",&q->num);q->next=p->next;p->next=q;}}int print(L* head){L *p;int lenth=0;p=head->next;printf("\t\tL(");while(p!=NULL){lenth++;printf("%d ",p->num);p=p->next;}printf(")\n");return lenth;}int insert(L *head,int lenth){printf("\t\t请输入你要插入的元素的位置:");int in;scanf("%d",&in);if(in<1 || in>lenth){printf("\t\t输入值不在范围内!");return -1;}L *p,*q;p=head->next;q=(L *)malloc(sizeof(L));if(q==NULL){printf("新点申请失败!\n");return -1;}printf("\t\t请为新节点输入值:");scanf("%d",&q->num);int i=0;while(p!=NULL){i++;if(i==in-1){q->next=p->next;p->next=q;}p=p->next;}lenth++;return lenth;}int dele(L *head,int lenth){printf("\t\t请输入你要删除的元素的位置:");int out;scanf("%d",&out);if(out<1 || out>lenth){printf("\t\t输入值不在范围内!");return -1;}L *p,*q;p=head->next;q=head;int i=0;while(p!=NULL){i++;if(i==out){q->next=p->next;}q=p;p=p->next;}lenth--;return lenth;}void find(L *head,int lenth){printf("\t\t请输入你要查找的元素的位置:");int finder;scanf("%d",&finder);if(finder<1 || finder>lenth){printf("\t\t输入值不在范围内!");return ;}L *p;p=head->next;int i=0;while(p!=NULL){i++;if(i==finder){printf("\t\t你要找的该位置所对应的值为:%d\n",p->num);}p=p->next;}}int main(){L *head;head=creat(head);printf("成功创建头节点!!!\n");init(head);printf("成功输入数据!!!\n");int len;len=print(head);printf("\t\t该线性表的长度为:%d\n",len);len=insert(head,len);len=print(head);printf("\t\t插入后线性表的长度为:%d\n",len);len=dele(head,len);len=print(head);printf("\t\t删除后该线性表的长度为:%d\n",len);find(head,len);return 0;}*//*顺序表的合并#include<iostream>using namespace std;struct LA{int *pa;int lenth;};struct LB{int *pb;int lenth;};struct LC{int *pc;int lenth;};void mergelist(LA la,LB lb,LC &lc);int main(){int x,y;LA la;LB lb;cout<<"\t\t请给线性表LA和LB指定长度:";cin>>x>>y;la.pa =new int(sizeof(int)*x);lb.pb =new int(sizeof(int)*y);int i;for(i=0;i<x;i++){cout<<"请输入表LA的值:";cin>>la.pa[i];}cout<<endl;la.lenth=x;for(i=0;i<y;i++){cout<<"请输入表LB的值:";cin>>lb.pb[i];}lb.lenth=y;cout<<"LA(";for(i=0;i<x;i++){cout<<la.pa[i]<<" ";}cout<<")"<<endl;cout<<"LB(";for(i=0;i<y;i++){cout<<lb.pb[i]<<" ";}cout<<")"<<endl;LC lc;mergelist(la,lb,lc);return 0;}void mergelist(LA la,LB lb,LC &lc){lc.lenth=la.lenth+lb.lenth;lc.pc=new int(sizeof(int)*lc.lenth);int *pa=la.pa,*pb=lb.pb,*pc=lc.pc;int *pa_last=la.pa+la.lenth-1;int *pb_last=lb.pb+lb.lenth-1;while(pa<=pa_last && pb<=pb_last){if(*pa <= *pb){*pc++=*pa++;}else{*pc++=*pb++;}}while(pa<=pa_last){*pc++=*pa++;}while(pb<=pb_last){*pc++=*pb++;}cout<<"LC(";int i=0;for(i=0;i<lc.lenth;i++){cout<<lc.pc[i]<<" ";}cout<<")"<<endl;}*///栈/*#include<iostream>using namespace std;#include<stdlib.h>#define MAXSIZE 100typedef struct{int *base;int *top;int stacksize;}Sqstack;int Initstack(Sqstack &s);void Push(Sqstack &s,int e);void StackTraverse(Sqstack &s);void Gettop(Sqstack &s);void Pop(Sqstack &s);int main(){Sqstack s;Initstack(s);cout<<"\t\t初始化栈成功!"<<endl;Push(s,2);cout<<"\t\t2入栈成功!"<<endl;Push(s,4);cout<<"\t\t4入栈成功!"<<endl;Push(s,6);cout<<"\t\t6入栈成功!"<<endl;Push(s,8);cout<<"\t\t8入栈成功!"<<endl;cout<<"\n由栈底至栈顶的元素为:";StackTraverse(s);Gettop(s);Pop(s);Gettop(s);return 0;}int Initstack(Sqstack &s){s.base=new int[MAXSIZE];if(s.base==NULL){exit(1);}s.top=s.base;s.stacksize=MAXSIZE;}void Push(Sqstack &s,int e){if(s.top-s.base==s.stacksize){exit(1);}*s.top++=e;}void StackTraverse(Sqstack &s){int *p=s.base,i=0;while(p<s.top){i++;cout<<*p++<<" ";}cout<<"\t\t栈的长度是"<<i<<endl;}void Gettop(Sqstack &s){if(s.base==s.top){exit(1);}cout<<"栈顶元素是:"<<*(s.top-1)<<endl; }void Pop(Sqstack &s){if(s.top==s.base){exit(1);}cout<<"出栈的第一个元素是:";cout<<*--s.top<<" "<<endl;}*///队列例题:/*#include<iostream>#include<stdlib.h>using namespace std;#define MAXQSIZE 100typedef struct{int *base;int front;int rear;}SqQueue;int InitQueue(SqQueue &q);int EnQueue(SqQueue &q,int x);int DeQueue(SqQueue &q);int main(){SqQueue q;InitQueue(q);EnQueue(q,1);EnQueue(q,3);EnQueue(q,5);EnQueue(q,7);DeQueue(q);DeQueue(q);DeQueue(q);DeQueue(q);return 0;}int InitQueue(SqQueue &q){q.base=new int[MAXQSIZE];if(q.base==NULL){exit(1);}q.front=0;q.rear=0;return 0;}int EnQueue(SqQueue &q,int x){if((q.rear+1)%MAXQSIZE==q.front){exit(0);}q.base[q.rear]=x;q.rear=(q.rear+1)%MAXQSIZE;return 0;}int DeQueue(SqQueue &q){if(q.front==q.rear){exit(0);}int x=q.base[q.front];q.front=(q.front+1)%MAXQSIZE;cout<<x<<endl;}*//*#include<iostream>#include<stdlib.h>using namespace std;typedef struct Qnode{int date;struct Qnode *next;}Qnode,*Queueptr;typedef struct{Queueptr front; //队头指针Queueptr rear; //队尾指针}LinkQueue;int InitQueue(LinkQueue &Q);void EnQueue(LinkQueue &Q,int e);void TrvalQueue(LinkQueue Q);void DeQueue(LinkQueue &Q);int main(){LinkQueue Q;InitQueue(Q);EnQueue(Q,1);cout<<"\t元素1入队成功!"<<endl;EnQueue(Q,3);cout<<"\t元素3入队成功!"<<endl;EnQueue(Q,5);cout<<"\t元素5入队成功!"<<endl;EnQueue(Q,7);cout<<"\t元素7入队成功!"<<endl;cout<<"\t队列的元素分别是:"<<endl;TrvalQueue(Q);cout<<"\t第一个出队的元素是:"<<endl;DeQueue(Q);cout<<"\n\t第一个元素出队完成之后队列中从队头至队尾的元素为:";TrvalQueue(Q);return 0;}int InitQueue(LinkQueue &Q){Q.rear=new Qnode;Q.front=Q.rear;if(Q.front==NULL){exit(0);}Q.front->next=NULL;return 0;}void EnQueue(LinkQueue &Q,int e){Qnode *p=new Qnode;if(!p){exit(1);}p->date=e;p->next=NULL;Q.rear->next=p; //连接Q.rear=p; //修改队尾指针}void TrvalQueue(LinkQueue Q){Qnode *p=Q.front->next;//队头元素while(Q.front!=Q.rear){cout <<p->date<<" ";Q.front=p;p=p->next;}cout<<endl;}void DeQueue(LinkQueue &Q){if(Q.front==Q.rear){return;}Qnode *p=Q.front->next;cout<<"\t"<<p->date<<endl;Q.front->next=p->next;if(Q.rear==p){Q.rear=Q.front;delete p;}}*//*//表达式求值#include<iostream>#include<stdlib.h>#include<stdio.h>using namespace std;#define MAXSIZE 100typedef struct{char *base;char *top;char num;}OPND; //数据栈typedef struct{char *base;char *top;char c;}OPTR; //符号栈int Initstack(OPND &op_n,OPTR &op_t);void Pushstack(OPND &op_n,char ch);void Pushstack(OPTR &op_t,char ch);char Popstack(OPND &op_n,char ch);char Popstack(OPTR &op_t,char ch);char Gettop(OPTR op_t);char Gettop(OPND op_n);int In(char ch);char Precede(char x,char y);char operate(char z,char x,char y);int main(){OPND op_n;OPTR op_t;Initstack(op_n,op_t);Pushstack(op_t,'#');char ch;char p;cin>>ch;while(ch!='#' || Gettop(op_t)!='#'){if(!In(ch)){Pushstack(op_n,ch);cin>>ch;}else{switch( Precede(Gettop(op_t),ch) ){case '<':Pushstack(op_t,ch);cin>>ch;break;case '>':char x,y,z;x=Popstack(op_t,x);y=Popstack(op_n,y);z=Popstack(op_n,z);Pushstack(op_n,operate(z,x,y));break;case '=':p=Popstack(op_t,p);cin>>ch;break;}}}cout<<"\t表达式结果是:"<<Gettop(op_n)<<endl;return 0;}int Initstack(OPND &op_n,OPTR &op_t){op_n.base=new char[MAXSIZE];op_t.base=new char[MAXSIZE];if((op_n.base==NULL) || (op_t.base==NULL)){exit(1);}op_n.top=op_n.base;op_t.top=op_t.base;op_n.num=MAXSIZE;op_t.c=MAXSIZE;return 0;}void Pushstack(OPND &op_n,char ch){if(op_n.top-op_n.base==op_n.num){return;}*op_n.top++=ch;cout<<ch<<" 入数字栈"<<endl;}void Pushstack(OPTR &op_t,char ch){if(op_t.top-op_t.base==op_t.c){return;}*op_t.top++=ch;cout<<ch<<" 入操作符"<<endl;}char Popstack(OPND &op_n,char ch)if(op_n.top==op_n.base){exit(1);}ch=*--op_n.top;cout<<ch<<" 出数字栈"<<endl;return ch;}char Popstack(OPTR &op_t,char ch){if(op_t.top==op_t.base){exit(1);}ch=*--op_t.top;cout<<ch<<" 出字符栈"<<endl;return ch;}char Gettop(OPTR op_t){char x;if(op_t.top==op_t.base){exit(1);}x=*(op_t.top-1);cout<<"得到操作符栈顶"<<x<<endl;return x;}char Gettop(OPND op_n){char x;if(op_n.top==op_n.base){exit(1);}x=*(op_n.top-1);cout<<"得到操作数栈顶"<<x<<endl;return x;}int In(char ch)if(ch=='+'||ch=='-'||ch=='*'||ch=='/'||ch=='('||ch==')'||ch=='#') {return 1;}else{return 0;}}char Precede(char x,char y){if(x=='+' || x=='-'){if(y=='+' || y=='-' || y==')' || y=='#'){return '>';}else{return '<';}}if(x=='*'||x=='/'){if(y=='('){return '<';}else{return '>';}}if(x=='('){if(y==')'){return '=';}else if(y=='+'||y=='-'||y=='*'||y=='/'||y=='('){return '<';}}if(x==')'){if(y!='('){return '>';}}if(x=='#'){if(y=='#'){return '=';}else if(y!=')'){return '<';}}}char operate(char z,char x,char y) {if(x=='+'){return (z-'0') + (y-'0')+48;}if(x=='-'){return (z-'0') - (y-'0')+48;}if(x=='*'){return (z-'0')* (y-'0')+48;}if(x=='/'){return (z-'0')/ (y-'0')+48;}}*//*#include<iostream>using namespace std;int main(){char a[10];char *b[10];char **c[10];return 0;}*//*#include<iostream>using namespace std;char f(char x,char y){return (x-'0') * (y-'0')+48;}int main(){char a='3',b='5';char p=f(a,b);cout<<p<<endl;return 0;}*///数列出队/*#include<iostream>#include<stdlib.h>using namespace std;typedef struct Qnode{int num;struct Qnode *next;}Qnode,*Queueptr;typedef struct{Queueptr front;Queueptr rear;}LinkQueue;int InitQueue(LinkQueue &Q);void EnQueue(LinkQueue &Q,int x); int DeQueue(LinkQueue &Q,int p); int main(){LinkQueue Q;InitQueue(Q);int x,i,y,num=0,e;cout<<"请输入总人数:";cin>>x;for(i=1;i<=x;i++){EnQueue(Q,i);}cout<<"请输入第几个数淘汰:";cin>>y;{for(i=0;i<y;i++){if(i!=y-1){e=DeQueue(Q,e);EnQueue(Q,e);}else{DeQueue(Q,e);num++;}}if(num==x-1){break;}}e=DeQueue(Q,e);cout<<"最后剩下的是:"<<e<<endl;return 0;}int InitQueue(LinkQueue &Q){Q.front=new Qnode;Q.rear=Q.front;if(Q.front==NULL){exit(1);}Q.front->next=NULL;}void EnQueue(LinkQueue &Q,int x){Qnode *p=new Qnode;if(!p){exit(1);}p->num=x;p->next=NULL;Q.rear->next=p;}int DeQueue(LinkQueue &Q,int e) {Qnode *p;if(Q.rear==Q.front){exit(0);}p=Q.front->next;e=p->num;Q.front->next=p->next;if(Q.rear==p){Q.front=Q.rear;}delete p;return e;}*//*二叉树#include<iostream>#include<stdlib.h>using namespace std;typedef struct BiTNode{char date;struct BiTNode *lchild,*rchild; }BiTNode,*BiTree;void CreateBiTree(BiTree &T);int Depth(BiTree T);int NodeCount(BiTree T);int LeavesNodeCount(BiTree T);int PreOrderTraverse(BiTree T);int InOrderTraverse(BiTree T);int PostOrderTraverse(BiTree T); int main(){BiTree T;CreateBiTree(T);cout<<"二叉树的深度为:"<<Depth(T)<<endl;cout<<"二叉树中结点个数为:"<<NodeCount(T)<<endl;cout<<"二叉树中叶子结点个数为:"<<LeavesNodeCount(T)<<endl;cout<<"先序遍历:";PreOrderTraverse(T);cout<<"\n中序遍历:";InOrderTraverse(T);cout<<"\n后序遍历:";PostOrderTraverse(T);cout<<endl;return 0;}void CreateBiTree(BiTree &T){cout<<"请为该节点赋值:";char ch;cin>>ch;if(ch=='#'){T=NULL;}else{T =new BiTNode;T->date=ch;CreateBiTree(T->lchild);CreateBiTree(T->rchild);}}int Depth(BiTree T){int m,n;if(T==NULL){return 0;}else{m=Depth(T->lchild);n=Depth(T->rchild);if(m>n){return m+1;}else{return n+1;}}}int NodeCount(BiTree T){if(T==NULL){return 0;}else{return NodeCount(T->lchild)+NodeCount(T->rchild)+1;}}int LeavesNodeCount(BiTree T){if(T==NULL){return 0;}else if(T->lchild==NULL && T->rchild==NULL){return 1;}else{return LeavesNodeCount(T->lchild)+LeavesNodeCount(T->rchild);}}int PreOrderTraverse(BiTree T){if(T!=NULL){cout<<T->date;PreOrderTraverse(T->lchild);PreOrderTraverse(T->rchild);}}int InOrderTraverse(BiTree T){if(T!=NULL){InOrderTraverse(T->lchild);cout<<T->date;InOrderTraverse(T->rchild);}}int PostOrderTraverse(BiTree T){if(T!=NULL){PostOrderTraverse(T->lchild);PostOrderTraverse(T->rchild);cout<<T->date;}}请为该节点赋值:-请为该节点赋值:+请为该节点赋值:a请为该节点赋值:#请为该节点赋值:#请为该节点赋值:*请为该节点赋值:b请为该节点赋值:#请为该节点赋值:#请为该节点赋值:-请为该节点赋值:c请为该节点赋值:#请为该节点赋值:#请为该节点赋值:d请为该节点赋值:#请为该节点赋值:#请为该节点赋值:/请为该节点赋值:e请为该节点赋值:#请为该节点赋值:#请为该节点赋值:f请为该节点赋值:#请为该节点赋值:#二叉树的深度为:5二叉树中结点个数为:11二叉树中叶子结点个数为:6先序遍历:-+a*b-cd/ef中序遍历:a+b*c-d-e/f后序遍历:abcd-*+ef/-Process returned 0 (0x0) execution time : 76.214 s Press any key to continue.*//*#include<iostream>#include<stdlib.h>#include<string.h>using namespace std;typedef struct{int weiget;int parent,lchild,rchild;}HTNode,*HuffmanTree;typedef char** HuffmanCode;void creat(HuffmanTree &HT,int n);void Select(HuffmanTree HT,int k,int &min1,int &min2); void creatcode(HuffmanTree HT,HuffmanCode &HC,int n); int min(HuffmanTree HT,int k);int main(){int n;cout<<"请输入叶子节点的个数:";cin>>n;HuffmanTree HT;creat(HT,n);HuffmanCode HC;creatcode(HT,HC,n);return 0;}void creat(HuffmanTree &HT,int n){if(n<1){exit(1);}int m=2*n-1,i;HT=new HTNode[m+1];for( i=1;i<=m;i++){HT[i].parent=0;HT[i].lchild=0;HT[i].rchild=0;}for(i=1;i<=n;i++){cout<<"请输入权值:";cin>>HT[i].weiget;}int s1,s2;for(i=n+1;i<=m;i++) //通过n-1次选择来合并创建{Select(HT,i-1,s1,s2);HT[s1].parent=i; //赋值,作为删除的标记HT[s2].parent=i;cout<<"s1:"<<s1<<" s2:"<<s2<<endl;HT[i].lchild=s1; //生成新节点HT[i].rchild=s2;HT[i].weiget=HT[s1].weiget+HT[s2].weiget;}}void Select(HuffmanTree HT,int k,int &min1,int &min2){min1=min(HT,k);min2=min(HT,k);}int min(HuffmanTree HT,int k){int i=0;int min;//存放weight最小且parent为-1的元素的序号int min_wei;//存放权值while(HT[i].parent!=0){i++;}min_wei=HT[i].weiget;min=i;for(;i<=k;i++){if(HT[i].weiget<min_wei && HT[i].parent==0){min_wei=HT[i].weiget;min=i;}}HT[min].parent=1;return min;}void creatcode(HuffmanTree HT,HuffmanCode &HC,int n){HC =new char *[n+1];char *cd=new char[n];cd[n-1]='\0';int i,start;//start指向最后,即编码结束符的位置int current,father;for(i=1;i<=n;i++){start=n-1;current=i;father=HT[i].parent;while(father!=0){--start;if(HT[father].lchild==current){cd[start]='0';}else{cd[start]='1';}current=father;father=HT[father].parent;}HC[i]=new char[n-start];strcpy(HC[i],&cd[start]);cout<<HT[i].weiget<<"对应的编码是:"<<HC[i]<<endl;}delete cd;}请输入叶子节点的个数:5请输入权值:1请输入权值:2请输入权值:3请输入权值:4请输入权值:5s1:1 s2:2s1:3 s2:6s1:4 s2:5s1:7 s2:81对应的编码是:0102对应的编码是:0113对应的编码是:004对应的编码是:105对应的编码是:11Process returned 0 (0x0) execution time : 4.003 s Press any key to continue.*///折半查找#include<iostream>#include<stdio.h>using namespace std;#define ENDFLAG 10000typedef int KeyType;typedef char* InfoType;typedef struct{KeyType key;InfoType otherinfo;}ElemType;typedef struct{ElemType *R;int length;}SSTable;void CreateSTable(SSTable &ST,int n){int i;ST.R=new ElemType[n+1];for(i=1;i<=n;i++){cout<<"请输入"<<i<<"个测试数据:";cin>>ST.R[i].key;}ST.length=n;}int Search_Bin1(SSTable ST,KeyType key){int low,high,mid;low=1;high=ST.length;while(low<=high){mid=(low+high)/2;if(key==ST.R[mid].key){return mid;}else if(key<ST.R[mid].key){high=mid-1;}else{low=mid+1;}}return 0;}int Search_Bin2(SSTable ST,int low,int high,KeyType key) {int mid;if(low>high){return 0;}mid=(low+high)/2;printf("%d+++++",key==ST.R[mid].key);if(key==ST.R[mid].key){return mid;}else if(key<ST.R[mid].key){return Search_Bin2(ST,low,mid-1,key);}else{return Search_Bin2(ST,mid+1,high,key);}}int main(){int n;KeyType key;SSTable ST;cout<<"请输入静态查找表长:";cin>>n;CreateSTable(ST,n);cout<<"请输入待查记录的关键字:";cin>>key;cout<<"Search_Bin1算法计算的位置为:"<<Search_Bin1(ST,key)<<endl;cout<<"Search_Bin2算法计算的位置为:"<<Search_Bin2(ST,1,ST.length,key)<<endl;return 0;}/*请输入静态查找表长:5请输入1个测试数据:1请输入2个测试数据:2请输入3个测试数据:3请输入4个测试数据:4请输入5个测试数据:5请输入待查记录的关键字:3Search_Bin1算法计算的位置为:3Search_Bin2算法计算的位置为:3Process returned 0 (0x0) execution time : 8.620 sPress any key to continue.*//*#include<iostream>using namespace std;typedef struct{int key;}ElemType;typedef struct BSTNode{ElemType date;struct BSTNode *lchild,*rchild;}BSTNode,*BSTree;void Create(BSTree &T);void Insert(BSTree &T,ElemType e);int InOrderTraverse(BSTree T);int main(){BSTree T;Create(T);InOrderTraverse(T);cout<<"\n中序遍历:";return 0;}void Create(BSTree &T){T=NULL;ElemType e;cout<<"请为节点赋值:(0为结束条件)";cin>>e.key;while(e.key!=0){Insert(T,e);cout<<"请为节点赋值:(0为结束条件)";cin>>e.key;}}void Insert(BSTree &T,ElemType e){if(!T){BSTree S;S=new BSTNode;S->date=e;S->lchild=NULL;S->rchild=NULL;T=S;}else if(e.key<T->date.key){Insert(T->lchild,e);}else{Insert(T->rchild,e);}}int InOrderTraverse(BSTree T){if(T!=NULL){InOrderTraverse(T->lchild);cout<<T->date.key<<" ";InOrderTraverse(T->rchild);}return 0;}请为节点赋值:(0为结束条件)12请为节点赋值:(0为结束条件)7请为节点赋值:(0为结束条件)17请为节点赋值:(0为结束条件)11请为节点赋值:(0为结束条件)16请为节点赋值:(0为结束条件)2请为节点赋值:(0为结束条件)13请为节点赋值:(0为结束条件)9请为节点赋值:(0为结束条件)21请为节点赋值:(0为结束条件)4请为节点赋值:(0为结束条件)02 4 7 9 11 12 13 16 17 21中序遍历:Process returned 0 (0x0) execution time : 23.808 s Press any key to continue.*/。
串-数据结构实验报告[修改版]
第一篇:串-数据结构实验报告【源程序】:#include #include #include void choose(char *s, int i,int m,char *t);//i位置截取m个字符函数void main() //主函数{ char *s,*t; int i,sl,m;s=(char *)malloc(100*sizeof(char));t=(char *)malloc(100*sizeof(char));printf("\n 输入主字符串s=?"); gets(s); printf("\n s=%s\n",s);printf("\n 输入位置i=?"); scanf("%d",&i); printf("\n i=%d\n",i);printf("\n 输入字符个数m=?"); scanf("%d",&m); printf("\n m=%d\n",m);sl=strlen(s);if(i>sl) printf("i位置出错\n");else if(i+m>sl+1) printf("m位置出错\n");else{choose(s,i,m,t);printf("\n 子串为t=%s\n",t);} } //end_main void choose(char *s, int i,int m,char *t) { int n;int j=0; for(n=i;n三.实验结论及分析串的存储结构包含有顺序存储结构和链式存储结构。
在串的顺序存储结构中,表示串的长度通常有两种方法:一种方法是设置一个串的长度参数,其优点在于便于在算法中用长度参数控制循环过程;另一种方法是在串值得末尾添加结束标记,此种方法的优点在于便于系统自动实现。
数据结构:串子系统
scanf("%d", &j);
deleStr(p, i-1, j); //删除子串
break;
case 5:
printf("请输入从第几字符后开始插入:"); //插入字符串
scanf("%d", &i);
t = createStr(t); //建立字符串
}
else
{
for (k = p->len-1; k >= i; k--) //找到要插入的位置,将其后面的向后移
{
p->data[r->len+k] = p->data[k];
}
for (k = 0; k < r->len; k++) //插入另一个字符串
{
p->data[i+k] = r->data[k];
j:连续几个字符
Return: void
Others: NULL
*************************************************/
void subStr(str *p, int i, int j)
{
str *r = (str *)malloc(sizeof(str));
printf("请输入从第几字符开始:");
scanf("%d", &i);
printf("请输入要取出的连续字符数:");
scanf("%d", &j);
subStr(p, i-1, j); //取出子串
数据结构完整代码
(线性表顺序存储)#include"string.h"#include"ctype.h"#include"stdio.h"#include"stdlib.h"#include"io.h"#include"math.h"#include"time.h"#define OK1#define ERROR0#define TRUE1#define FALSE0#define MAXSIZE20/*存储空间初始分配量*/ typedef int Status;/*Status是函数的类型,其值是函数结果状态代码,如OK等*/typedef int ElemType;/*ElemType类型根据实际情况而定,这里假设为int*/Status visit(ElemType c){printf("%d",c);return OK;}typedef struct{ElemType data[MAXSIZE];/*数组,存储数据元素*/int length;/*线性表当前长度*/}SqList;/*初始化顺序线性表*/Status InitList(SqList*L){L->length=0;return OK;}/*初始条件:顺序线性表L已存在。
操作结果:若L为空表,则返回TRUE,否则返回FALSE*/Status ListEmpty(SqList L){if(L.length==0)return TRUE;elsereturn FALSE;}/*初始条件:顺序线性表L已存在。
操作结果:将L重置为空表*/Status ClearList(SqList*L){L->length=0;return OK;}/*初始条件:顺序线性表L已存在。
操作结果:返回L 中数据元素个数*/int ListLength(SqList L){return L.length;}/*初始条件:顺序线性表L已存在,1≤i≤ListLength(L)*/ /*操作结果:用e返回L中第i个数据元素的值,注意i 是指位置,第1个位置的数组是从0开始*/Status GetElem(SqList L,int i,ElemType*e){if(L.length==0||i<1||i>L.length)return ERROR;*e=L.data[i-1];return OK;}/*初始条件:顺序线性表L已存在*//*操作结果:返回L中第1个与e满足关系的数据元素的位序。
数据结构 串基本操作代码
数据结构串基本操作代码简介本文档介绍了数据结构中串的基本操作代码,包括串的定义、串的赋值、串的比较、串的连接、串的替换等。
1.串的定义串是由零个或多个字符组成的有限序列,是字符串的抽象数据类型。
常用的串类型包括顺序串和链式串。
1.1 顺序串顺序串是使用数组来存储字符序列的数据结构。
其定义如下:```cdefine MaXSiZe 100 // 串的最大长度typedef struct {char data[MaXSiZe]; // 存储串的字符数组int length; // 串的长度} SqString;```1.2 链式串链式串是使用链表来存储字符序列的数据结构。
其定义如下:```ctypedef struct LNode {char data; // 存储串的字符struct LNode next; // 指向下一个节点的指针} LNode, LinkString;```2.串的基本操作2.1 串的赋值将一个字符串赋值给一个串,可以使用字符串赋值函数`strcpy`或者循环遍历字符串赋值。
2.1.1 使用strcpy函数赋值```cinclude <string.h>void Strassign(SqString s, char str) {strcpy(s->data, str);s->length = strlen(str);}```2.1.2 使用循环遍历赋值```cvoid Strassign(SqString s, char str) {int i;for (i = 0; str[i] != '\\0'; i++) {s->data[i] = str[i];}s->length = i;s->data[i] = '\\0';}```2.2 串的比较比较两个串是否相等,可以使用字符串比较函数`strcmp`或者循环遍历比较。
数据结构实验与实训教程源代码
i
第一部分 预备知识
预备知识
例 1.1 #include <stdio.h> int sumabc(int a, int b, int c) /* 求三个整数之和*/ { int s; a=b+c; s=a+b+c; return s; } void displayLine(void) { printf(”----------------------\n“); } void main( ) { int x,y, z ,sabc; x=y=z=8; display(); /* 画一条线 */ printf(“\n sum=%d”,sumabc(x,y,z)); /* 在输出语句中直接调用函数 sumabc( ) */ printf(“\n %6d%6d%6d”,x,y,z); display();/* 画一条线 */ x=2; y=4; z=6; sabc =sumabc(x, y, z); /* 在赋值语句中调用函数 sumabc( ) */ printf(“\n “ sum=%d”, sabc); printf(“\n %6d%6d%6d”,x,y,z); display();/* 画一条线 */ } 例 1.2 int sumabc(int *a, int b, int c) { int s; *a=b+c; s=*a+b+c;
2
}//while(1) }//main
3
第二部分 基础实验
实验 1 线性表的基本操作
四、参考程序
程序 1:题 1 线性表基本操作函数 #include<stdio.h> #include<stdlib.h> #include<alloc.h> struct LinearList /*定义线性表结构*/ { int *list; /* 存线性表元素 */ int size; /* 存线性表长度 */ int MaxSize; /* 存 list 数组元素个数 */ }; typedef struct LinearList LIST; void InitList( LIST *L, int ms ) /* 初始化线性表 */ { if( (L->list = 1 ) == NULL ) { printf( "内存申请错误!\n" ); exit( 1 ); } 2 L->MaxSize = ms; } int InsertList( LIST *L, int /* item:记录值 rc:插入位置 { int i; if( 3 ) return -1; if( rc < 0 ) item, int rc ) */备知识实验
数据结构串基本操作代码
数据结构串基本操作代码串是由零个或多个字符组成的有限序列,是数据结构中的一种基本数据类型。
常见的串操作有串的存储、串的插入、串的删除、串的替换、串的连接、串的比较等。
以下是对串基本操作的代码实现:1.串的存储串的存储可以使用数组或链表来实现。
下面是基于数组的实现方式。
```C++#define MAX_LEN 100 // 定义串的最大长度typedef structchar data[MAX_LEN]; // 存储串的字符数组int length; // 当前串的长度} String;//初始化串void InitString(String &s)s.length = 0;//串赋值void AssignString(String &s, char str[])int len = strlen(str);for (int i = 0; i < len; i++)s.data[i] = str[i];}s.length = len;//输出串void PrintString(String s)for (int i = 0; i < s.length; i++)cout << s.data[i];}cout << endl;```2.串的插入在指定位置上插入指定内容。
```C++//串的插入void InsertString(String &s, int pos, char str[]) int len = strlen(str);if (s.length + len > MAX_LEN)return; // 串已满,无法插入for (int i = s.length - 1; i >= pos; i--)s.data[i + len] = s.data[i];}for (int i = pos, j = 0; j < len; i++, j++)s.data[i] = str[j];}s.length += len;```3.串的删除删除指定位置上的字符。
数据结构实验源代码
数据结构实验源代码【附】数据结构实验源代码范本一、实验背景与目的1.1 实验背景在计算机科学中,数据结构是指数据元素之间的关系,以及为操作这些数据元素所提供的方法。
数据结构对于程序的设计和性能优化具有重要影响。
1.2 实验目的本实验旨在通过编写和实现不同的数据结构,加深学生对数据结构的理解,掌握基本的数据结构操作方法。
二、实验内容2.1 线性表2.1.1 顺序表2.1.1.1 初始化顺序表2.1.1.2 插入元素到顺序表2.1.1.3 删除顺序表中的元素2.1.1.4 遍历顺序表2.1.1.5 查找指定元素在顺序表中的位置2.1.2 链表2.1.2.1 初始化链表2.1.2.2 插入元素到链表2.1.2.3 删除链表中的元素2.1.2.4 遍历链表2.1.2.5 查找指定元素在链表中的位置2.2 栈2.2.1 初始化栈2.2.2 进栈操作2.2.3 出栈操作2.2.4 获取栈顶元素2.2.5 判断栈是否为空2.3 队列2.3.1 初始化队列2.3.2 入队操作2.3.3 出队操作2.3.4 获取队首元素2.3.5 判断队列是否为空三、实验步骤3.1 线性表实现在实现顺序表和链表时,首先需要定义数据结构和所需的操作函数。
然后进行初始化、添加元素、删除元素等操作。
最后进行遍历和查找操作,并检验实验结果是否符合预期。
3.2 栈实现栈的实现过程与线性表类似,需要定义栈的数据结构和所需的函数,然后进行初始化、进栈、出栈等操作。
3.3 队列实现队列的实现也与线性表类似,需要定义队列的数据结构和函数,进行初始化、入队、出队等操作。
四、数据结构实验源代码以下是实验代码的源代码范本,包括线性表、栈和队列的实现。
(代码略,如需获取,请查看附件)五、附件本文档附带的附件为数据结构实验源代码。
六、法律名词及注释6.1 数据结构:计算机科学中,数据结构是指数据元素之间的关系,以及为操作这些数据元素所提供的方法。
6.2 顺序表:一种物理上相邻的存储结构,元素按照顺序依次存放。
串的操作实验报告
一、实验目的1. 理解串的概念及其在程序设计中的应用。
2. 掌握串的基本操作,如创建、插入、删除、查找等。
3. 提高对数据结构操作的理解和编程能力。
二、实验环境1. 操作系统:Windows 102. 编程语言:C++3. 开发工具:Visual Studio 2019三、实验内容1. 创建串2. 插入字符3. 删除字符4. 查找字符5. 合并串6. 判断串是否为空7. 获取串的长度8. 反转串四、实验步骤1. 创建串```cpp#include <iostream>#include <string>using namespace std;int main() {string str1 = "Hello";string str2 = "World";return 0;}```2. 插入字符```cppint main() {string str = "Hello";int position = 3;char ch = 'W';str.insert(position, 1, ch);cout << str << endl; // 输出:HWeHllo return 0;}```3. 删除字符```cppint main() {string str = "Hello";int position = 2;int length = 2;str.erase(position, length);cout << str << endl; // 输出:Hereturn 0;}```4. 查找字符```cppint main() {string str = "Hello";char ch = 'e';size_t position = str.find(ch);cout << position << endl; // 输出:1return 0;}```5. 合并串```cppint main() {string str1 = "Hello";string str2 = "World";string str3 = str1 + str2;cout << str3 << endl; // 输出:HelloWorld return 0;}```6. 判断串是否为空```cppint main() {string str1 = "Hello";string str2 = "";if (str1.empty()) {cout << "str1 is empty" << endl;} else {cout << "str1 is not empty" << endl; }if (str2.empty()) {cout << "str2 is empty" << endl;} else {cout << "str2 is not empty" << endl; }return 0;}```7. 获取串的长度```cppint main() {string str = "Hello";int length = str.length();cout << length << endl; // 输出:5return 0;}```8. 反转串```cppint main() {string str = "Hello";reverse(str.begin(), str.end());cout << str << endl; // 输出:olleHreturn 0;}```五、实验结果与分析通过以上实验,我们成功实现了串的基本操作。
数据结构源代码(全)
/*顺序表的操作#include<iostream>#include<stdlib.h>using namespace std; Release 13.12 rev 9501 (2013/12/25 19:25:45) gcc 4.7.1 Windows/unicode - 32 bit#define MAX_SIZE 100 typedef struct{int *emel;int lenth;}Sq;void init(Sq &l);void create(Sq &l);void trval(Sq &l);void find_value(Sq &l); void find_position(Sq &l); void insert(Sq &l);void dele(Sq &l);int main(){S q l;i nit(l);c reate(l);t rval(l);f ind_value(l);f ind_position(l);i nsert(l);t rval(l);d ele(l);t rval(l);r eturn 0;}void init(Sq &l){l.emel =new int[MAX_SIZE];i f(l.emel ==NULL){c out<<"\t申请空间失败!"<<endl;e xit(1);}l.lenth=0;cout<<"\t成功申请空间!该顺序表的长度目前为:"<<l.lenth<<endl;}void create(Sq &l){c out<<"\t请输入你想输入元素的个数:";i nt x;c in>>x;if((x<1)&&(x>MAX_SIZE)){c out<<"\t你说输入的数不在范围里"<<endl;r eturn;}int i;for(i=0;i<x;i++){c in>>l.emel[i];}l.lenth=x;cout<<"\t成功赋值!"<<endl;}void trval(Sq &l){i nt i;c out<<"l(";f or(i=0;i<l.lenth;i++){cout<<l.emel[i]<<" "; }c out<<")"<<" 该顺序表现在的长度为:"<<l.lenth<<endl;}void find_value(Sq &l) {i nt x,t=0;c out<<"\t请输入你要查找的值:";c in>>x;i nt i;f or(i=0;i<l.lenth;i++){if(l.emel[i]==x){t=1;c out<<"\t成功找到该元素,它是顺序表的第"<<i+1<<"个元素!"<<endl;}}i f(t==0){cout<<"\t无该元素!"<<endl;}}void find_position(Sq &l) {i nt x;c out<<"\t请输入你要查找的位置:";c in>>x;i nt i;i f((x<1)||(x>l.lenth)){cout<<"\t输入的值不在范围内!"<<endl;return;}f or(i=1;i<=l.lenth;i++){if(i==x){c out<<"\t成功找到该元素,该值是"<<l.emel[i-1]<<endl;}}}void insert(Sq &l){int i,x,y;cout<<"\t请输入你要插入的位置";cin>>x;cout<<"\t请输入你要插入的值";cin>>y;if((x<1)||(x>l.lenth)) {cout<<"\t输入的值不在范围内!"<<endl;return;}if(x==l.lenth){l.emel[l.lenth]=y;l.lenth=l.lenth+1;return;}for(i=l.lenth;i>=x;i--) {l.emel[i]=l.emel[i-1]; }l.emel[x-1]=y;l.lenth=l.lenth+1;}void dele(Sq &l){int i,x;cout<<"\t请输入你要删除位置:";cin>>x;if((x<1)||(x>l.lenth))cout<<"\t输入的值不在范围内!"<<endl;return;}for(i=x-1;i<=l.lenth;i++) {l.emel[i]=l.emel[i+1];l.lenth=l.lenth-1;}成功申请空间!该顺序表的长度目前为:0请输入你想输入元素的个数:385成功赋值!l(8 5 2 ) 该顺序表现在的长度为:3请输入你要查找的值:5成功找到该元素,它是顺序表的第2个元素!请输入你要查找的位置:3成功找到该元素,该值是2请输入你要插入的位置3请输入你要插入的值10l(8 5 2 10 ) 该顺序表现在的长度为:4请输入你要删除位置:3l(8 5 10 ) 该顺序表现在的长度为:3--------------------------------Process exited with return value 0Press any key tocontinue . . .*//*#include<stdio.h> #include<stdlib.h> typedef struct Link {int num;struct Link *next;}L;L* creat(L* head){head=(L*)malloc(sizeof(L));if(head==NULL){printf("头节点申请失败!\n");exit(-1);}head->next=NULL; return head;}void insert(L* head) {int x,i;printf("请输入你想输入数据的个数:");scanf("%d",&x);L *p,*q;p=head;for(i=0;i<x;i++){q=(L *)malloc(sizeof(L));if(q==NULL){printf("新点申请失败!\n");exit(-1);}printf("请输入值:"); scanf("%d",&q->num);q->next=NULL; p->next=q;p=q;}}void print(L* head) {L *p;p=head->next;while(p!=NULL){printf("值为:%d\n",p->num);p=p->next;}}int main(){L *head;head=creat(head);printf("成功创建头节点!!!\n");insert(head);printf("成功输入数据!!!\n");print(head); return 0;}*//*线性表的操作#include<stdio.h> #include<stdlib.h> typedef struct Link{int num;struct Link *next; }L;L* creat(L* head) {head=(L*)malloc(sizeof(L));if(head==NULL){printf("头节点申请失败!\n");exit(-1);}head->next=NULL; return head;}void init(L* head){int x,i;printf("请输入你想输入数据的个数:");scanf("%d",&x);L *p,*q;p=head;for(i=0;i<x;i++){q=(L *)malloc(sizeof(L)); if(q==NULL){printf("新点申请失败!\n");exit(-1);}printf("请输入值:"); scanf("%d",&q->num); q->next=p->next;p->next=q;}}int print(L* head) {L *p;int lenth=0;p=head->next; printf("\t\tL("); while(p!=NULL) {lenth++;printf("%d ",p->num); p=p->next;}printf(")\n");return lenth;}int insert(L *head,int lenth){printf("\t\t请输入你要插入的元素的位置:");int in;scanf("%d",&in);if(in<1 || in>lenth){printf("\t\t输入值不在范围内!");}L *p,*q;p=head->next;q=(L *)malloc(sizeof(L)); if(q==NULL){printf("新点申请失败!\n");}printf("\t\t请为新节点输入值:");scanf("%d",&q->num); int i=0;while(p!=NULL){i++;if(i==in-1){q->next=p->next; p->next=q;}p=p->next;}lenth++;return lenth;}int dele(L *head,int lenth) {printf("\t\t请输入你要删除的元素的位置:");int out;scanf("%d",&out);if(out<1 || out>lenth) {printf("\t\t输入值不在范围内!");return -1;}L *p,*q;p=head->next; q=head;int i=0;while(p!=NULL) {i++;if(i==out) {q->next=p->next; }q=p;p=p->next;}lenth--;return lenth;}void find(L *head,int lenth) {printf("\t\t请输入你要查找的元素的位置:");int finder;scanf("%d",&finder);if(finder<1 || finder>lenth){。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
数据结构串的操作1.头文件://串类的定义class AString{private:char *ch; //串存放数组int curLength; //串的实际长度int maxSize; //存放数组的最大长度.void CheckMem(); //检测内存是否申请成功public:AString();AString(int sz); //构造函数,构造一个最大长度为sz,实际长度为0的字符串AString(const char *init); //构造函数,构造一个最大长度为maxSize,由init 初始化的新字符串对象AString(const AString &ob); //复制构造函数,由一个已有的字符串对象ob 构造一个新字符串~AString(){delete[] ch;} //析构函数,释放动态分配的串空间并撤销该字符串对象//与字符串对象的比较运算int operator == (AString &ob)const {return strcmp(ch,ob.ch) == 0;} //判断当前实例是否与ob串相等,若相等则返回1,否则返回0int operator != (AString &ob)const {return strcmp(ch,ob.ch) != 0;} //判断当前实例是否与ob串不等,若不等则返回1,否则返回0int operator < (AString &ob)const {return strcmp(ch,ob.ch)<0;} //判断当前实例串是否小于ob串,若小于则返回1,否则为0int operator > (AString &ob)const {return strcmp(ch,ob.ch)>0;}//判断当前实例串是否大于ob串,若小于则返回1,否则为0int operator <= (AString &ob)const {return strcmp(ch,ob.ch)<=0;}//判断当前实例串是否小于等于ob串,若小于等于则返回1,否则为0int operator >= (AString &ob)const {return strcmp(ch,ob.ch)>=0;}//判断当前实例串是否大于等于ob串,若大于等于则返回1,否则为0//与字符串的比较运算int operator == (char *str)const{return strcmp(ch,str) == 0;} //判断当前实例是否与C++串相等,若相等则返回1,否则返回0int operator != (char *str)const{return strcmp(ch,str) != 0;}//判断当前实例是否与C++串不相等,若不等则返回1,否则返回0int operator < (char *str)const {return strcmp(ch,str)<0;}//判断当前实例是否与小于C++串,若小于则返回1,否则返回0int operator > (char *str)const{return strcmp(ch,str)>0;}//判断当前实例是否与大于C++串,若小于则返回1,否则返回0int operator <= (char *str)const{return strcmp(ch,str)<=0;}//判断当前实例是否与小于等于C++串,若小于等于则返回1,否则返回0int operator >=(char *str)const {return strcmp(ch,str)>=0;}//判断当前实例是否与大于等于C++串,若大于等于则返回1,否则返回0AString& operator = (AString &ob); //将串ob赋值给当前实例.AString& operator = (const char *str); //将字符串赋值给字符串对象AString& operator +=(AString &ob); //若当前实例串长度与ob串长度之和不超过maxSize则把ob串接在当前实例的后面.AString& operator +=(const char *str); //若当前实例串长度与str串长度之和不超过maxSize,则把str串接到串对象后面.char& operator[](int i); //取当前实例的第i个字符返回.bool IsEmpty()const{return curLength == 0;} //判空函数int Length() const{return curLength;} //返回当前实例的实际字符长度.//下面主要是常用函数的重载等等,方便各种调用方法void SubString(AString &subs,int index,int length); //从索引index开始截取length长度的字符串返回.AString& Remove(int startIndex,int length); //以索引startIndex开始删除length个字符AString& Insert(int pos,const char *value);void Clear(); //清空当前字符串对象void Output(); //输出};//串类的实现void AString::CheckMem(){if(ch == NULL){cerr<<"内存分配失败!\n";exit(1);}}AString::AString(){maxSize = defaultSize;curLength = 0;ch = new char[maxSize];CheckMem();ch[0] = '\0';}AString::AString(int sz){//串构造函数maxSize = sz;ch = new char[maxSize+1];CheckMem();curLength = 0;ch[0] = '\0';}AString::AString(const char *init){//串构造函数int initLength = strlen(init);maxSize = (initLength > defaultSize) ? initLength : defaultSize;ch = new char[maxSize+1];CheckMem();curLength = initLength;strcpy(ch,init);}AString::AString(const AString &ob){//串对象复制构造函数maxSize = ob.maxSize;ch = new char[maxSize+1];CheckMem();strcpy(ch,ob.ch);curLength = ob.curLength;}AString& AString::operator =(AString &ob){if(&ob != this)//若两个串相等为自我赋值{Clear();curLength = ob.curLength;strcpy(ch,ob.ch);}elsecout<<"字符串自身赋值出错!\n";return *this;}AString& AString::operator =(const char *str){//字符串赋值int strLength = strlen(str);maxSize = strLength>maxSize?strLength:maxSize;Clear();strcpy(ch,str);curLength = strLength;return *this;}AString& AString::operator +=(AString &ob){//字符串对象连接char *tempCH = ch;char *tempOb = ob.ch;int addLength = curLength+strlen(tempOb);maxSize = maxSize>addLength?maxSize:addLength;char *temp = new char[maxSize+1];char *tempT = temp;while(*tempCH!='\0')*tempT++=*tempCH++;while(*tempOb!='\0')*tempT++=*tempOb++;*tempT++='\0';Clear();strcpy(ch,temp);curLength=strlen(ch);delete[] temp;return *this;}AString& AString::operator +=(const char *str){//字符串连接到字符串对象char *tempCH = ch;int addLength = curLength+strlen(str);maxSize = maxSize>addLength?maxSize:addLength;char *temp = new char[maxSize+1];char *tempT = temp;while(*tempCH!='\0')*tempT++=*tempCH++;while(*str!='\0')*tempT++=*str++;*tempT++='\0';Clear();strcpy(ch,temp);curLength=strlen(ch);delete[] temp;return *this;}char& AString::operator [](int i){//读取索引位置上的字符if(i<0||i>curLength){cerr<<"字符下标越界\n";exit(1);}return ch[i];}void AString::SubString(AString &subs,int index,int length) {if(index<0||index+length>maxSize||length<0){cerr<<"或索引或者长度越界\n";exit(1);}if(IsEmpty())cerr<<"字符串对象为空\n",exit(1);else{char *temp = new char[length+1];if(temp==NULL){cerr<<"内存分配错误!\n";exit(1);}for(int i=0,j=index;i<length;i++,j++){temp[i] = ch[j];}temp[length] = '\0';subs=temp;}}AString& AString::Remove(int startIndex,int length){if(startIndex<0||startIndex+length>maxSize||length<0){cerr<<"索引或长度越界\n";exit(1);}if(IsEmpty())cerr<<"字符串对象为空\n",exit(1);for(int i=0;i<curLength-startIndex-length;i++){ch[i+startIndex] = ch[i+length+startIndex];}ch[curLength-length] = '\0';curLength=strlen(ch);return *this;}AString& AString::Insert(int pos,const char *value){if(pos>curLength||pos<0){cerr<<"试图插入的位置越界\n";exit(1);}int addLength = strlen(value) + curLength;maxSize = addLength>maxSize?addLength:maxSize;char *temp = new char[maxSize+1];char *tempCH = ch;char *tempH = temp;for(int i=0;i<pos;i++)*temp++ = *tempCH++;//先将当前对象中插入位置之前的字符复制到tempH指向的内存中while(*value!='\0')*temp++=*value++;//再将待插入的字符串连接到tempH指向的内存中while(*tempCH!='\0')*temp++=*tempCH++;//最后将当前对象插入位置之后的字符连接到tempH指向的内存中*temp='\0';Clear(); //清空当前对象strcpy(ch,tempH);//将拼接好的字符串复制到实例中curLength=strlen(ch);return *this;}void AString::Clear(){delete[] ch;ch = new char[maxSize+1];CheckMem();//释放内存并重新申请ch[0] = '\0';//将串对象置为空curLength = 0;}void AString::Output(){if(IsEmpty())cerr<<"字符串对象为空"<<endl;elsecout<<ch<<endl;}2.主程序:#include<iostream.h>#include"stdio.h"//EOF,NULL#include<string>const int defaultSize = 128;using namespace std;#include"AString.h"int main(){cout<<"------------------------------------------------------------------------"<<endl;cout<<"请输入初始化对象的大小:";int len;cin>>len;char *str = new char[len+1];cout<<"\n请输入要初始化字符串(不能含有空格):";cin>>str;AString string(len);string = str;int tag=0;while(1){cout<<"1-删除操作\n"<<"2-插入操作\n"<<"3-连接操作\n"<<"4-截取字符串\n"<<"5-字符比较\n"<<"6-输出字符串对象\n"<<"7-清空字符对象(清空后可选择序号8来重新赋值)\n"<<"8-字符串对象赋值\n"<<"9-退出程序\n";cout<<"\n请输入要操作的方法的序号:";cin>>tag;switch(tag){case 1:{int index,length;cout<<"请输入要删除的起始位置:";cin>>index;cout<<"\n请输入要删除的长度:";cin>>length;string.Remove(index,length);cout<<"\n删除后的字符串:"<<endl;string.Output();break;}case 2:{int index;char *input = new char[defaultSize];cout<<"\n请输入要插入的字符串:";cin>>input;//cout<<" 输入的串长为:"<<strlen(input)<<endl;cout<<"\n请输入要插入的位置:";cin>>index;string.Insert(index,input);cout<<"\n插入字符串后的字符对象:"<<endl;string.Output();delete[] input;break;}case 3:{char *value = new char[defaultSize+1];cout<<"\n请输入要连接的字符串:";cin>>value;AString astr = value;string+=astr;cout<<"\n连接字符串后的字符对象:"<<endl;string.Output();delete[] value;break;}case 4:{int len,i;AString subs;cout<<"\n请输入要截取的字符串长度:";cin>>len;cout<<"\n请输入开始截取的位置:";cin>>i;string.SubString(subs,i,len);cout<<"\n下面为截取后的字符串对象:";subs.Output();break;}case 5:{char *value = new char[128];cout<<"\n请输入要比较的字符串:";cin>>value;cout<<"\n字符串比较结果如下所示:";string.Output();if(string>value) cout<<">";if(string==value) cout<<"=";if(string<value) cout<<"<";cout<<value<<endl;break;}case 6:cout<<"\n当前字符串对象的值如下所示:";string.Output();break;case 7:string.Clear();cout<<"\n字符串对象已清空!\n";break;case 8:{char *str = new char[128];cout<<"\n请输入要赋值的字符串(不能有空格):";cin>>str;string = str;cout<<"\n赋值后的字符串对象为:";string.Output();break;}case 9:cout<<"运行结束"<<endl;return 0;break;default:cout<<"选择非法,请重选!";break;}}}。