线性表串的有关运算
7.2.4 线性表的基本运算_大学计算机基础_[共2页]
140假设顺序表(a 1,a 2,…,a n )中每个元素占用d 个存储单元,则元素a i 的存储位置为:Loc(a i )=Loc(a 1)+(i −1)*d其中,Loc(a 1)是顺序表的第一个元素a 1的存储位置,通常称为顺序表的起始地址(简称为基地址)。
顺序存储结构示意图如图7.8所示。
由此,只要知道了基地址和每个数据元素的大小,就可通过上述表达式计算出任意一个数据元素的存储地址,顺序表中任意一个数据元素都可以随机存取,所以顺序表是一种随机存取的存储结构。
对于线性表的顺序存储结构,元素之间的逻辑顺序与存储单元中的各结点的物理顺序是一致的,线性关系利用物理上的相邻关系来体现。
性线表的顺序存储结构具备如下两个基本特点。
①线性表中所有元素结点的存储空间是连续的。
②线性表中数据元素在存储空间中是按逻辑顺序依次存放的。
【例7.6】设有一个顺序表的第一个元素的存储地址是1000,每个元素所点的存储空间大小为2,计算该线性表的第5个元素的地址是多少?解:在顺序表中,每个元素在存储器中占用的空间大小相同,若第一个元素存放的位置是Loc(a 1),每个元素占用的空间大小为d ,则元素a i 的存放位置为:Loc(a i )=Loc(a 1)+(i −1)*d (1≤i ≤n )。
把题中各值代入公式可得第5个元素的地址为1008。
7.2.4线性表的基本运算1.线性表的基本运算线性表是一个相当灵活的数据结构,它的长度可根据需要增加或缩短。
在线性表上定义的基本运算有以下六种。
①初始化:InitList (&L ),建立一个空线性表L 。
②求表长:ListLength (L ),求线性表L 中数据元素的个数。
③读表元素:GetNode (L,i ),取线性表L 中第i 个数据元素。
④定位:LocateNode (L,e ),查找线性表L 中值为e 的数据元素是否存在,若L 中有多个与e 值相同,则返回首次找到的元素位置;若L 中没有元素的值为e ,则返回一个特殊值表示查找失败。
线性表 知识点总结
线性表知识点总结线性表的特点:1. 有序性:线性表中的元素是有序排列的,每个元素都有唯一的前驱和后继。
2. 可变性:线性表的长度是可变的,可以进行插入、删除操作来改变表的元素数量。
3. 线性关系:线性表中的元素之间存在明确的前驱和后继关系。
4. 存储结构:线性表的存储结构有顺序存储和链式存储两种方式。
线性表的操作:1. 查找操作:根据元素的位置或值来查找线性表中的元素。
2. 插入操作:将一个新元素插入到线性表中的指定位置。
3. 删除操作:将线性表中的某个元素删除。
4. 更新操作:将线性表中的某个元素更新为新的值。
线性表的顺序存储结构:顺序存储结构是将线性表的元素按照其逻辑顺序依次存储在一块连续的存储空间中。
线性表的顺序存储结构通常采用数组来实现。
数组中的每个元素都可以通过下标来访问,因此可以快速的进行查找操作。
但是插入和删除操作会导致元素位置的变动,需要进行大量数据搬移,效率较低。
线性表的链式存储结构:链式存储结构是将线性表的元素通过指针相连,形成一个链式结构。
每个元素包含数据和指向下一个元素的指针。
链式存储结构不需要连续的存储空间,可以动态分配内存,适合插入和删除频繁的场景。
但是链式结构的元素访问不如顺序结构高效,需要通过指针来逐个访问元素。
线性表的应用场景:1. 线性表适用于数据元素之间存在明确的前后关系,有序排列的场景。
2. 顺序存储结构适用于元素的插入和删除操作较少,对元素的随机访问较频繁的场景。
3. 链式存储结构适用于插入和删除操作较频繁的场景,对元素的随机访问较少。
线性表的操作的时间复杂度:1. 查找操作:顺序存储结构的时间复杂度为O(1),链式存储结构的时间复杂度为O(n)。
2. 插入和删除操作:顺序存储结构的时间复杂度为O(n),链式存储结构的时间复杂度为O(1)。
线性表的实现:1. 顺序存储结构的实现:使用数组来存储元素,通过下标来访问元素。
2. 链式存储结构的实现:使用链表来实现,每个元素包含数据和指向下一个元素的指针。
第二章基本数据结构及其运算
第二章基本数据结构及其运算本章主要介绍计算机中常见的基本数据结构及其运算。
数据结构是计算机存储、组织和管理数据的方式,它对算法的设计和效率有很大影响。
基本数据结构包括线性表、栈、队列、树、图等,以及它们的各种运算。
1.线性表线性表是最简单、最常用的数据结构之一、线性表的定义是n个数据元素的有限序列:a1, a2, …, an。
其中,a1是第一个元素,an是最后一个元素。
线性表的特点是数据元素之间是一对一的关系,每个元素只有一个直接前驱和一个直接后继。
线性表的运算主要包括:-插入:在指定位置插入一个元素;-删除:删除指定位置上的元素;-查找:根据索引查找元素;-修改:根据索引修改元素的值;-遍历:依次访问线性表中的每个元素。
2.栈栈是一种特殊的线性表,具有“先进后出”(Last In First Out, LIFO)的特点。
在栈中,最后插入的元素是第一个被访问的元素,最先插入的元素是最后一个被访问的元素。
栈的运算主要包括:-入栈:将一个元素插入到栈的顶部;-出栈:从栈顶删除一个元素;-栈顶元素:查看栈顶的元素,不改变栈的内容。
栈的应用场景有很多,例如函数调用、表达式求值、迷宫求解等。
3.队列队列也是一种特殊的线性表,具有“先进先出”(First In First Out, FIFO)的特点。
在队列中,最先插入的元素是第一个被访问的元素,最后插入的元素是最后一个被访问的元素。
队列的运算主要包括:-入队:将一个元素插入到队列的末尾;-出队:从队列的头部删除一个元素;-队首元素:查看队列的头部元素,不改变队列的内容。
队列的应用场景有很多,例如任务调度、缓冲区管理、广度优先等。
4.树树是一种非线性的数据结构,它由n(n>=0)个节点组成的有限集合。
特点是每个节点最多有一个直接前驱和多个直接后继。
树的运算主要包括:-插入节点:在树中插入一个新节点;-删除节点:从树中删除一个指定节点;-查找节点:在树中查找一个指定节点;-遍历树:按照其中一种规则,依次访问树中的每个节点。
线性表的逻辑结构及其基本操作.
4. 顺序表上的基本运算-插入
template<class Type> BOOL Array<Type>::Insert(int k,Type x) { if(k<0 || k>=ArraySize || ArraySize==MaxSize) return false; for(int i=ArraySize-1;i>=k;i--) elements[i+1]=elements[i]; elements[k]=x; ArraySize++; return true; }
public:
Array(int Size=DefaultSize); Array(Type *pa,int Size=DefaultSize); Array(const Array<Type> &x); ~Array(){ delete []elements; }; Array<Type> & operator = (const Array<Type> &A); Type & operator [] (int i); operator Type * () const { return elements; }; void ClearAll() { ArraySize=0; }; void Init(int size){ ArraySize=size;GetArray(); }; BOOL Delete(int k);//删除第k项 BOOL Insert(int k,Type x);//将数据x插在第k项 int Length() const { return ArraySize; }; int GetMax() const { return MaxSize; };
串的定义和基本运算(精)
int length;
}STRING; 不同的定义形式,算法中的处理也略有不同。下 面我们将给出在第二种顺序存储方式下串的几个基本 操作的算法。
(1) 串的赋值 int StringAssign(STRING*s,char *string_constant) { if (s->str) free(s->str);
2. 链式存储结构
由于串结构中每个数据元素为一个字符,所以最 直接的链式存储结构是每个结点的数据域存放一个字 符。举例:
S
s
t r i n g^
图 4-1
优点是操作方便;不足ቤተ መጻሕፍቲ ባይዱ处是存储密度较低。所 谓存储密度为:
串值所占的存储单元 存储密度
实际分配的存储密度
若要将多个字符存放在一个结点中,就可以缓解 这个问题。举例:
(4)串连接 int Concat(STRING *s1,STRING s2) { STRING s; StringAssign(&s,s1->str); //将s1原来的内容保留在s中 len=Length(s1)+Length(s2);
数据结构线性表总结
数据结构线性表总结线性表是一种经典的数据结构,它是由n个数据元素组成的有序序列。
线性表的实现方法有很多种,比较常见的有顺序表和链表。
本文将详细介绍线性表的定义、基本操作、顺序表和链表的实现以及一些常用的线性表算法。
一、线性表的定义线性表是由n个数据元素组成的有序序列,其中每个元素只有一个直接前驱元素和一个直接后继元素。
二、线性表的基本操作1-初始化线性表:创建一个空的线性表,初始化其相关属性。
2-插入元素:向线性表的指定位置插入一个元素。
3-删除元素:从线性表中删除指定位置的元素。
4-查找元素:在线性表中查找指定值的元素,并返回其位置。
5-获取元素:获取线性表中指定位置的元素值。
6-修改元素:修改线性表中指定位置的元素值。
7-遍历线性表:按照线性表的顺序,依次访问每个元素。
三、顺序表的实现顺序表是用一段连续的存储空间存储线性表的元素,并通过下标来定位元素的位置。
顺序表的实现包括以下步骤:1-定义顺序表的结构体:包含线性表的长度和存储元素的数组。
2-初始化顺序表:给顺序表的长度和数组的每个元素赋初值。
3-插入元素:在指定位置之后的所有元素后移一位,并将要插入的元素放入该位置。
4-删除元素:将指定位置之后的所有元素前移一位,覆盖需要删除的元素。
5-查找元素:从第一个元素开始遍历,逐一比较元素的值,直到找到指定值的元素或遍历结束。
6-获取元素:根据给定的位置直接定位元素的值。
7-修改元素:根据给定的位置直接修改元素的值。
8-遍历线性表:按照数组的下标顺序,依次访问每个元素。
四、链表的实现链表是通过指针将线性表的元素连接起来的数据结构。
链表的实现包括以下步骤:1-定义链表的节点结构体:包含元素的值和指向下一个节点的指针。
2-初始化链表:创建一个空的链表,初始化头节点的指针为NULL。
3-插入元素:创建一个新的节点,将其插入到指定位置的节点之后。
4-删除元素:找到要删除节点的前驱节点,将前驱节点的指针指向要删除节点的后继节点,释放要删除节点的空间。
线性表及其运算
用数量级的形式表示线性表插入、删除运算 的时间复杂性均为O(n)。
返回
数组与线性表
数据结构
数组与线性表
2. 数据元素的删除(Delete)
设用一个一维数组A[n]表示此线性表, 原来有n个元素,元素值已给定。
要求删除第i个数据元素,由于线性表元 素在数组中必须连续排列,中间不能有 空单元,故将此元素删除后,它后面的 所有元素都需要向前移动一个单元,且 数据元素总数由原来的n减少到n-1.
Байду номын сангаас
各元素均需向后移动一个单元位置,这样才
能将G插入到i位置,且元素总数由m增加为
(m+1)。
数组与线性表
void insert(A, int n, m, i, G)
{
int j;
if (i<1||i>n+1)
插
printf(“i值错!\n”);
入
else {
函
for (j=m;j>=i;j--)
数
A[j+1]=A[j];
当i=n时,则循环一次也不执行,只是将 元素数目n比原来减少一个,而第n个数 据元素不必再考虑,其余的各单元的元 素均维持不变,这是最好的情况。
数组与线性表
3. 算法的时间复杂性
可以用数据元素的移动次数来度量这两个算 法的时间复杂性。
插入时,最少循环0次,最多循环n次,如i 的各种取值概率相同,则平均循环次数为 n/2;
数组与线性表
删除函数
void delete(A,int n,i) {
int j; if (i<1||i>n)
线性表总结(顺序表、单链表、静态链表、循环链表、双向循环链表)
线性表总结(顺序表、单链表、静态链表、循环链表、双向循环链表)线性表的存储结构是线性结构,其特点是:在数据元素的⾮空有限集中(1)存在惟⼀的⼀个被称做“第⼀个”的数据元素;(2)存在惟⼀的⼀个被称做“最后⼀个”的数据元素;(3)除第⼀个之外,集合中的每个数据元素均只有⼀个前驱;(4)除最后⼀个之外,集合中每个数据元素均只有⼀个后继。
顺序表:定义:1. ⽤⼀组地址连续的存储单元依次存储线性表中的数据元素2.代码的实现const int LIST_INIT_SIZE=100; // 线性表存储空间初始分配量const int LISTINCREMENT=10; // 线性表存储空间分配增量typedef struct {ElemType *elem; // 存储空间基址int length; // 当前长度int listsize; // 允许的最⼤存储容量// (以sizeof(ElemType)为单位)} SqList; // 顺序表空表图⽰例:判空:(SqList &L)L->length == 0?空表:⾮空判满:(SqList &L)L->length == L->listsize?表满:未满表长度计算⽅法:(SqList &L)L->length单链表:定义:1. ⽤⼀组地址任意的存储单元依次存储线性表中的数据元素2.代码的实现Struct L_Node{Elemtype data;Struct L_Node* next;}Node;空表图⽰例:判空:headNode->next == NULL? 空表:⾮空判满:\表长度计算⽅法:Node* posNode=headNode; //初始化int length; // 表的结数for(length=0;posNode->next != NULL;length++)posNode=posNode->next;静态链表:定义:1. ~在不设指针类型的⾼级程序设计语⾔中使⽤链表结构。
串的定义及基本运算
趟比较开始位置的下一个字符(i=i-j+2) ,同时将
子串的位置返回到第一个位置。
进行下次比较,直到匹配成功或者主串已经结束。
2020年1月30日
17
• 算法举例
主 串 S abbaba 子 串 T aba
第1趟 S a b b a b a T aba
3. 设定长串存储空间:char s[MAXSIZE+1]; 用s[0] 存放串的实际长度,串值存放在s[1]~s[MAXSIZE],字 符的序号和存储位置一致,应用更为方便。
2020年1月30日
10
4.2.2 定长顺序串的基本运算
第四章 串
1.串联接:把两个串s1和s2首尾连接成一个新串s 。 int StrConcat1(s1,s2,s) { int i=0 , j, len1, len2;
(ii)在最坏的情况下,如果不成功的匹配都发生在子 串(t)的最后一个字符的位置,即每趟比较都要进行 m 次,这样比较的趟数要 n 趟,因此,此情况下的时 间复杂度为 O(n*m)。
例如:s="aaaaaaaaaab"
t="aaaab"
2020年1月30日
20
第四章 串
算法分析 优点:算法简单 实现容易 缺点:算法复杂度高; 重复比较次数比较,只要不匹配的情况,要 从新开始;回溯次数比较多。
8.串删除 StrDelete(s,i,len) 操作条件:串s存在,1≤i≤StrLength(s), 0≤len≤StrLength(s)-i+1。 操作结果:删除串s 中从第i个字符开始的长度为 len的子串,s的串值改变。
9.串替换 StrRep(s,t,r) 操作条件:串s,t,r存在,t不为空。 操作结果:用串r 替换串s中出现的所有与串t相等
数据结构--线性表的基本运算及多项式的算术运算
数据结构:线性表的基本运算及多项式的算术运算一、实验目的和要求实现顺序表和单链表的基本运算,多项式的加法和乘法算术运算。
要求:能够正确演示线性表的查找、插入、删除运算。
实现多项式的加法和乘法运算操作。
二、实验环境(实验设备)X64架构计算机一台,Windows 7操作系统,IDE: Dev C++ 5.11编译器: gcc 4.9.2 64bit二、实验原理及内容程序一:实现顺序表和单链表的实现本程序包含了四个文件,分别是LinearListMain.cpp,linearlist.h,seqlist.h,singlelist.h。
分别是主程序,线性表抽象类,顺序储存线性表的实现,链表储存顺序表的实现。
文件之间的关系图:本程序一共包含了三个类:分别是LinearList(线性表抽象类),SeqList(顺序储存的线性表),SingleList(链表储存的线性表)。
类与类之间的关系图如下:其实,抽象类LinearList规定了公共接口。
分别派生了SeqList类和SingleList。
SingleList类与SingleList类分别实现了LinearList类中的所有接口。
程序代码以及分析:Linearlist类:#include <iostream>using namespace std;template <class T>class LinearList{protected:int n; //线性表的长度public:virtual bool IsEmpty() const=0; //判读是否是空线性表virtual int Length() const=0; //返回长度virtual bool Find(int i,T& x) const=0; //将下标为i的元素储存在x中,成功返回true,否则返回falsevirtual int Search(T x) const=0; //寻找值是x的元素,找到返回true,否则返回falsevirtual bool Insert(int i,T x)=0; //在下标为i的元素后面插入xvirtual bool Delete(int i)=0; //删除下标为i的元素virtual bool Update(int i,T x)=0;//将下标为i的元素更新为x virtual void Output(ostream& out)const=0; //将线性表送至输出流};包含了一个保护数据成员n,和8种运算,具体说明见注释。
线性表的基本运算
实习题目:线性表的基本运算及多项式的算术运算。
班级:姓名:学号日期:2013.9.30一、问题描述实现顺序表和单链表的基本运算,多项式的加法和乘法算术运算。
能够正确演示线性表的查找、插入、删除运算。
实现多项式的加法和乘法运算操作。
熟练掌握顺序表的各种基本操作。
学会使用线性表解决应用问题的方法;加深对抽象模板类、类的继承、代码重用、重载等C++语言机制的理解和使用。
二、概要设计为实现程序包含的文件如下:多项式:线性表:三、详细设计1、程序的类和类的层次结构在顺序表建立为类SeqList、在单链表建立类SingleList和类Node。
顺序表和单链表有一个共同的基类LinearList,并且,类SeqList、类SingleList均公有继承基类LinearList。
类SingleList 是类Node的友元类。
在多项式的加法和乘法中,使用了两个类,即类Term、类Polynominal,且类Polynominal 是类Term的友元类。
四、程序代码顺序表和单链表的基本运算以及多项式加法及乘法。
详细代码另附纸。
五、测试和调试以上结果为多项式的加法;以上结果为多项式的乘法。
六、实习小结(1)线性表的顺序存储结构具有2个弱点:其一,在进行插入和删除操作时,需移动大量元素;其二,必须预先分配较大的空间,但往往存储空间不能得到充分利用;但线性表的链式存储结构能有效克服这2个弱点。
其一,插入、删除只需修改指针无需移动元素;其二,链表中结点空间是动态申请的。
(2)程序必须有较强的健壮性。
程序在合法输入时正确只是一个最基本的要求,还需考虑当输入不合法时,应当给予错误提示,并作合理处理。
串的定义及其基本运算
则操作结果是s1="he bei"
(4)串比较 strcmp(s1,s2); 操作结果:若s1==s2,返回值为0;若s1<s2, 返回值<0;若 s1>s2, 返回值>0。
result= strcmp("abc","Abc");/* result>O */
5页
2020/9/19
数据结构(C语言版)
第5章 串
(2)串拷贝strcpy (s1,s2) ; 执行操作:将s2的串值赋值给s1。 操作结果:串s1的值与串s2的值相等,s1原来的值被覆盖掉。 例如 strcpy (str3,str1)
(3)连接操作 :strcat (s1,s2) ; 操作结果:将字符串s2连接 在s1的后面,s2不改变。
例如:substr(str1, str3,5,3),则str3="bin"
再例如:substr(str1, str3,14,3),则str3=NULL
(6)子串定位 strindex(s,t);找子串t在主串s中首次出 现的位置
操作结果:若t∈s,则操作返回t在s中首次出现的位置, 否则返回值为-1。
串的链式存储结构简称为链串。其结点数据域为单个
子串的位置:子串在主串中首次出现时,该子串的 首字符对应主串的序号称为子串在主串中的位置。
例如,设A和B分别为
A="This is a string”,B ="is“
则B是A的子串,A为主串。且位置是3。
4页
2020/9/19
数据结构(C语言版)
第5章 串
特别规定,空串是任意串的子串,任意串是其自身 的子串。 串相等:两个串相等,是指两个串的长度相等且对 应字符都相同。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
实验目的、实验原理和内容:
一、实验目的:掌握特殊线性表串的有关运算和串存储结构的基本特点。
二、实验原理:完成特殊单链表-----字符串的运算。
具体1、完成2个字符串的连接运算;2、完成2个字符串的比较运算。
三、实验内容及要求:
1、设2个字符串存分别在2个数组中,编写一个算法程序实现这2个串的连接
运算,要求不能使用C语言中的字符串连接函数。
2、设2个字符串存分别存储在2个单链表中,编写一个算法程序实现这2个串的比较运算,要求不能使用C语言中的字符串比较函数。
四、实验总结
1、1)源代码:
#include<stdio.h>
#include<stdlib.h>
#define MAXSTRLEN 255
typedef char SString[MAXSTRLEN+1];
void Concat(SString S1,SString S2)
{
int i,j;
SString T;
if(S1[0]+S2[0]<=MAXSTRLEN)
{
for(i=1;i<=(int)S1[0];i++)
{
T[i]=S1[i];
}
for(i=((int)S1[0])+1,j=1;i<=((int)S1[0])+((int)S2[0]),j<=(int)S2[0];i++,j++)
{
T[i]=S2[j];
}
T[0]=S1[0]+S2[0];
printf("串未被截断.连接后的串为:");
}
else if(S1[0]+S2[0]>MAXSTRLEN)
{
for(i=1;i<=(int)S1[0];i++)
{
T[i]=S1[i];
}
for(i=((int)S1[0])+1,j=1;i<=MAXSTRLEN,j<=MAXSTRLEN-((int)S1[0]);i++,j++) {
T[i]=S2[j];
}
T[0]=MAXSTRLEN;
printf("串被截断.连接后的串为:");
}
else{
for(i=0;i<=MAXSTRLEN;i++)
{
T[i]=S1[i];
}
T[0]=S1[0];
printf("串被截断.连接后的串为:");
}
for(i=1;i<=(int)T[0];i++)
{
printf("%c",T[i]);
}
}
main()
{
SString S1,S2,T;
int i,num1,num2;
printf("请输入第一个字符串的长度:");
scanf("%d",&num1);
S1[0]=num1;
getchar();
printf("请输入第一个字符串:");
for(i=1;i<=S1[0];i++)
{
scanf("%c",&S1[i]);
}
getchar();
printf("请输入第二个字符串的长度:");
scanf("%d",&num2);
S2[0]=num2;
getchar();
printf("请输入第二个字符串:");
for(i=1;i<=S2[0];i++)
{
scanf("%c",&S2[i]);
}
getchar();
Concat(S1,S2);
system("pause");
return 0;
}
2)实验步骤:
定义,三个SString型的变量S1、S2和T,其中T是由S1和S2连接的到的串。
T[0],S1[0],S2[0]分别存储T、S1和S2的长度。
T的前段部分和S1相等,只需把S1的值赋给T,T的后段部分和S2相等,即把S2的值赋给T即可。
只是须对超长部分事实“截断”操作。
(1)S1加S2的长度小于等于MAXSTRLEN,则得到的串是正确的结果;(2)S1的长度小于MAXSTRLEN而S1加S2的长度大于MAXSTRLEN,则将串S2的一部分截断。
(3)S1的长度等于MAXSTRLEN,则得到的串T和串S1相等。
3实验中遇到的问题:
需对S1[0]、S2[0]、T[0]进行强制类型转换;在返回T时出现类型不匹配的问题。
可以直接在链接函数后面打印出连接后的结果。
2、1)源代码
#include<stdio.h>
typedef struct StrNode
{
char ch;
struct StrNode* next;
}Node,*Linklist;
Linklist CreateStr()//创建链表,并输入元素
{
char c;
Linklist L;
Node *r,*s;
int flag=1;
L=(Node*)malloc(sizeof(Node));//分配头结点
L->ch=0;
L->next=NULL;
r=L;//r时钟指向链表的表尾
printf("请输入字符串(以#结束):");
while(flag==1)
{
c=getchar();
if(c!='#')
{
s=(Node*)malloc(sizeof(Node));//分配新节点
s->ch=c;
r->next=s;
r=s;//链接
(int)s->ch++;
}
else{
flag=0;
r->next=NULL;
}
}
return s;
}
int StrCompare(Linklist s1,Linklist s2)//s1和s2的比较函数{
int n,m;
Node *r,*s;
r=s1->next;
s=s2->next;
while(r!=NULL&&s!=NULL)
{
if(r->ch==s->ch)
{
r=r->next;
s=s->next;
}
else
return (r->ch)-(s->ch);
}
return (s1->ch)-(s2->ch);
}
main()
{
Linklist s1,s2;
int a;
s1=CreateStr();//建立链表,输入元素
s2=CreateStr();
a=StrCompare(s1,s2);//s1和s2的比较函数
if(a>0)
printf("第一个字符串大于第二个字符串.");
else if(a<0)
printf("第一个字符串小于第二个字符串");
else
printf("两个字符串相等.");
system("pause");
return 0;
}
2)实验步骤
定义两个Linklist的变量s1和s2,创建链表将元素存入s1和s2,比较两个串的大小。
若两个串的长度相等并且元素也一一对应相等则s1=s2,;若s1的第一个元素的ASICC码大于s2的第一个元素的ASICC码值,则s1>s2;反之,s2>s1。
对于比较函数的返回值来说,若s1>s2则返回>0的值,若s1<s2则返回<0的值,若相等则返回0;
3)遇到的问题:
用尾插法建立链表时由于新节点加到链表末尾,r应该始终指向链表的表尾。