数据结构顺序表(电话通讯录)
数据结构算法经典 -顺序表
insertsort(struct sqlist *p,int n)
{
int i,j;
for(i=2;i<=n;i++)
{
p->sqlist[0]=p->sqlist[i];
j=i-1;
while(j>0 && p->sqlist[0]<p->sqlist[j])
printf("\n");
for(i=1;i<=n;i++)
printf("%d",p->sqlist[i]);
printf("\n");
}
}
display(struct sqlist *p)
{
int j;
if (p->size==0)
printf("此表为空无法显示！");
else
{
for (j=i;j<p->size;j++)
p->sqlist[j]=p->sqlist[j+1];
p->size--;
}
printf("此线性表为：");
for (i=1;i<=p->size;i++)
printf("%d->",p->sqlist[i]);
printf("%d",p->sqlist[j]);
}
}
main()
{
int i,select,a,j;int w;
数据结构(c语言版)课后习题答案完整版
数据结构(c语言版)课后习题答案完整版数据结构(C语言版)课后习题答案完整版一、数据结构概述数据结构是计算机科学中一个重要的概念，用来组织和存储数据，使之可以高效地访问和操作。
在C语言中，我们可以使用不同的数据结构来解决各种问题。
本文将提供完整版本的C语言数据结构的课后习题答案。
二、顺序表1. 顺序表的定义和基本操作顺序表是一种线性表，其中的元素在物理内存中连续地存储。
在C 语言中，我们可以通过定义结构体和使用指针来实现顺序表。
以下是顺序表的一些基本操作的答案：（1）初始化顺序表```ctypedef struct{int data[MAX_SIZE];int length;} SeqList;void InitList(SeqList *L){L->length = 0;}```（2）插入元素到顺序表中```cbool Insert(SeqList *L, int pos, int elem){if(L->length == MAX_SIZE){return false; // 顺序表已满}if(pos < 1 || pos > L->length + 1){return false; // 位置不合法}for(int i = L->length; i >= pos; i--){L->data[i] = L->data[i-1]; // 向后移动元素 }L->data[pos-1] = elem;L->length++;return true;}```（3）删除顺序表中的元素```cbool Delete(SeqList *L, int pos){if(pos < 1 || pos > L->length){return false; // 位置不合法}for(int i = pos; i < L->length; i++){L->data[i-1] = L->data[i]; // 向前移动元素 }L->length--;return true;}```（4）查找顺序表中的元素```cint Search(SeqList L, int elem){for(int i = 0; i < L.length; i++){if(L.data[i] == elem){return i + 1; // 找到元素，返回位置 }}return -1; // 未找到元素}```2. 顺序表习题解答（1）逆置顺序表```cvoid Reverse(SeqList *L){for(int i = 0; i < L->length / 2; i++){int temp = L->data[i];L->data[i] = L->data[L->length - 1 - i]; L->data[L->length - 1 - i] = temp;}}```（2）顺序表元素去重```cvoid RemoveDuplicates(SeqList *L){for(int i = 0; i < L->length; i++){for(int j = i + 1; j < L->length; j++){if(L->data[i] == L->data[j]){Delete(L, j + 1);j--;}}}}```三、链表1. 单链表单链表是一种常见的链式存储结构，每个节点包含数据和指向下一个节点的指针。
数据结构实验一顺序表
数据结构实验一1、实验目的∙掌握线性表的逻辑特征∙掌握线性表顺序存储结构的特点，熟练掌握顺序表的基本运算2、实验内容：建立顺序表，完成顺序表的基本操作：初始化、插入、删除、逆转、输出、销毁, 置空表、求表长、查找元素、判线性表是否为空；1．问题描述：利用顺序表,设计一组输入数据（假定为一组整数），能够对顺序表进行如下操作：∙创建一个新的顺序表，实现动态空间分配的初始化；∙根据顺序表结点的位置插入一个新结点(位置插入)，也可以根据给定的值进行插入(值插入)，形成有序顺序表；∙根据顺序表结点的位置删除一个结点(位置删除)，也可以根据给定的值删除对应的第一个结点，或者删除指定值的所有结点(值删除)；∙利用最少的空间实现顺序表元素的逆转；∙实现顺序表的各个元素的输出；∙彻底销毁顺序线性表，回收所分配的空间；∙对顺序线性表的所有元素删除，置为空表；∙返回其数据元素个数；∙按序号查找，根据顺序表的特点，可以随机存取，直接可以定位于第i 个结点，查找该元素的值，对查找结果进行返回；∙按值查找，根据给定数据元素的值，只能顺序比较，查找该元素的位置，对查找结果进行返回；∙判断顺序表中是否有元素存在，对判断结果进行返回；.编写主程序，实现对各不同的算法调用。
2．实现要求：∙“初始化算法”的操作结果：构造一个空的顺序线性表。
对顺序表的空间进行动态管理，实现动态分配、回收和增加存储空间；∙“位置插入算法”的初始条件：顺序线性表L 已存在，给定的元素位置为i，且1≤i≤ListLength(L)+1 ；操作结果：在L 中第i 个位置之前插入新的数据元素e，L 的长度加1；∙“位置删除算法”的初始条件：顺序线性表L 已存在，1≤i≤ListLength(L) ；操作结果：删除L 的第i 个数据元素，并用e 返回其值，L 的长度减1 ；∙“逆转算法”的初始条件：顺序线性表L 已存在；操作结果：依次对L 的每个数据元素进行交换，为了使用最少的额外空间，对顺序表的元素进行交换；∙“输出算法”的初始条件：顺序线性表L 已存在；操作结果：依次对L 的每个数据元素进行输出；∙“销毁算法”初始条件：顺序线性表L 已存在；操作结果：销毁顺序线性表L；∙“置空表算法”初始条件：顺序线性表L 已存在；操作结果：将L 重置为空表；∙“求表长算法”初始条件：顺序线性表L 已存在；操作结果：返回L 中数据元素个数；∙“按序号查找算法”初始条件：顺序线性表L 已存在，元素位置为i，且1≤i≤ListLength(L)操作结果：返回L 中第i 个数据元素的值∙“按值查找算法”初始条件：顺序线性表L 已存在，元素值为e；操作结果：返回L 中数据元素值为e 的元素位置；∙“判表空算法”初始条件：顺序线性表L 已存在；操作结果：若L 为空表，则返回TRUE，否则返回FALSE；分析: 修改输入数据，预期输出并验证输出的结果，加深对有关算法的理解。
数据结构课程设计报告——哈希表实现电话号码查询
数据结构课程设计报告一、需求分析1问题描述：根据需要设计出合理的Hash函数，并由此建立相应的Hash表。
要求：1)每个电话用户信息包括（姓名，电话，住址）信息。
2)可以使用姓名与地址查找相应的用户信息。
3)使用Hash表实现。
使用开放定址法解决冲突。
2 基本要求：1）记录每个用户的姓名、地址和电话。
2）从键盘输入，以姓名和地址为关键字分别建立Hash表。
3）用开放地址法解决冲突。
4）分别按姓名和地址查找并显示电话号码。
二、概要设计三、详细设计typedef struct //定义结构Hash表{定义Hash表内的所有成员}HashTable[MaxSize];int Key(char x[])//关键字转换为数值{求字符数组x每个字符对应的asc值的绝对值之和，并返回最后结果}void CreateHT(HashTable ha)//创建Hash表{创建Hash表，并初始化它}void InsertHTna(HashTable ha,int &n,KeyType k,int d) //按姓名插入{以姓名为关键字，调用关键字转换函数将对应的电话号码存储到相应的存储空间。
若该位置已经被存储，则向后移一位（当移到最后一位，就移到头部继续）。
若还有冲突重复上一步。
当所有空间都查过一遍，发现没有空位，则输出“没有存储空间”。
}void InsertHTadd(HashTable ha,int &n,KeyType k,int d)//按地址插入{以地址为关键字，调用关键字转换函数将对应的电话号码存储到相应的存储空间。
若该位置已经被存储，则向后移一位（当移到最后一位，就移到头部继续）。
若还有冲突重复上一步。
当所有空间都查过一遍，发现没有空位，则输出“没有存储空间”。
}void InserHT(HashTable ha)//Hash表插入{输入用户姓名、地址和电话，分别调用按姓名插入和按地址插入函数进行插入。
数据结构-顺序表
数据结构-顺序表判断题1.(neuDS)所谓随机存取，就是通过⾸地址和元素的位序号值可以在O(1)的时间内找到指定的元素。
F2.(neuDS)在顺序表上进⾏插⼊、删除操作时需要移动元素的个数与待插⼊或待删除元素的位置⽆关。
T F3.顺序存储⽅式只能⽤于存储线性结构。
T F4.在顺序表中取出第i个元素所花费的时间与i成正⽐。
T F5.对于顺序存储的长度为N的线性表，删除第⼀个元素和插⼊最后⼀个元素的时间复杂度分别对应为O(1)和O(N)。
T F6.(neuDS)在顺序表中逻辑上相邻的元素，其对应的物理位置也是相邻的。
F7.顺序存储的线性表可以随机存取。
F8.顺序存储结构的主要缺点是不利于插⼊或删除操作。
F选择题1.⽤数组表⽰线性表的优点是（）。
A.便于插⼊和删除操作B.便于随机存取C.可以动态地分配存储空间D.不需要占⽤⼀⽚相邻的存储空间2.阅读下列程序，其功能是（）。
typedef struct {ElemType *list;int size;intMaxSize;}SeqList;void fun1(SeqList&L) {inti, j;ElemType temp;for (i=0, j= L.sise-1; i<j; i++, j--) {temp=L.list[i];L.list[i]=L.list[j];L.list[j]=temp;}}A.将顺序表原地逆置B.将链表原地逆置C.将顺序表⾸尾元素对换D.将链表⾸尾元素对换3.顺序存储表⽰中数据元素之间的逻辑关系是由（）表⽰的。
A.指针B.逻辑顺序C.存储位置D.问题上下⽂4.顺序表的优点是（）。
A.插⼊操作的时间效率⾼B.适⽤于各种逻辑结构的存储表⽰C.存储密度(存储利⽤率)⾼D.删除操作的时间效率⾼5.若线性表最常⽤的操作是存取第i个元素及其前驱的值，则采⽤( )存储⽅式节省时间。
A.单链表B.双向链表C.单循环链表D.顺序表6.数组A[1..5,1..6]每个元素占5个单元，将其按⾏优先次序存储在起始地址为1000的连续的内存单元中，则元素A[5,5]的地址为：A.1120B.1125C.1140D.11457.若某线性表最常⽤的操作是存取任⼀指定序号的元素和在最后进⾏插⼊和删除运算，则利⽤哪种存储⽅式最节省时间？A.双链表B.单循环链表C.带头结点的双循环链表D.顺序表8.若长度为n的线性表采⽤顺序结构，在第i个数据元素之前插⼊⼀个元素，需要它依次向后移动（）个元素。
数据结构单链表通讯录
实验报告实验名称单链表通讯录一、实验目的1.熟练掌握线性表的类型定义方法、存储方法及其基本运算（元素的插入、删除等）的实现方法，培养综合运用所学知识，根据具体问题进行数据结构设计和算法设计的能力。
二、实验内容1．用带头结点的单链表作存储结构，实现通讯录单链表的建立、查询、修改、排序、合并、统计、结点的查找、移动以及通讯录链表的输出功能。
三、实验要求设计要求：为了实现通讯录管理的操作功能，首先设计一个含有多个菜单项的主控菜单程序，然后再为这些菜单项配上相应的功能。
主控菜单设计要求：菜单内容程序运行后，给出9个菜单项的内容和输入提示：1.创建通讯录链表；2.将姓名为Name的好友的手机号改为MTel；3.输出通讯录；4.插入姓名为Name、手机号为MTel的好友信息,将链表中姓名≤Name的结点放到该结点的前面，将姓名>Name的结点放到该结点后面5.将通讯录按照好友姓名进行非递减排序；6.将两个按姓名非递减排序的通讯录合并为一个，姓名相同且手机号相同的好友记录在结果中只保留一个；7.统计籍贯是“大连”的好友人数；8.将通讯录中倒数第k个结点之后的所有结点移到头结点后面（保持结点间的先后顺序）；9.将通讯录的正中间位置结点之后的全部结点倒置；0.退出管理系统请选择0—9：菜单设计要求：使用数字0—9来选择菜单项，其它输入则不起作用。
四、实验概要设计1)功能框图五. 使用说明1.运行环境：VC6.02.首先选择主控菜单中的操作１，即建表，然后进行其它操作．六．实验截图(见下页)七实验体会附源程序代码：#include<stdio.h>#include<stdlib.h>#include<string.h>#define Newsp (TxlList *)malloc(sizeof(struct TxlList))typedef struct TxlList{char Name[16]; //姓名char MTel[11]; //手机号char Tel[9]; //固定电话char EMail[16]; //邮箱地址char BornAddr[20]; //籍贯(值域："北京"、"上海"、"大连"等等，只写城市名称)char BroadN[50]; //博客名struct TxlList *next; //指针域}TxlList, *TxlLink;void Lbuild1(TxlLink &T){//创建文件FILE *fp;TxlLink q;q=Newsp;q=T;int NUM;char filename[20];printf("\n*请输入要创建的通讯录名:\n");gets(filename);if ((fp=fopen(filename, "wb"))==NULL) { /*以写方式在当前目录打开（新建）文件*/printf("can't open file！！！\n");exit(0); //如果文件无法打开，关闭已经打开的其它文件，结束程序。
数据结构-顺序表-实验报告
实验报告课程数据结构及算法实验项目 1.顺序表的建立和基本运算成绩专业班级*** 指导教师***姓名*** 学号*** 实验日期***实验一顺序表的建立和基本运算一、实验目的1、掌握顺序表存储结构的定义及C/C++语言实现2、掌握顺序表的各种基本操作及C/C++语言实现3、设计并实现有序表的遍历、插入、删除等常规算法二、实验环境PC微机，Windows，DOS，Turbo C或者Visual C++三、实验内容1、顺序表的建立和基本运算（1）问题描述顺序表时常进行的运算包括：创建顺序表、销毁顺序表、求顺序表的长度、在顺序表中查找某个数据元素、在某个位置插入一个新数据元素、在顺序表中删除某个数据元素等操作。
试编程实现顺序表的这些基本运算。
（2）基本要求实现顺序表的每一个运算要求用一个函数实现。
（3）算法描述参见教材算法2.3、算法2.4、算法2.5等顺序表的常规算法。
（4）算法实现#include<malloc.h> // malloc()等#include<stdio.h> // NULL, printf()等#include<process.h> // exit()// 函数结果状态代码#define OVERFLOW -2#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEASIBLE -1typedef int Status; // Status是函数的类型,其值是函数结果状态代码，如OK等typedef int Boolean; // Boolean是布尔类型,其值是TRUE或者FALSE//-------- 线性表的动态分配顺序存储结构-----------#define LIST_INIT_SIZE 10 // 线性表存储空间的初始分配量#define LIST_INCREMENT 2 // 线性表存储空间的分配增量typedef int ElemType;struct SqList{ElemType *elem; // 存储空间基址int length; // 当前长度int listsize; // 当前分配的存储容量(以sizeof(int)为单位)};void InitList(SqList &L) // 算法2.3{ // 操作结果：构造一个空的顺序线性表LL.elem=new ElemType[LIST_INIT_SIZE];if(!L.elem)exit(OVERFLOW); // 存储分配失败L.length=0; // 空表长度为0L.listsize=LIST_INIT_SIZE; // 初始存储容量}void DestroyList(SqList &L){ // 初始条件：顺序线性表L已存在。
数据结构课程设计通讯录管理系统
数据结构课程设计通讯录管理系统一、系统需求分析通讯录管理系统的主要目标是提供一个方便、高效的方式来管理联系人信息。
具体需求包括：1、能够添加联系人，包括姓名、电话号码、电子邮件、地址等基本信息。
2、可以对联系人信息进行修改和删除操作。
3、支持按照姓名、电话号码等关键字进行快速查找。
4、能够以列表形式展示所有联系人的信息。
二、数据结构选择为了实现上述功能，我们需要选择合适的数据结构来存储联系人信息。
考虑到联系人信息的多样性和动态性，链表是一个不错的选择。
链表可以方便地进行插入、删除和修改操作，并且能够灵活地调整存储空间。
另外，为了提高查找效率，我们可以结合使用哈希表。
通过将联系人的关键信息（如姓名或电话号码）进行哈希运算，快速定位到对应的联系人节点。
三、系统功能实现1、添加联系人功能当用户选择添加联系人时，系统会提示用户输入联系人的各项信息。
这些信息被封装成一个结构体，并通过链表的插入操作添加到链表中。
同时，将关键信息映射到哈希表中，以便后续快速查找。
2、修改联系人功能用户输入要修改的联系人的关键字，系统通过哈希表快速找到对应的联系人节点。
然后，提示用户输入修改后的信息，并更新链表和哈希表中的数据。
3、删除联系人功能与修改功能类似，通过关键字找到联系人节点，从链表和哈希表中删除相应的节点和信息。
4、查找联系人功能用户输入查找关键字，系统通过哈希表进行快速定位，如果找到匹配的联系人，则显示其详细信息。
5、展示所有联系人功能遍历链表，将所有联系人的信息以列表形式输出到屏幕上。
四、系统界面设计为了提高用户体验，系统设计了简洁直观的界面。
主界面提供了添加、修改、删除、查找和展示所有联系人等功能选项。
用户通过选择相应的选项，进入对应的操作流程。
五、代码实现示例以下是部分关键代码的示例：｀｀｀c／／联系人结构体typedef struct Contact ｛char name50;char phoneNumber20;char email50;char address100;struct Contact next;｝ Contact;／／哈希表节点结构体typedef struct HashNode ｛char key50;Contact contact;struct HashNode next;｝ HashNode;／／链表插入联系人void insertContact(Contact head, Contact newContact) ｛newContact>next ＝ head;head ＝ newContact;｝／／哈希函数unsigned int hashFunction(const char key) ｛unsigned int hash ＝ 0;while （key) ｛hash ＝（hash ＜＜ 5) ＋ key+＋；｝return hash ％ HASH_TABLE_SIZE;｝／／查找联系人Contact findContact(Contact head, const char key, HashNode hashTable) ｛unsigned int hashValue ＝ hashFunction(key)；HashNode node ＝ hashTablehashValue;while （node) ｛if （strcmp(node>key, key) ＝＝ 0) ｛return node>contact;｝node ＝ node>next;｝Contact current ＝ head;while （current) ｛if （strcmp(current>name, key) ＝＝ 0 ｜｜strcmp(current>phoneNumber, key) ＝＝ 0) ｛／／更新哈希表HashNode newNode ＝（HashNode ）malloc(sizeof(HashNode)）；strcpy(newNode>key, key)；newNode>contact ＝ current;newNode>next ＝ hashTablehashValue;hashTablehashValue ＝ newNode;return current;｝current ＝ current>next;｝return NULL;｝｀｀｀六、系统测试在完成系统的开发后，需要进行全面的测试以确保系统的稳定性和可靠性。
数据结构 顺序表 实验报告
重庆交通大学计算机与信息学院数据结构实验报告实验名称：顺序表操作实验性质：课程安排实验所属课程：数据结构指导教师：班级： 2008级3班学号：姓名：完成时间： 2010年 4 月 7 日目录封面 (1)目录 (2)一、实验目的 (3)二、实验内容及要求................................................. (3)（1）实验内容（2）实现功能（3）上交内容三、实验设备及软件 (4)四、设计方案 (5)（一）题目：顺序表及其相关操作（二）设计的主要思路 (5)（三）主要功能 (5)（四）程序大致流程图 (6)五、主要代码（略） (7)六、测试结果及说明 (7)七、实验体会 (10)一、实验目的培养学生在程序设计方面知识的综合应用能力及程序设计能力（包括编制能力及程序调试能力）二、实验内容及要求（1）以顺序存储方式实现线性表进行简单的图书管理，图书信息由学生自行定义。
（2）主要实现以下功能：增加图书、删除图书、修改图书信息、查询与定位（查询方式由学生自行设计）、显示与浏览、图书信息文件的打开与保存等（3）上交内容：1、实验报告：要求内容充实、结构完整、格式规范、说明详细等2、源代码与数据文件：将所有的源代码与测试用数据文件一并压缩后提交注：实验报告、源代码中均需要注明自己的学号、姓名、年级、专业、班级等信息三、实验设备及软件计算机、Visual C++6.0四、设计方案（一）题目：顺序表及其相关操作（二）设计的主要思路1、建立能保存图书信息的数据类型，定义类book1)由于本次实验要求，图书信息自己定义，所以本次选用双精度型作为编号，字符串类型的名称和作者以及整型的页数；2)根据原来定义类的经验，本次程序同样定义了比较完善的共有成员函数，其中包括设置私有成员的值（含有函数重载，包括有参函数和无参函数）、私有成员数据的获取、book数据类型赋值符号的重载、输入、输出，以及文件操作的读入数据函数。
数据结构实验报告(C语言)顺序表__排序
int i,j,n,x,change; n=L->length; change=1; for(i=1;i<=n-1 && change;++i){
change=0; for(j=1;j<=n-i-1;++j)
if(L->r[j] > L->r[j+1]){ x=L->r[j]; L->r[j]=L->r[j+1]; L->r[j+1]=x; change=1;
void QuickSort(SqeList *L,int low,int high){ int mid; if(low<high){ mid=Partition(L,low,high); QuickSort(L,low,mid-1); QuickSort(L,mid+1,high); }
}
//直接选择排序
printf("\n7-直接选择排序结果为:\n"); SelectSort(&l); PrintList(&l); printf("\n"); printf("\n8-二路归并结果为:\n"); MergeSort(&l);
PrintList(&l); printf("\n"); } else printf("请输入大于 0 的值: "); return 0; }
} else{
MR->r[k]=R->r[j]; ++j; } ++k; } while(i<=mid) MR->r[k++]=R->r[i++]; while(j<=high) MR->r[k++]=R->r[j++]; }
编制通讯录
电子通讯录功能如下：Function choose1.Read2.Append3.Delete4.Search5.Save and exit6.Quit说明：上图是电子通讯录的主菜单，利用它，将能够轻松地录入一个朋友的电话号码，通讯地址和出生日期，而且它还提供了检索和删除功能。
在后面还将提供按生日先后排序的功能，这些都有助于该通讯录的管理。
电子通讯录是采用线性表作为电子通讯录功能如下：Function choose1.Read2.Append3.Delete4.Search5.Save and exit6.Quit说明：上图是电子通讯录的主菜单，利用它，将能够轻松地录入一个朋友的电话号码，通讯地址和出生日期，而且它还提供了检索和删除功能。
在后面还将提供按生日先后排序的功能，这些都有助于该通讯录的管理。
电子通讯录是采用线性表作为程序的基本结构的。
设计思想：1。
用顺序表设计电子通讯录的结构为了表示较为复杂的数据内容，一般用结构这种数据类型，第一步就是在结构中定义所需要的各项信息。
一般的通讯录都包括姓名，性别，出生年月，通讯地址和联系电话这几项，而在这几项中，出生年月又包括年份，月份和日期三项，通讯地址包括邮编和家庭地址二项，我们把这些联系较为紧密的内容又用单独的结构表示，这样就产生了电子通讯录的基本结构：struct addr /*通讯地址结构定义*/{ char post_num[10]; /*邮编*/char addr[40]; /*家庭地址*/};struct birth /*出生年月结构定义*/{ int year; /*年份*/int month; /*月份*/int day; /*日期*/};struct friend /*电子通讯录结构定义*/{ int number; /*序号*/char name[20] /*姓名*/char sex; /*性别*/struct birth birth; /*出生年月*/struct addr addr; /*通信地址*/char telephone[13]; /*联系电话*/};定义的主结构friend包含了前述的五项内容 name,sex,和telephone分别代表了姓名，性别和联系电话。
数据结构实验报告—顺序表
《算法与数据结构》课程实验报告一、实验目的1、实现线性表的顺序存储结构。
2、熟悉C++程序的基本结构，掌握程序中的头文件、实现文件和主文件之间的相互关系及各自的作用。
3、熟悉顺序表的基本操作方式,掌握顺序表相关操作的具体实现。
二、实验内容及要求对顺序存储的线性表进行一些基本操作。
主要包括：（1）插入：操作方式为在指定元素前插入、在指定元素之后插入、在指定位置完成插入。
（2）删除：操作方式可分为删除指定元素、删除指定位置的元素等，尝试实现逻辑删除操作。
（3）显示数据。
（4）查找：查询指定的元素（可根据某个数据成员完成查询操作）。
（5）定位操作：定位指定元素的序号。
（6）更新：修改指定元素的数据。
（7）数据文件的读写操作等。
其它操作可根据具体需要自行补充。
要求线性表采用类的定义,数据对象的类型自行定义。
三、系统分析（1）数据方面：能够实现多种数据类型顺序表的创建，并进行操作，不同的数据类型数据使用不同的文本文件保存。
（2）功能方面：能够实现线性表的一些基本操作，主要包括：1.计算表最大可以容纳表项个数以及当前表的当前长度。
2.能够进行添加操作，在已有的数据文件中进行数据的添加。
3.能够进行搜索操作，返回搜索项在表中表项序号4.能够进行定位操作，定位到表中合理位置。
5.能够进行取值操作，根据用户需求取出表中某项的值。
6.能够进行修改操作，在用户选择修改项后将重新输入内容修改到对应位置。
7.能够进行插入操作，在用户选择合理位置并输入插入内容后即可。
8.能够进行删除操作，用户根据选择表中项数删除对应数据。
9.能够进行判断表空或表满。
四、系统设计（1）设计的主要思路根据实验要求，首先将顺序表模板类完成，并将需要实现的功能代码完善，在写实现各个功能的菜单并将模板类实例化为简单数据类型最后进行调试，由于还需使得顺序表能够存储自定义的学生类类型数据，故根据要求写出Student类，并将之前所写得模板类用学生类数据类型实例化，再进行调试。
C#数据结构之顺序表（SeqList）实例详解
C#数据结构之顺序表（SeqList）实例详解本⽂实例讲述了C#数据结构之顺序表(SeqList)实现⽅法。
分享给⼤家供⼤家参考，具体如下：线性结构(Linear Stucture)是数据结构(Data Structure)中最基本的结构，其特征⽤图形表⽰如下：即：每个元素前⾯有且只有⼀个元素(称为“前驱”)，同样后⾯有且只有⼀个元素(称为"后继")--注：起始元素的前驱认为是空，末尾元素的后继认为也是空，这样在概念上就不冲突了。
线性表(List)是线性结构的⼀种典型实现，它⼜可以分为：顺序表(SeqList)和链表(LinkList)⼆⼤类.顺序表（SeqList）的基本特征为：元素在内部存储时是⼀个接⼀个在存储单元中按顺序存储的，所以只要知道"起始元素的存储地址"--称为顺序表的基地址(Base Address)以及顺序表中任何元素的位置(即它是第⼏个元素)，就能直接定位到该元素的地址，从⽽直接访问到该元素的值。
也就是说存储/读取每个元素所⽤的时间是相同的，即所谓的“随机存取”C#语⾔中数组(Array)在内存中占⽤的就是⼀组连续的存储区域，所以⽤数组来实现顺序表再适⽤不过。
先来定义线性表的通⽤接⼝IListDS.cs(注：DS为DataStructure的缩写)namespace 线性表{public interface IListDS<T>{//取得线性表的实际元素个数int Count();//清空线性表void Clear();//判断线性表是否为空bool IsEmpty();//（在末端）追加元素void Append(T item);//在位置i“前⾯”插⼊元素itemvoid InsertBefore(T item, int i);//在位置i“后⾯”插⼊元素itemvoid InsertAfter(T item, int i);//删除索引i处的元素T RemoveAt(int i);//获得索引位置i处的元素T GetItemAt(int i);//返回元素value的索引int IndexOf(T value);//反转线性表的所有元素void Reverse();}}顺序表(SeqList)的实现：using System;using System.Text;namespace 线性表{/// <summary>/// 顺序表/// </summary>/// <typeparam name="T"></typeparam>public class SeqList<T> : IListDS<T>{private int maxsize;private T[] data;private int last;//类索引器public T this[int index]{get{return this.GetItemAt(index);}set{if (index < 0 || index > last + 1)Console.WriteLine("Position is error");return;}data[index] = value;}}//最后⼀个元素的下标public int Last{get { return last; }}//最⼤容量public int Maxsize{get { return this.maxsize; }set { this.maxsize = value; }}//构造函数public SeqList(int size){data = new T[size];maxsize = size;last = -1;}//返回链表的实际长度public int Count(){return last + 1;}//清空public void Clear(){last = -1;}//是否空public bool IsEmpty(){return last == -1;}//是否满public bool IsFull(){return last == maxsize - 1;}//(在最后位置)追加元素public void Append(T item){if (IsFull()){Console.WriteLine("List is full");return;}data[++last] = item;}/// <summary>///前插/// </summary>/// <param name="item">要插⼊的元素</param> /// <param name="i">要插⼊的位置索引</param> public void InsertBefore(T item, int i){if (IsFull()){Console.WriteLine("List is full");return;}if (i < 0 || i > last + 1){Console.WriteLine("Position is error");return;}if (i == last + 1){data[last + 1] = item;}{//位置i及i以后的元素，全部后移for (int j = last; j >= i; j--){data[j + 1] = data[j];}data[i] = item;}++last;}/// <summary>/// 后插/// </summary>/// <param name="item"></param>/// <param name="i"></param>public void InsertAfter(T item, int i){if (IsFull()){Console.WriteLine("List is full");return;}if (i < 0 || i > last){Console.WriteLine("Position is error");return;}if (i == last){data[last + 1] = item;}else{//位置i以后的元素(不含位置i)，全部后移for (int j = last; j > i; j--){data[j + 1] = data[j];}data[i+1] = item;}++last;}/// <summary>/// 删除元素/// </summary>/// <param name="i">要删除的元素索引</param> /// <returns></returns>public T RemoveAt(int i){T tmp = default(T);if (IsEmpty()){Console.WriteLine("List is empty");return tmp;}if (i < 0 || i > last){Console.WriteLine("Position is error!");return tmp;}if (i == last){tmp = data[last];}else{tmp = data[i];//位置i以及i以后的元素前移for (int j = i; j <= last; j++){data[j] = data[j + 1];}}--last;return tmp;}/// <summary>/// 获取第⼏个位置的元素/// </summary>/// <param name="i">第⼏个位置</param>/// <returns></returns>public T GetItemAt(int i){if (IsEmpty() || (i < 0) || (i > last)){Console.WriteLine("List is empty or Position is error!"); return default(T);}return data[i];}/// <summary>/// 定位元素的下标索引/// </summary>/// <param name="value"></param>/// <returns></returns>public int IndexOf(T value){if (IsEmpty()){Console.WriteLine("List is Empty!");return -1;}int i = 0;for (i = 0; i <= last; i++){if (value.Equals(data[i])){break;}}if (i > last){return -1;}return i;}/// <summary>/// 元素反转/// </summary>public void Reverse(){T tmp = default(T);for (int i = 0; i <= last / 2; i++){tmp = data[i];data[i] = data[last-i];data[last-i] = tmp;}}public override string ToString(){StringBuilder sb = new StringBuilder();for (int i = 0; i <= last; i++){sb.Append(data[i].ToString() + "，");}return sb.ToString().TrimEnd('，');}}}测试代码⽚段：Console.WriteLine("顺序表测试开始...");SeqList<string> seq = new SeqList<string>(10);seq.Append("x");seq.InsertBefore("w", 0);seq.InsertBefore("v", 0);seq.Append("y");seq.InsertBefore("z", seq.Count());Console.WriteLine(seq.Count());//5Console.WriteLine(seq.ToString());//v,w,x,y,zConsole.WriteLine(seq[1]);//wConsole.WriteLine(seq[0]);//vConsole.WriteLine(seq[4]);//zConsole.WriteLine(seq.IndexOf("z"));//4Console.WriteLine(seq.RemoveAt(2));//xConsole.WriteLine(seq.ToString());//v,w,y,zseq.InsertBefore("x", 2);Console.WriteLine(seq.ToString());//v,w,x,y,zConsole.WriteLine(seq.GetItemAt(2));//xseq.Reverse();Console.WriteLine(seq.ToString());//z,y,x,w,vseq.InsertAfter("z_1", 0);seq.InsertAfter("y_1", 2);seq.InsertAfter("v_1", seq.Count()-1);Console.WriteLine(seq.ToString());//z，z_1，y，y_1，x，w，v，v_1顺序表的优点：读取元素时可直接定位，所以在某些操作(⽐如将顺序表元素反转合围)中，不需要完全遍历，循环次数(即时间复杂度)相对完全遍历⽽⾔能减少⼀半。
数据结构课程设计-简易手机通讯录管理系统
一、课题名称简易手机通讯录管理系统（线性表、查找、排序）二、主要内容简易手机通讯录管理系统的设计主要是实现对手机通讯录的管理和相关操作。
基本功能如下：（1）联系人信息录入、添加功能:包括手机号(此处用短号，5位，不能重复)、姓名、家庭住址的录入和添加。
（2）联系人信息查询功能：能①按手机号进行查询。
②按联系人姓名进行查询。
（3）排序：①能按手机号升序进行排序；②能按姓名进行升序排序，姓名相同时按手机号从小到大进行排序（4）联系人信息的修改、删除功能：①按手机号进行联系人信息的修改和删除。
②按姓名进行联系人信息的修改和删除，多个姓名时，再指定具体的号码。
（5）统计功能：统计自己的联系人有多少个。
三、课题设计的基本思想，原理和算法描述（1）本次课程设计题目为简易手机通讯录管理系统，主要运用到线性表中顺序表的相关知识，以及顺序查找的思想和冒泡排序算法。
（2）界面设计//菜单函数int menu(){int c;printf("\n\n\t☆☆☆☆☆☆☆手机通讯录信息管理系统☆☆☆☆☆☆☆☆\n\n");printf("******************************************************************* ***\n");printf(" 1.添加联系人信息\n");printf(" 2.查询联系人信息\n");printf(" 3.对联系人信息进行排序\n");printf(" 4.修改联系人信息\n");printf(" 5.删除联系人信息\n");printf(" 6.统计联系人个数\n");printf(" 0.退出信息管理系统\n");printf("******************************************************************* ***\n\n");printf("★请输入您的选择(0-6):");while(1){scanf("%d",&c);if(c<0||c>6)printf("\n▲输入错误！请重新选择：");elsebreak;}return c;}//主函数void main(){SqList * L;InitList(L);system("color 3f");while(1){switch(menu()){case 1:system("cls");printf("\n\t\t\t信息的增加\n");ListAdd(L);break;case 2:system("cls");printf("\n\t\t\t信息的查询\n");Search(L);break;case 3:system("cls");printf("\n\t\t\t对信息进行排序\n");Paixu(L);break;case 4:system("cls");printf("\n\t\t\t信息的修改\n");ListModify(L);break;case 5:system("cls");printf("\n\t\t\t信息的删除\n");Delete(L);break;case 6:system("cls");printf("\n\t\t\t统计联系人个数\n");ListLength(L);break;case 0:printf("再见！\n");return;default:printf("\n▲输入错误！请重新选择：");break;}}}（3）功能模块的实现初始化顺序表void InitList(SqList *&L)L=(SqList *)malloc(sizeof(SqList));L->length=0;}增加信息函数。
数据结构实验报告顺序表
数据结构实验报告顺序表(此⽂档为word格式，下载后您可任意编辑修改！)江西理⼯⼤学软件学院计算机类课程实验报告课程名称：数据结构班级：姓名：学号：江西理⼯⼤学软件学院实验⼆：顺序表2012年11⽉10⽇⼀. 实验⽬的掌握顺序表的逻辑结构、存储结构、以及操作。
⼆. 问题描述线性表是由n(n≥0)个元素（结点）a1, a2, …, a n组成的有限序列，其中a i中的i称为该数据元素的位置（序号），n为数据元素的个数（表的长度），当n等于0时称为空表。
按逻辑次序依次把数据元素存放在⼀组连续的地址存储单元⾥的线性表称为顺序表。
在这⾥，我们通过C++中的动态数组来实现顺序表的存放，并通过建⽴顺序表类实现它的各种操作。
三. 实验要求实现顺序表的三个框架操作：随机⽣成，⽤已有顺序表初始化另⼀个顺序表，输⼊顺序表。
以及⼗个基本操作：在第i个元素之前插⼊元素，判断是否为空，求元素个数，取第i个元素，查找第⼀个与e满⾜compare()关系的元素，返回元素的前驱，返回后继，删除第i个元素，把⼀个顺序表赋值给另⼀个顺序表，置空顺序表。
四. 实验环境3323机房OS：WxpC环境：1、TC2.02、VC++ 6.0 五．运⾏结果程序开始界⾯1.随机⽣成顺序表（元素值为0到99之间的整数）2. ⽤已有的顺序表初始化另⼀个顺序表3. 输⼊顺序表基本操作：1.在第i个元素之前插⼊⼀个元素2. 判断顺序表是否为空3. 求顺序表中元素的个数4. 取第i个元素5. 查找第⼀个与之满⾜compare()关系的元素序号6. 返回某元素的前驱7. 返回某元素的后继8. 删除第i个元素9. 把⼀个顺序表复制给另⼀个顺序表10. 把顺序表置空11.顺序表的运⽤六．实验⼼得熟悉最基本的数据类型——顺序表，同时我们让我们熟练C++的基本操作，模板的使⽤，以及模块化的设计思想。
同时也运⽤顺序表做⼀些简单的运⽤，⽐如顺序表的并交差运算，学⽣管理系统等等。
数据结构实验报告-实验一顺序表、单链表基本操作的实现
数据结构实验报告-实验⼀顺序表、单链表基本操作的实现实验⼀顺序表、单链表基本操作的实现l 实验⽬的1、顺序表（1）掌握线性表的基本运算。
（2）掌握顺序存储的概念，学会对顺序存储数据结构进⾏操作。
（3）加深对顺序存储数据结构的理解，逐步培养解决实际问题的编程能⼒。
l 实验内容1、顺序表1、编写线性表基本操作函数：（1）InitList(LIST *L,int ms)初始化线性表；（2）InsertList(LIST *L,int item,int rc)向线性表的指定位置插⼊元素；（3）DeleteList1(LIST *L,int item)删除指定元素值的线性表记录；（4）DeleteList2(LIST *L,int rc)删除指定位置的线性表记录；（5）FindList(LIST *L,int item)查找线性表的元素；（6）OutputList(LIST *L)输出线性表元素；2、调⽤上述函数实现下列操作：（1）初始化线性表；（2）调⽤插⼊函数建⽴⼀个线性表；（3）在线性表中寻找指定的元素；（4）在线性表中删除指定值的元素；（5）在线性表中删除指定位置的元素；（6）遍历并输出线性表；l 实验结果1、顺序表（1）流程图（2）程序运⾏主要结果截图（3）程序源代码#include<stdio.h>#include<stdlib.h>#include<malloc.h>struct LinearList/*定义线性表结构*/{int *list; /*存线性表元素*/int size; /*存线性表长度*/int Maxsize; /*存list数组元素的个数*/};typedef struct LinearList LIST;void InitList(LIST *L,int ms)/*初始化线性表*/{if((L->list=(int*)malloc(ms*sizeof(int)))==NULL){printf("内存申请错误");exit(1);}L->size=0;L->Maxsize=ms;}int InsertList(LIST *L,int item,int rc)/*item记录值；rc插⼊位置*/ {int i;if(L->size==L->Maxsize)/*线性表已满*/return -1;if(rc<0)rc=0;if(rc>L->size)rc=L->size;for(i=L->size-1;i>=rc;i--)/*将线性表元素后移*/L->list[i+=1]=L->list[i];L->list[rc]=item;L->size++;return0;}void OutputList(LIST *L)/*输出线性表元素*/{int i;printf("%d",L->list[i]);printf("\n");}int FindList(LIST *L,int item)/*查找线性元素，返回值>=0为元素的位置，返回-1为没找到*/ {int i;for(i=0;i<L->size;i++)if(item==L->list[i])return i;return -1;}int DeleteList1(LIST *L,int item)/*删除指定元素值得线性表记录，返回值为>=0为删除成功*/ {int i,n;for(i=0;i<L->size;i++)if(item==L->list[i])break;if(i<L->size){for(n=i;n<L->size-1;n++)L->list[n]=L->list[n+1];L->size--;return i;}return -1;}int DeleteList2(LIST *L,int rc)/*删除指定位置的线性表记录*/{int i,n;if(rc<0||rc>=L->size)return -1;for(n=rc;n<L->size-1;n++)L->list[n]=L->list[n+1];L->size--;return0;}int main(){LIST LL;int i,r;printf("list addr=%p\tsize=%d\tMaxsize=%d\n",LL.list,LL.size,LL.Maxsize);printf("list addr=%p\tsize=%d\tMaxsize=%d\n",LL.list,LL.list,LL.Maxsize);while(1){printf("请输⼊元素值，输⼊0结束插⼊操作:");fflush(stdin);/*清空标准输⼊缓冲区*/scanf("%d",&i);if(i==0)break;printf("请输⼊插⼊位置：");scanf("%d",&r);InsertList(&LL,i,r-1);printf("线性表为：");OutputList(&LL);}while(1){printf("请输⼊查找元素值，输⼊0结束查找操作：");fflush(stdin);/*清空标准输⼊缓冲区*/scanf("%d ",&i);if(i==0)break;r=FindList(&LL,i);if(r<0)printf("没有找到\n");elseprintf("有符合条件的元素，位置为：%d\n",r+1);}while(1){printf("请输⼊删除元素值，输⼊0结束查找操作：");fflush(stdin);/*清楚标准缓存区*/scanf("%d",&i);if(i==0)break;r=DeleteList1(&LL,i);if(i<0)printf("没有找到\n");else{printf("有符合条件的元素，位置为：%d\n线性表为：",r+1);OutputList(&LL);}while(1){printf("请输⼊删除元素位置，输⼊0结束查找操作：");fflush(stdin);/*清楚标准输⼊缓冲区*/scanf("%d",&r);if(r==0)break;i=DeleteList2(&LL,r-1);if(i<0)printf("位置越界\n");else{printf("线性表为：");OutputList(&LL);}}}链表基本操作l 实验⽬的2、链表（1）掌握链表的概念，学会对链表进⾏操作。
数据结构-顺序表的基本操作的实现-课程设计-实验报告
数据结构-顺序表的基本操作的实现-课程设计-实验报告顺序表的基本操作的实现一、实验目的1、掌握使用VC++上机调试顺序表的基本方法；2、掌握顺序表的基本操作：建立、插入、删除等运算。
二、实验仪器安装VC++软件的计算机。
三、实验原理利用线性表的特性以及顺序存储结构特点对线性表进行相关的基本操作四、实验内容程序中演示了顺序表的创建、插入和删除。
程序如下：#include#include/*顺序表的定义：*/#define ListSize 100typedef struct{ int data[ListSize]; /*向量data用于存放表结点*/i nt length; /*当前的表长度*/}SeqList;void main(){ void CreateList(SeqList *L,int n);v oid PrintList(SeqList *L,int n);i nt LocateList(SeqList *L,int x);v oid InsertList(SeqList *L,int x,int i);v oid DeleteList(SeqList *L,int i);SeqList L;i nt i,x;i nt n=10;L.length=0;c lrscr();C reateList(&L,n); /*建立顺序表*/P rintList(&L,n); /*打印建立后的顺序表*/p rintf("INPUT THE RESEARCH ELEMENT");s canf("%d",&x);i=LocateList(&L,x);p rintf("the research position is %d\n",i); /*顺序表查找*/ p rintf("input the position of insert:\n");s canf("%d",&i);p rintf("input the value of insert\n");s canf("%d",&x);I nsertList(&L,x,i); /*顺序表插入*/P rintList(&L,n); /*打印插入后的顺序表*/p rintf("input the position of delete\n");s canf("%d",&i);D eleteList(&L,i); /*顺序表删除*/P rintList(&L,n); /*打印删除后的顺序表*/g etchar();}/*顺序表的建立：*/void CreateList(SeqList *L,int n){int i;printf("please input n numbers\n");for(i=1;i<=n;i++)scanf("%d",&L->data[i]);L->length=n;}/*顺序表的打印：*/void PrintList(SeqList *L,int n){int i;printf("the sqlist is\n");for(i=1;i<=n;i++)printf("%d ",L->data[i]);}/*顺序表的查找：*/int LocateList(SeqList *L,int x){int i;for(i=1;i<=10;i++)if((L->data[i])==x) return(i);else return(0);}/*顺序表的插入：*/void InsertList(SeqList *L,int x,int i){int j;for(j=L->length;j>=i;j--)L->data[j+1]=L->data[j];L->data[i]=x;L->length++;}void DeleteList(SeqList *L,int i) /*顺序表的删除：*/ { int j;for(j=i;j<=(L->length)-1;j++)L->data[j]=L->data[j+1];}五、实验步骤1、认真阅读和掌握本实验的程序。
数据结构顺序表实验报告
《数据结构》课程实验报告实验名称顺序表实验序号 1 实验日期姓名院系班级学号专业指导教师成绩教师评语一、实验目的和要求(1)理解线形表的逻辑结构特征(2)理解并掌握顺序表(3)了解顺序表的各种基本运算二、实验项目摘要编写一个程序algo2-1.cpp，实现顺序表的各种基本运算，并在此基础上设计一个主程序并完成如下功能：（1）初始化顺序表L；（2）依次采用尾插法插入a,b,c,d,e元素；（3）输出顺序表L；（4）输出顺序表L长度；（5）判断顺序表L是否为空；（6）输出顺序表L的第3个元素；（7）输出元素’a’的位置；（8）在第4个元素位置上插入’f’元素；（9）输出顺序表L；（10）删除L的第3个元素；（11）输出顺序表L；（12）释放顺序表L。
三、实验预习内容顺序表基本运算，包括：建立顺序表、顺序表基本运算算法（初始化线形表、销毁线形表、判断线形表是否为空表、求线形表的长度、输出线形表、球现行表中某个数据元素值、按元素值查找、插入元素数据、删除数据元素）三、实验结果与分析#include <stdio.h>#include <malloc.h>#define MaxSize 50typedef int ElemType;typedef struct{ ElemType elem[MaxSize];int length;} SqList;void InitList(SqList *&L){ L=(SqList *)malloc(sizeof(SqList));L->length=0;}void DestroyList(SqList *L){free(L);}int ListEmpty(SqList *L){return(L->length==0);}int ListLength(SqList *L){return(L->length);}void DispList(SqList *L){ int i;if (ListEmpty(L)) return;for (i=0;i<L->length;i++)printf("%c",L->elem[i]);printf("\n");}int GetElem(SqList *L,int i,ElemType &e) { if (i<1 || i>L->length)return 0;e=L->elem[i-1];return 1;}int LocateElem(SqList *L, ElemType e) {int i=0;while (i<L->length && L->elem[i]!=e) i++; if (i>=L->length)return 0;elsereturn i+1;}int ListInsert(SqList *&L,int i,ElemType e) { int j;if (i<1 || i>L->length+1)return 0;i--;for (j=L->length;j>i;j--)L->elem[j]=L->elem[j-1];L->elem[i]=e;L->length++;}int ListDelete(SqList *&L,int i,ElemType &e){ int j;if (i<1 || i>L->length)return 0;i--;e=L->elem[i];for (j=i;j<L->length-1;j++)L->elem[j]=L->elem[j+1];L->length--;return 1;}void main(){SqList *L;ElemType e;printf("初始化顺序表L\n");InitList(L);printf("依次采用尾插法插入a,b,c,d,e元素\n"); ListInsert(L,1,'a');ListInsert(L,2,'b');ListInsert(L,3,'c');ListInsert(L,4,'d');ListInsert(L,5,'e');printf("输出顺序表L:");DispList(L);printf("顺序表L长度=%d\n",ListLength(L));printf("顺序表L为%s\n",(ListEmpty(L)?"空":"非空")); GetElem(L,3,e);printf("顺序表L的第3个元素=%c\n",e);printf("元素a的位置=%d\n",LocateElem(L,'a'));printf("在第4个元素位置上插入f元素\n"); ListInsert(L,4,'f');printf("输出顺序表L:");DispList(L);printf("删除L的第3个元素\n");ListDelete(L,3,e);printf("输出顺序表L:");DispList(L);printf("释放顺序表L\n");}注：空间不够，可以增加页码。
数据结构(行逻辑连接的顺序表求矩阵相乘自己的解释)
/*功能：Q=M*N解释：其中M的行数为M.mu，列数为M.nu，非零元素的个数为M.tu；N的行数为N.mu，列数为N.nu，非零元素的个数为N.tu；而且，M列数和N的行数必须相等，即M.nu=N.mu；矩阵Q的行数和列数则分别为M.mu，N.nu，非零元素的个数暂且不能确定*//*定义数据存放的格式结构体*/typedef struct{int i,j;ElemType e;}Triple;//结构体名为Triple，三个元素分别为行i；列j，以及值e。
typedef struct{Triple data[MAX+1];int rpos[MAXRC]; //整型数组，数组下标表示矩阵的行数，相应的值表示对应行数的第一个非零元素在data[]数组中的相对位置int mu,nu,tu;}RLSMAtrix;//结构体名为RLSMatrix，4个元素，data是一个结构体数组，其元素的类型就是你上面的Triple，//mu，nu，tu分别代表一个矩阵的行列数和非零元素的个数；这个结构体就是表示一个举证的结构体mulsmatrix(RLSMatrix M,RLSMatrix N,RLSMatrix Q){if(M.nu != N.mu)return ERROR; //如果M的列数和N的行数不相等，则矩阵无法想成，返回错误。
Q.mu = M.mu;Q.nu = N.nu;Q.tu = 0;if(M.tu * N.tu != 0){ //两个举证都不是零矩阵，否则Q一定为零矩阵for(Mrow=1;Mrow<=M.mu;++Mrow){ //处理M的每一行Qtemp[] = 0; //累加器置0Q.rpos[Mrow] = Q.tu + 1; //Q矩阵中的第Mrow行的第一个元素在数组data[]里面的逻辑顺序Q.rpos[Mrow]，Q.tu表示前面循环所得的非零元素的个数，Q.tu+1则为新的一行开始的逻辑顺序。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
数据结构用顺序表实现的电话通讯录（C语言）#include<stdio.h>#include<malloc.h>#include<math.h>#include<string.h>#define FALSE 0#define ERROR 0#define OK 1#define INFEASIBLE -1#define LIST_INIT_SIZE 10#define LIST_INCREMENT 5#define N 5typedef int Status;typedef struct{ char name[10]; //姓名char num[15]; //号码}student;typedef struct{student *elem;//存储空间基址int length;//当前长度int listsize;//当前分配的存储空间(以sizeof(student)为单位) }Sqlist;Sqlist L; //定义全局变量L 为Sqllist类型Status ListInsert(Sqlist &L,int i,student e){//插入学生信息到顺序表L中int j;student *newbase;if(i<1||i>L.length+1) return ERROR; //i值不合法if(L.length>=L.listsize)//当前存储空间已满，增加分配{newbase=(student*)realloc(L.elem,(LIST_INIT_SIZE+LIST_INCREMENT)*(sizeof(student)));if(!newbase) //存储分配失败exit(OVERFLOW);L.elem=newbase;//新基址L.listsize+=LIST_INCREMENT;//增加存储容量}for(j=L.length;j>=i;j--)L.elem[j]=L.elem[j-1]; //插入位置及之后元素的右移L.elem[i-1]=e;L.length++;return OK;void InitList(Sqlist &L){//创建顺序表L.elem=(student *)malloc(LIST_INIT_SIZE*sizeof(student));if(!L.elem) exit(OVERFLOW);//存储分配失败L.length=0;//空表长度L.listsize=LIST_INIT_SIZE;//初始存储容量}void ListTraverse(Sqlist L,void(*vi)(student &)){//显示顺序表中的所有记录system("cls");printf("姓名电话号码\n");student *p;int i;p=L.elem;for(i=1;i<L.length+1;i++)vi(*p++);printf(" 输入0:返回菜单请输入您的选择：");}void print(student &a){//信息输出printf("%-10s%-8s",,a.num);printf("\n");}int ListLength(Sqlist L) //返回顺序表的长度{ return L.length; }int LocateElem(Sqlist L,student e,Status(*compare)(student,student)){//返回L中第一个与e满足关系compare的数据的位序，//若这样的数据不存在，则返回为0；int i=1;//i的初值为第1个元素的位序student*p=L.elem;//p的初值为第1个元素的存储位置while(i<=L.length&&!compare(*p++,e))i++;if(i<=L.length)return i;elsereturn ERROR;}Status ListDelete(Sqlist &L,int i,student &e)//在顺序表L中删除第i个元素，并返回OKsystem("cls"); //清除屏幕int j;if(i<1||i>L.length) //i值不合法return ERROR;else{e=L.elem[i-1];//p为删除元素的位置for(j=i;j<=L.length;j++) L.elem[j-1]=L.elem[j];L.length--;return OK;}}void wrong(){//错误提示信息输出printf("you have inputed a wrong number");printf(" please input the number that is between 0 and 8");}void Delete(Sqlist &L){//根据i删除顺序表中的记录student e;int j;printf("请输入要删除的位置（1≦i≦%d）：",L.length+1);scanf("%d",&j);ListDelete(L,j,e);printf("已删除！");printf("输入0:返回菜单请输入您的选择：");}void ScanIn(Sqlist &L){//信息输入system("cls");int i;student e;char a[2];printf("请输入信息:\n");do{student *p=L.elem;printf("请输入姓名：");scanf("%s",);printf("请输入电话号码：");scanf("%s",e.num);printf("请输入你要插入的位置(1≦i≦%d): ",L.length+1);scanf("%d",&i);ListInsert(L,i,e);jump:printf("是否继续输入信息(y/n)");scanf("%s",a);}while(strcmp(a,"y")==0||strcmp(a,"Y")==0);printf("输入0:返回菜单请输入您的选择：");}student stu[N]={{"小易","137****1111"},{"小二","134****2222"},{"小伞","187****3333"},{"小斯","158****4444"},{"小武","134****5555"}};int stuIntsertList(Sqlist &L){//将结构体数组stu中的记录插入到顺序表int i,j;for(i=0;i<N;i++)j=ListInsert(L,i+1,stu[i]);system("cls");if(j)printf("已成功加入到顺序表中\n");printf(" 输入0:返回菜单请输入您的选择：");return OK;}void menu(){//菜单函数printf("\t\t *************************************\n");printf("\t\t * 1. 导入记录*\n");printf("\t\t * 2. 输入记录*\n");printf("\t\t * 3. 删除记录*\n");printf("\t\t * 4. 显示所有记录*\n");printf("\t\t *0. 返回本菜单*\n");printf("\t\t *************************************\n\n\n");}//开始函数void start(){printf("\n");printf("\t\t\t**************************\n");printf("\t\t\t* 欢迎使用*\n");printf("\t\t\t* 电话查询系统*\n");printf("\t\t\t**************************\n");printf("\t\t\t* *\n");printf("\t\t\t**************************\n");printf("\n");menu();}int main(){int i=0,j;student e;Sqlist p,q;InitList(L);start();while(scanf("%d",&i)){switch(i){case 1: stuIntsertList(L); break;case 2: ScanIn(L);break;case 3: Delete(L);break;case 4: ListTraverse(L,print);break;case 0: menu();break;default:wrong();}}return 0;}。