① 以定长顺序存储方式实现串的抽象数据类型中定义的基本操作 要求不得使用c语言的字符串操作函数
这是运行结果：
需要的话给我的地址
/*
在vc++6.0中的输出结果：
------------------------
请输入串s1:ABCD
串长为4
串空吗：0(1:是 0:非空)
拷贝s1生成的串s2为：A B C D
请输入串s2:123456
串s1 > 串s2
串s1链接s2得到的串t为：A B C D 1 2 3 4 5 6
清为空串后，串s1为：
串长为0
串空吗：1(1:空 0:非空)
求串t的子串，请输入子串的起始位置,子串长度：3,7
子串s2为：C D 1 2 3 4 5
从串t的第pos个字符起，删除len个字符，请输入pos,len：4,4
删除后的串t为：A B C 4 5 6
在串s2的第3个字符起插入串t后，串s2为：C D A B C 4 5 6 1 2 3 4 5
s2的第3个字母起和t第一次匹配
串t为:C
串s1为：C C
用串s1取代串s2中和串t相同的不重叠的串后，串s2为：C C D A B C C 4 5 6 1 2 3 4 5
Press any key to continue
------------------------------
*/
② C语言（数据结构）怎么用顺序存储的串的0号单元存放串长度
char里面放的是字符还是数字，是编程者决定的。如果写SString[0]=8，存的就是数字；如果写SString[0]='8'，存的就是字符，也就是数字8的ASIIC值
③ 定长顺序串与堆串的区别
摘要 1、定长顺序存储结构和堆分配存储结构都是顺序存储结构，它们的主要区别是前者的串长是固定的，后者的串长是动态
④ 若s和t是两个采用定长顺序存储表示的串，编写一个实现串比较运算的函数StrCompare（s，t），当s大于t时返
用 ANSI 标准函数 memcmp 试过吗？ #include <string。h> 。。 头文4件 i = memcmp( s7, s0, N ); 。。 ANSI 标准函数 memcmp 这里: const void *s2, *s6; 。。 也e就是 x,y 的起始地址 size_t N; 。。 比4的长1度，用多少0个u字符计5算 int i; 。。 比8较结果，0 -- 相等。 memcmp与dstrcmp不d同，strcmp认8字符串结束符\0，memcmp看到\0也q不n认7为4字符串结束，所以3memcmp的“比3较”无k长0度限制，我想可以6比5较顺序结构存储的事。 piρulニry奈x（ωjzc
⑤ 数据结构串联接程序
gets()函数的参数只能为char *型，你定义为unsigned char肯定是不行的。
还有字符是不能赋值的，要用拷贝函数啊
⑥ 数据结构编程求救
试验一:
#include<iostream>
#include<string>
using namespace std;
struct List
{
int num;
List *next;
};
List *head=NULL;
List* CreateList()
{
List *pL;
List *pEnd;
pL=new List;
head=pL;
pEnd=pL;
cout<<"请输入节点的数目,以 0 结束"<<endl;
cin>>pL->num;
while(pL->num!=0)
{
pEnd->next=pL;
pEnd=pL;
pL=new List;
cin>>pL->num;
}
delete pL;
pEnd->next=NULL;
return head;
}
void ShowList(List *head)
{
cout<<endl;
cout<<"链表节点如下:"<<endl;
while(head)
{
cout<<head->num<<endl;
head=head->next;
}
}
void InsertList(List *head,int num)
{
List *list =new List;
List *l;
while(head)
{
l=head;
head=head->next;
}
list->num=num;
list->next=NULL;
l->next=list;
}
void DeleteList(List *head, int num)
{
List *l;
if(head->num==num)
{
l=head;
head=head->next;
::head=head;
delete l;
return ;
}
List *l1=head;
while(head)
{
if(head->next==NULL){
cout<<"找不到不要删除的数字."<<endl;
return ;
}
if(head->next->num==num)
{
l=head->next;
head->next=l->next;
delete l;
::head=l1;
cout<<"操作成功"<<endl;
return ;
}
head=head->next;
}
cout<<"找不到不要删除的数字."<<endl;
}
int GetListNum(List *head)
{
int num=0;
while(head)
{
num++;
head=head->next;
}
return num;
}
int main()
{
string str;
begin:
cout<<"1->增加链表 2->显示链表 3->插入节点 4->删除节点 5->节点数目"<<endl;
cin>>str;
if(str[0]=='1')
{
CreateList();
}
else if(str[0]=='2')
{
if(head==NULL)
{
cout<<"你的链表现在是空的,请增加链表"<<endl;
getchar();
getchar();
system("cls");
goto begin;
}
ShowList(head);
}
else if(str[0]=='3')
{
if(head==NULL)
{
cout<<"你的链表现在是空的,请增加链表"<<endl;
getchar();
getchar();
system("cls");
goto begin;
}
int num;
cout<<"请输入要插入的数字:"<<endl;
cin>>num;
InsertList(head,num);
}
else if(str[0]=='4')
{
if(head==NULL)
{
cout<<"你的链表现在是空的,请增加链表"<<endl;
getchar();
getchar();
system("cls");
goto begin;
}
int num;
cout<<"请输入要删除的数字:"<<endl;
cin>>num;
DeleteList(head,num);
}
else if(str[0]=='5')
{
cout<<"节点数是:"<<GetListNum(head)<<endl;
}
else
{
cout<<"输入错误,请重新输入.";
}
if(str[0]!='Q' && str[0]!='q'){
cout<<endl<<endl;
getchar();
getchar();
system("cls");
goto begin;
}
}
试验二:
#include<iostream>
#include<string>
using namespace std;
struct Stack {
char c;
Stack *pNext;
};
void InitStack(Stack *&s)
{
s=NULL;
}
char Peek(Stack *s)
{
if(s==NULL) {
cout<<"栈是空的."<<endl;
return -1;
}
return s->c;
}
void Push(Stack *&s,Stack *newS)
{
newS->pNext=s;
s=newS;
}
char Pop(Stack *&s)
{
if(s==NULL)
{
cout<<"栈是空的."<<endl;
return -1;
}
Stack *pNext;
char c;
if(s)
{
pNext=s->pNext;
c=s->c;
delete s;
s=pNext;
return c;
}
}
int main()
{
Stack *s;
Stack *s1;
InitStack(s);
long num;
int m;
int k;
char c;
cout<<"输入一个数:"<<endl;
cin>>num;
cout<<"输入要转换的进制:"<<endl;
cin>>k;
while(num!=0)
{
m=num%k;
c=(int('0')+m);
s1=new Stack;
s1->c=c;
Push(s,s1);
num/=k;
}
while(s)
{
cout<<Pop(s);
}
cout<<endl;
}
⑦ 《数据结构（C语言版）》之“串的模式匹配算法”
# include <string.h>
# include <stdio.h>
# include <stdlib.h>
# define OK 1
# define ERROR 0
typedef int Status;
//串的定长顺序存储结构
# define MAX_STR_LEN 40
typedef char SString[MAX_STR_LEN + 1];//0号单元存放串的长度
Status StrAssign(SString T,char * chars)//生成一个其值等于chars的串T
{
int i;
if (strlen(chars) > MAX_STR_LEN)
{
return ERROR;
}
else
{
T[0] = strlen(chars);
for (i=1; i<=T[0]; ++i)
{
T[i] = * (chars + i - 1);
}
return OK;
}
}
//返回串S的元素的个数
int StrLength(SString S)
{
return S[0];
}
//用Sub返回串S的自第pos个字符起长度为len的子串
Status SubString(SString Sub,SString S,int pos,int len)
{
int i;
if (pos<1 || pos>S[0] || len<0 || len>S[0]-pos+1)
{
return ERROR;
}
for (i=1; i<=len; ++i)
{
Sub[i] = S[pos+i-1];
}
Sub[0] = len;
return OK;
}
//输出字符串T
void StrPrint(SString T)
{
int i;
for (i=1; i<=T[0]; ++i)
{
printf("%c ",T[i]);
}
printf("\n");
}
//求模式串T的next函数值并存入数组next
void get_next(SString T,int next[])
{
int i = 1,j = 0;
next[1] = 0;
while (i < T[0])
{
if (j==0 || T[i]==T[j])
{
++i;
++j;
next[i] = j;
}
else
{
j = next[j];
}
}
}
//求模式串T的next函数修正值并存入数组nextval
void get_nextval(SString T,int nextval[])
{
int i = 1,j = 0;
nextval[1] = 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];
}
}
}
//利用模式串T的next函数求T在主串S中第pos字符之后的位置的KMP算法
//1=<pos=<StrLength(S)
int Index_KMP(SString S,SString T,int pos,int next[])
{
int i = pos,j = 1;
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];
}
else
{
return 0;
}
}
int main(void)
{
int i,* p;
SString s1,s2;
StrAssign(s1,"aaabaaaab");
printf("主串为：");
StrPrint(s1);
StrAssign(s2,"aaaab");
printf("子串为：");
StrPrint(s2);
p = (int *)malloc((StrLength(s2) + 1) * sizeof(int));
get_next(s2,p);
printf("子串的next的数组为：");
for (i=1; i<=StrLength(s2); ++i)
{
printf("%d ",* (p+i));
}
printf("\n");
i = Index_KMP(s1,s2,1,p);
if (i)
{
printf("主串和子串在第%d个字符处首次匹配\n",i);
}
else
{
printf("主串和子串匹配不成功\n");
}
get_nextval(s2,p);
printf("子串的nextval数组为：");
for (i=1; i<=StrLength(s2); ++i)
{
printf("%d ",* (p+i));
}
printf("\n");
printf("主串和子串在第%d个字符处首次匹配\n",Index_KMP(s1,s2,1,p));
printf("求串s1的从第5个字符起长度为5的子串s2:\n");
SubString(s2,s1,5,5);
printf("串s2为:");
StrPrint(s2);
return 0;
}
/*
在vc++6.0中的输出结果：
------------------------
主串为：a a a b a a a a b
子串为：a a a a b
子串的next的数组为：0 1 2 3 4
主串和子串在第5个字符处首次匹配
子串的nextval数组为：0 0 0 0 4
主串和子串在第5个字符处首次匹配
求串s1的从第5个字符起长度为5的子串s2:
串s2为:a a a a b
Press any key to continue
------------------------------
*/
⑧ 堆串属于顺序存储
堆串的本质还是顺序存储，只不过内存是动态分配的。
定长顺序存储结构和堆分配存储结构都是顺序存储结构，它们的主要区别是前者的串长是固定的。后者的串长是动态串的定长顺序存储结构的缺点是限定了串的长度，若超出长度则约定截断堆分配存储表示解决上面的问题，它动态分配串值得存储空间。
串值共享的存储空间称之为堆，串的块链存储，表示该存储结构为链式存储结构，存储密度＝串值所占的储存位／实际分配的存位块链结构。
是结构中包含头指针、尾指针、当前串长度的一种结构使用块链结构的目的是为了提高存储密度。串的堆存储结构，与定长顺序串的存储结构类似，都是用一维数组地址连续的存储单元存储串的字符序列，不同的是堆串的存储空间是在程序执行过程中动态分配的。
定长顺序存储结构和堆分配存储结构都是顺序存储结构，它们的主要区别是前者的串长是固定的，后者的串长是动态串的定长顺序存储结构的缺点是限定了串的长度，若超出长度则约定截断堆分配存储表示解决上面的问题，它动态分配串值得存储空间。
⑨ 【数据结构】串的定长顺序储存，如何初始化
如果是用字符来存储，那用length指向它的长度， 存储如下 data[length++] = ch;
⑩ 假设串采用定长顺序存储结构
#include <stdio.h>
int STRCMP(char *p, char *q)
{
while(*p == *q && *p != '\0'){
p++;
q++;
}
return *p - *q;
}
int main()
{
char str1[128];
char str2[128];
int n;
printf("input str1:\n");
scanf("%s", str1);
printf("input str2:\n");
scanf("%s", str2);
n = STRCMP(str1,str2);
printf("%d", n);
putchar('\n');
return 0;
}