C++实现顺序表(模版类)

合集下载

顺序表c语言的程序代码

顺序表c语言的程序代码

//----------------------------线性表的动态分配顺序存储结构-------------------------# include "stdio.h"# include "malloc.h"# include "stdlib.h"# define M 5 //线性表存储空间的初始分配量# define N 2 //线性表存储空间的分配增量typedef struct {int *elem; //存储空间基址int length; //当前长度int listsize; //当前分配的存储容量(以sizeof(int)为单位)}SqList;int InitList(SqList *L) { // 构造一个空的线性表LL->elem=(int *)malloc(M*sizeof(int));if(!L->elem) // 存储分配失败exit(-2);L->length=0; // 空表长度为0L->listsize=M; // 初始存储容量return 1;}int IntPut(SqList *L) { //输入数据int i,e;printf ("请输入你要输入数据的个数:\n");scanf ("%d",&e);if (1>e||5<e) { //判断输入数据的个数是否合格,若不合格请重新输入do{printf ("你输入的数据有误!请重新输入:\n");scanf ("%d",&e);}while(1>e||5<e);}printf ("输入正确!\n请开始输入数据并用空格隔开:\n");for (i=0;i<e;i++) { //开始输入数据scanf ("%d",&L->elem[i]);L->length=L->length+1;}return 1;}int OutPut(SqList *L) { //输出数据int i;for (i=0;i<L->length;i++) {printf ("%d",L->elem[i]);printf ("\n");}return 1;}int Find(SqList *L) { //在顺序线性表L中查找第i个值,若找到,则打印出对应的值int i;printf ("请输入你要查找的数据序号:\n");scanf ("%d",&i);if (1>i||L->length<i) { //判断输入的序号是否合格,若不合格请重新输入do{printf ("你输入的数据有误!请重新输入:\n");scanf ("%d",&i);}while(1>i||L->length<i);}printf ("输入的序号正确!\n你输入的序号所对应的数据是:\n");printf ("%d\n",L->elem[i-1]); //打印出对应的值return 0;}int ListInsert(SqList *L) { // 在顺序线性表L的第i个元素之前插入新的元素e,// i的合法值为1≤i≤ListLength(L)+1 int *y,*q,*p,i,e;printf ("请输入你要插入的数据序号:\n");scanf ("%d",&i);if (1>i||(L->length+1)<i) { // 判断输入的序号是否合格,若不合格请重新输入do{printf ("你输入的数据有误!请重新输入:\n");scanf ("%d",&i);}while(1>i||(L->length+1)<i);}printf ("输入的序号正确!\n请输入你要插入的数据:\n");scanf ("%d",&e);if(L->length>=L->listsize) { // 当前存储空间已满,增加容量y=(int *)realloc(L->elem,(L->listsize+N)*sizeof(int));if(!y) // 存储分配失败exit(-2);L->elem=y; // 新基址L->listsize+=N; // 增加存储容量}q=&(L->elem[i-1]); // q为插入位置for(p=&(L->elem[L->length-1]);p>=q;--p) // 插入位置及之后的元素右移*(p+1)=*p;if(L->length>6){printf ("插入失败,线性表L已满!\n");return 1;}*q=e; // 插入e++L->length; // 表长增1return 1;}int ListDelete(SqList *L,int &e) { // 在顺序线性表L中删除第i个元素,并用e返回其值。

C语言顺序表的实现代码

C语言顺序表的实现代码

C语⾔顺序表的实现代码本⽂实例为⼤家分享了C语⾔实现顺序表的具体代码,供⼤家参考,具体内容如下seqlist.h#ifndef __SEQLIST_H__#define __SEQLIST_H__#include<cstdio>#include<malloc.h>#include<assert.h>#define SEQLIST_INIT_SIZE 8#define INC_SIZE 3 //空间增量的⼤⼩typedef int ElemType;typedef struct Seqlist {ElemType *base;int capacity; //顺序表容量int size; //表的⼤⼩}Seqlist;bool Inc(Seqlist *list);//增加顺序表的容量void InitSeqlist(Seqlist *list); //初始化顺序表void push_back(Seqlist *list, ElemType x); //在顺序表的末尾插⼊元素void push_front(Seqlist *list, ElemType x); //在顺序表的头部插⼊元素void show_list(Seqlist *list); //显⽰顺序表中的元素void pop_back(Seqlist *list); //删除顺序表最后⼀个元素void pop_front(Seqlist *list); //删除顺序表第⼀个元素void insert_pos(Seqlist *list, int pos, ElemType x);//在顺序表的选定位置上插⼊数据int find(Seqlist *list, ElemType key); //在顺序表中查找元素key的下标int length(Seqlist *list);//求顺序表的长度void delete_pos(Seqlist *list, int pos); //删除顺序表中特定位置的数据元素void delete_val(Seqlist *list, int key);//删除顺序表中值为key的数据元素void sort(Seqlist *list);//冒泡排序void reverse(Seqlist *list);//逆置顺序列表void clear(Seqlist *list);//清除顺序表中的所有元素void destroy(Seqlist *list);//摧毁顺序表void merge(Seqlist *lt, Seqlist *la, Seqlist *lb);//合并两个顺序列表#endif //__SEQLIST_H__seqlist.cpp#include"seqlist.h"bool Inc(Seqlist *list) {ElemType *newbase = (ElemType*)realloc(list, sizeof(ElemType)*(list->capacity + INC_SIZE)); //重新分配内存空间if (newbase == NULL) {printf("内存空间已满,⽆法再分配内存空间!\n");return false;}list->base = newbase;list->capacity += INC_SIZE;return true;}void InitSeqlist(Seqlist *list) {list->base = (ElemType*)malloc(sizeof(ElemType)*SEQLIST_INIT_SIZE);assert(list->base != NULL);list->capacity = SEQLIST_INIT_SIZE;list->size = 0;}void push_back(Seqlist *list, ElemType x) {if (list->size >= list->capacity && !Inc(list)) { //Inc(list)⽤来判断增加顺序表容量是否成功,只有在失败的情况下才会进⼊if语句中 printf("顺序表容量已满,⽆法再在表尾继续插⼊新元素!\n");return;}list->base[list->size] = x;list->size++;}void push_front(Seqlist *list, ElemType x) {if (list->size >= list->capacity && !Inc(list)) {printf("顺序表容量已满,⽆法再在表头插⼊新元素!\n"); return;}for (int i = list->size;i > 0;i--) {list->base[i] = list->base[i - 1];}list->base[0] = x;list->size++;}void show_list(Seqlist *list) {for (int i = 0;i < list->size;i++) {printf("%d ", list->base[i]);}printf("\n");}void pop_back(Seqlist *list) {if (list->size == 0) {printf("顺序表已空,⽆法再在表尾删除元素!\n");return;}list->size--;}void pop_front(Seqlist *list) {if (list->size == 0) {printf("顺序表已空,⽆法再在表头删除元素!\n");return;}for (int i = 0;i < list->size - 1;i++) {list->base[i] = list->base[i + 1];}list->size--;}void insert_pos(Seqlist *list, int pos, ElemType x) {if (pos<0 || pos>list->size) {printf("插⼊位置不合法,⽆法插⼊元素!\n");return;}if (list->size >= list->capacity && !Inc(list)) {printf("顺序表容量已满,⽆法在插⼊新的元素!\n");return;}for (int i = list->size;i > pos;i--) {list->base[i] = list->base[i - 1];}list->base[pos] = x;list->size++;}int find(Seqlist *list, ElemType key) {for (int i = 0;i < list->size;i++) {if (list->base[i] == key)return i;}return -1;}int length(Seqlist *list) {return list->size;}void delete_pos(Seqlist *list, int pos) {if (pos < 0 || pos >= list->size) {printf("删除位置不合法,⽆法删除元素!\n");return;}for (int i = pos;i < list->size - 1;i++) {list->base[i] = list->base[i + 1];}list->size--;}void delete_val(Seqlist *list, int key) {int pos = find(list, key);if (pos == -1) {printf("顺序表中没有这个元素!\n");return;}delete_pos(list, pos);}void sort(Seqlist *list) {for (int i = 0;i < list->size - 1;i++) {//排序的趟数(例如5个数据需要⽐较4趟)for (int j = 0;j < list->size - 1 - i;j++) {//每⼀趟⽐较中的⽐较次数(例如5个数据在第0趟需要⽐较4次) if (list->base[j] > list->base[j + 1]) {ElemType temp = list->base[j];list->base[j] = list->base[j + 1];list->base[j + 1] = temp;}}}}void reverse(Seqlist *list) {if (list->size == 0 || list->size == 1) return;int low = 0, high = list->size - 1;while (low < high) {ElemType temp = list->base[low];list->base[low] = list->base[high];list->base[high] = temp;low++;high--;}}void clear(Seqlist *list) {list->size = 0;}void destroy(Seqlist *list) {free(list->base);list->base = NULL;list->capacity = 0;list->size = 0;}void merge(Seqlist *lt, Seqlist *la, Seqlist *lb) {lt->capacity = la->size + lb->size;lt->base = (ElemType*)malloc(sizeof(ElemType)*lt->capacity);assert(lt->base != NULL);int ia = 0, ib = 0, ic = 0;while (ia < la->size&&ib < lb->size) {if (la->base[ia] < lb->base[ib]) {lt->base[ic++] = la->base[ia++];}else {lt->base[ic++] = lb->base[ib++];}}while (ia < la->size) {lt->base[ic++] = la->base[ia++];}while (ib < lb->size) {lt->base[ic++] = lb->base[ib++];}lt->size = la->size + lb->size;show_list(lt);}main.cpp#include"seqlist.h"void main() {Seqlist list;InitSeqlist(&list);ElemType item;int select = 1;while (select) {printf("*******************************************\n");printf("*[1] push_back [2] push_front *\n");printf("*[3] show_list [4] pop_back *\n");printf("*[5] pop_front [6] insert_pos *\n");printf("*[7] find [8] length *\n");printf("*[9] delete_pos [10] delete_value *\n");printf("*[11] sort [12] reverse *\n");printf("*[13] clear [14] merge *\n");printf("*[0] quit_system *\n");printf("*******************************************\n");printf("请选择:>>");scanf("%d", &select);if (select == 0) break;switch (select) {case 1:printf("请输⼊要插⼊的数据(-1结束):>");while (scanf("%d", &item), item != -1) {//先输⼊item的值,只要item不等于-1就接着循环 push_back(&list, item);}break;case 2:printf("请输⼊要插⼊的数据(-1结束):>");while (scanf("%d", &item), item != -1) {push_front(&list, item);}break;case 3:show_list(&list);break;case 4:pop_back(&list);break;case 5:pop_front(&list);break;case 6:printf("请输⼊要插⼊的数据:>");scanf("%d", &item);printf("请输⼊要插⼊的位置:>");scanf("%d", &pos);insert_pos(&list, pos, item);break;case 7:printf("请输⼊要查找的数据:>");scanf("%d", &item);pos = find(&list, item);if (pos == -1)printf("查找的数据元素不在顺序表中!\n");elseprintf("查找的数据元素在顺序表中的下标位置为%d\n", pos);break;case 8:printf("顺序表的长度为%d\n", length(&list));break;case 9:printf("请输⼊要删除数据在顺序表中的下标位置:>");scanf("%d", &pos);delete_pos(&list, pos);break;case 10:printf("请输⼊要删除数据的值:>");scanf("%d", &item);delete_val(&list, item);break;case 11:sort(&list);break;case 12:reverse(&list);break;case 13:clear(&list);break;Seqlist mylist, yourlist;ElemType item1, item2;InitSeqlist(&mylist);InitSeqlist(&yourlist);printf("请输⼊顺序表1中的元素值(-1结束):>");while (scanf("%d", &item1), item1 != -1) {push_back(&mylist, item1);}printf("请输⼊顺序表2中的元素值(-1结束):>");while (scanf("%d", &item2), item2 != -1) {push_back(&yourlist, item2);}merge(&list, &mylist, &yourlist);destroy(&mylist);destroy(&yourlist);break;default:printf("输⼊的选择错误!请重新输⼊!\n");break;}}destroy(&list);}以上就是本⽂的全部内容,希望对⼤家的学习有所帮助,也希望⼤家多多⽀持。

实现顺序表各种基本运算的算法.doc

实现顺序表各种基本运算的算法.doc

实现顺序表各种基本运算的算法.doc
创建顺序表:创建顺序表需要先确定表的大小,即容量。

可以通过动态分配内存来创建顺序表,或者直接在程序中定义一个静态数组作为顺序表的存储空间。

创建时需要初始化表中元素的数量为0。

插入元素:在顺序表中插入元素时,需要先判断表是否已满。

如果表已满,则需要扩容。

扩容可以通过动态分配更大的内存空间,并将原有元素拷贝到新的内存空间中来实现。

如果表未满,则可以直接在表的末尾插入元素。

如果要在指定位置插入元素,则需要先将该位置及其后面的元素依次后移一个位置,再在该位置插入新元素。

删除元素:在顺序表中删除元素时,需要先判断要删除的元素是否存在。

如果不存在,则无需进行任何操作。

如果存在,则可以直接删除该元素。

如果要删除指定位置的元素,则需要先将该位置后面的元素依次前移一个位置,再将表中元素的数量减1。

查找元素:在顺序表中查找元素时,可以使用顺序查找或二分查找算法。

顺序查找的时间复杂度为O(n),而二分查找的时间复杂度为O(log n)。

在使用二分查找时,需要保证顺序表中的元素已经按照升序或降序排列。

修改元素:在顺序表中修改元素时,需要先查找该元素的位置,然后将其修改为新值。

输出顺序表:输出顺序表时,需要遍历表中所有元素,并将它们依次输出。

可以使用循环来实现遍历。

总之,实现顺序表的基本运算需要涉及到动态内存分配、数组操作、循环遍历和查找算法等知识点。

在实际应用中,还需要考虑如何优化算法效率、如何处理异常情况等问题。

用c语言完成顺序表的初始化和创建例子

用c语言完成顺序表的初始化和创建例子

用c语言完成顺序表的初始化和创建例子顺序表是一种线性数据结构,通常用数组实现。

在使用前,需要对其进行初始化和创建。

下面是用c语言完成顺序表的初始化和创建的例子:
1. 初始化
顺序表初始化包括两个步骤:分配内存空间和将各个元素初始化为空。

```
#define MAXSIZE 100 // 定义顺序表的最大长度
typedef struct{
int data[MAXSIZE]; // 存储元素的数组
int length; // 顺序表当前长度
} SqList;
// 初始化顺序表
void InitList(SqList *L){
L->length = 0; // 初始长度为0
}
```
2. 创建
顺序表创建需要输入元素数据,创建过程中需要将元素逐个插入到顺序表中。

```
// 创建顺序表
void CreateList(SqList *L){
int i, n;
printf('请输入元素个数:');
scanf('%d', &n);
printf('请输入%d个元素:
', n);
for(i = 0; i < n; i++){
scanf('%d', &L->data[i]); // 逐个输入元素
L->length++; // 顺序表长度加1
}
}
```
以上就是用c语言完成顺序表的初始化和创建的例子。

通过这个例子,我们可以了解到顺序表的基本操作,并能够在实际编程中运用。

数据结构 耿国华 西北大学 2-9算法实现模板

数据结构 耿国华 西北大学 2-9算法实现模板
}
模板二:多文件结构模板 大型程序一般都采用多文件结构,以下是多文件结构的顺序表合并的例子。 模板的基本结构如下:
⑴ 包含必要的标准头文件,如标准的输入输出头文件 "stdio.h";同时给出必要 的符号常量宏定义; ⑵ 将某一数据结构所对应的类型定义存放在一个头文件当中,将某一数据结 构所对应的基本操作算法存放在一个分类的.c 文件当中.如:可以将单链表的有 关类型定义存放在 seqlist.h 中,将单链表的基本操作算法存放在 seqlist.c 中,之后 通过文件包含#include "seqlist.h" 和#include "seqlist.c",以实现对有关数据类型的 引用及有关操作函数的调用; ⑶ 编写基于某种数据结构的具体问题的算法; ⑷ 编写主函数,其中进行合理的函数调用,形成一个可执行程序。
int k; if((i<1) || (i>L->last+2)) /*首先判断插入位置是否合法*/ {
printf("插入位置 i 值不合法"); return(ERROR); } if(L->last>= MAXSIZE-1) { printf("表已满无法插入"); return(ERROR); } for(k=L->last;k>=i-1;k--) /*为插入元素而移动位置*/ L->elem[k+1]=L->elem[k]; L->elem[i-1]=e; /*在 C 语言数组中,第 i 个元素的下标为 i-1*/ L->last++; return(OK); }
while(i<=LA->last) /*当表 LA 有剩余元素时,则将表 LA 余下的元素赋给

c语言实现顺序表的增删查改逆置简单代码

c语言实现顺序表的增删查改逆置简单代码

c语言实现顺序表的增删查改逆置简单代码1. 顺序表的定义顺序表是一种线性表,其元素在内存中按顺序存储,每个元素占用连续的存储单元。

顺序表的特点是存取速度快,但插入和删除元素时需要移动大量的元素。

顺序表可以用结构体来表示,其定义如下:typedef struct_SeqList {int*data; // 指向数据元素的指针int size; // 顺序表的长度int capacity; // 顺序表的容量} SeqList;2. 顺序表的初始化顺序表的初始化需要分配内存空间来存放数据元素。

可以使用以下代码来初始化顺序表:SeqList*init_seq_list(int capacity) {SeqList*list= (SeqList*)malloc(sizeof(SeqList));if (list==NULL) {return NULL;}list->data= (int*)malloc(sizeof(int) *capacity);if (list->data==NULL) {free(list);return NULL;}list->size=0;list->capacity=capacity;return list;}3. 顺序表的插入在顺序表中插入元素需要移动后面的元素,以保证元素的顺序性。

可以使用以下代码在顺序表中插入元素:int insert_seq_list(SeqList*list, int index, int value) {if (index<0||index>list->size) {return-1;}if (list->size==list->capacity) {// 扩容顺序表int*new_data= (int*)realloc(list->data, sizeof(int) *list->capacity*2);if (new_data==NULL) {return-1;}list->data=new_data;list->capacity*=2;}// 移动后面的元素for (int i=list->size; i>index; i--) {list->data[i] =list->data[i-1];}// 插入元素list->data[index] =value;list->size++;return0;}4. 顺序表的删除从顺序表中删除元素需要移动后面的元素,以保证元素的顺序性。

顺序表的实现-包含插入-删除-查找等操作-完整源代码-有注释-包你喜欢.

实验一顺序表的实现实验目的:熟练掌握顺序表的基本操作(插入、删除、查找等)实验内容:顺序表中的基本操作的实现(初始化、插入、删除、求表长、按值查找、按位置查找)实验要求:以顺序表的动态分配存储结构来实现;所有基本操作均应该以函数的形式表示;要有运行结果并考虑到顺序表中所有情况。

一、实验算法描述:1、顺序表的声明和创建typedef struct{int* data;//int*型元素int length;//顺序表的实际长度int listsize;//顺序表的最大长度}sqlist;void creatsqlist(sqlist &list){list.data=(int*)malloc(sizeof(int)*maxsize);//开辟一个名为l的顺序表if(!list.data)//判断顺序表是否存在exit(1);list.length=0;list.listsize=maxsize;}2、初始化函数initsqlist(list)void initsqlist(sqlist &list)//初始化操作{int* p;int n;cout<<"请输入顺序表元素数(1-50):"<<endl;//让用户输入顺序表元素个数cin>>n;cout<<"您申请的顺序表的长度是---"<<n<<endl;p=list.data;//p指向头指针cout<<"请依次输入无重复数字的有序顺序表(相邻数据用空格隔开,回车键完成输入):"<<endl;for(int i=0;i<n;i++)//逐个赋值{cin>>*p;p++;list.length++;}cout<<"您输入的递增顺序表为:"<<endl;//打印出初始化的顺序表for(i=0;i<n;i++)cout<<list.data[i]<<"\t";cout<<endl;}3、输出函数put(list)void put(sqlist &list) //输出函数{ int i;for(i=0;i<list.length;i++)cout<<list.data[i]<<"\t";cout<<endl;}4、定位函数locateElem(list)void locateElem(sqlist &list){int i,j=0,b;cout<<"请输如要查找的字符:\n";cin>>b;for(i=0;i<list.length;i++)if(list.data[i]==b){j=i+1;break;}if(j)cout<<"该数字的位置是:"<<j<<endl;elsecout<<"很抱歉,表中没有这个数字,请重试!"<<endl; }5、插入函数insert(list)void insert(sqlist &list)//插入函数{int i;cout<<"您想在第几位插入数字:\n";cin>>i;int x;cout<<"请输入要插入的数字:\n";cin>>x;int j;if(i<0||i>list.length){cout<<"位置错误"<<endl;put(list);}else{ for(j=list.length;j>=i;j--)list.data[j]=list.data[j-1];list.data[j]=x;list.length++;}cout<<"插入操作完成后的顺序表:"<<endl;put(list);}6、删除函数delete1(list)和delete2(list)void delete1(sqlist &list)//删除第i个位置的数字的函数{int i,b;cout<<"请输入你想要删除数据的位置:"<<endl;cin>>i;if(i<0||i>list.length){cout<<"输入错误!"<<endl;return;}else{b=list.data[i-1];for(i=i-1;i<list.length-1;i++)list.data[i]=list.data[i+1];--list.length;cout<<"需要删除的元素是:"<<b<<endl;cout<<"删除操作完成后的顺序表是:"<<endl;put(list);}}void delete2(sqlist &list)//删除指定数字的函数{int b;cout<<"输入您想删除的数字:"<<endl;cin>>b;int i,j=0;for(i=0;i<list.length;i++){if(list.data[i]==b){j=i+1;break;}}if(j!=0){for(;i<list.length-2 ;i++)list.data[i]=list.data[i+1];--list.length;cout<<"该位置是第"<<i<<"位"<<endl;cout<<"删除操作完成后的顺序表是:"<<endl;put(list);}elsecout<<"很遗憾,表中没有找到此数字,删除不成功,请重试!"<<endl;}二、实验程序描述:主函数如下:int main(){int flag;sqlist l;creatsqlist(l);initsqlist(l);cout<<endl<<"********************************************************* *****************"<<endl;cout<<"请输入要进行的操作序号:\n";cout<<"1.插入字符"<<endl<<"2.查找数字"<<endl<<"3.删除第i位数字"<<endl<<"4.删除指定数字"<<endl<<"0.退出"<<endl<<endl;cin>>flag;do{switch(flag){case 1:insert(l);break;case 2:locateElem(l);break;case 3:delete1(l);break;case 4:delete2(l);break;default:cout<<"请重新输入||代码错误"<<endl;}cout<<"*********************************************************** ***************"<<endl;cout<<"请输入要进行的操作序号:\n";cout<<"1.插入字符"<<endl<<"2.查找数字"<<endl<<"3.删除第i位数字"<<endl<<"4.删除指定数字"<<endl<<"0.退出"<<endl<<endl;cin>>flag;}while(flag!=0);return 0;}三、实验结果(输入和输出):1、输入界面:2、插入操作:3、查找操作:4、删除操作:最新文件仅供参考已改成word文本。

C语言实现顺序表的基本操作(从键盘输入生成线性表,读txt文件生成线性表和数组生成线性表-。。。

C语⾔实现顺序表的基本操作(从键盘输⼊⽣成线性表,读txt⽂件⽣成线性表和数组⽣成线性表-。

经过三天的时间终于把顺序表的操作实现搞定了。

(主要是在测试部分停留了太长时间)1. 线性表顺序存储的概念:指的是在内存中⽤⼀段地址连续的存储单元依次存储线性表中的元素。

2. 采⽤的实现⽅式:⼀段地址连续的存储单元可以⽤固定数组或者动态存储结构来实现,这⾥采⽤动态分配存储结构。

3. 顺序表结构体⽰意图三种写法完整代码:第⼀种写法. 从键盘输⼊⽣成线性表--完整代码如下,取值操作实际上就是删除操作的部分实现,这⾥就不写了#include<stdio.h>#include<stdlib.h>#include<malloc.h>#define LIST_INIT_SIZE 100#define LISTINCREMENT 10#define OK 1#define ERROR 0#define INFEASIBLE -1#define OVERFLOW -2#define TRUE 1#define FALSE 0typedef int Status;typedef int ElemType;typedef struct SqList{ElemType *elem;int length;int listsize;}SqList;Status InitList(SqList &L){L.elem = (ElemType *)malloc(LIST_INIT_SIZE * sizeof(ElemType));if (!L.elem){printf("ERROR\n");return ERROR;}L.length = 0;L.listsize = LIST_INIT_SIZE;return OK;}Status ListEmpty(SqList L) //判空{if (L.length = 0) return TRUE;else return FALSE;}Status ListInsert(SqList &L, int i, ElemType e) //插⼊{ElemType *p, *q;ElemType *newbase;int j;if (i < 1 || i > L.length + 1) return ERROR;if (L.length >= L.listsize){newbase = (ElemType *)realloc(L.elem, (L.listsize + LISTINCREMENT) * sizeof(ElemType));if (newbase == NULL){printf("realloc failed!\n");return ERROR;//exit(-1);}L.elem = newbase;L.listsize += LISTINCREMENT;}p = L.elem+i-1;for( q = L.elem + L.length - 1; q>= p; --q ){*(q+1) = *q;}*p = e;++L.length;return OK;}Status CrtList(SqList &L) // 从键盘输⼊数据⽣成线性表{printf("输⼊整数,以0结束:\n");ElemType e;int i = 1;scanf("%d", &e);while (e != 0){if (!ListInsert(L, i, e)) return ERROR;i++;scanf("%d", &e);}return OK;}Status CrtList2(SqList &L, ElemType d[], int n) // 从数组⽣成线性表{int i;for (i = 0; i < n; ++i){if (!ListInsert(L, i + 1, d[i])) return ERROR;}return OK;}Status ListDelet(SqList &L, int i, ElemType &e) //删除{if ((i<1) || (i>L.length)) return ERROR;ElemType *p, *q;p = &(L.elem[i - 1]);e = *p;q = L.elem + L.length - 1;for (++p; p <= q; ++p) *(p - 1) = *(p);--L.length;return OK;}Status GetElem(SqList &L, int i, ElemType &e) //取值{if ((i <= 0) || (i>L.length)) return ERROR;else{e = L.elem[i - 1];return OK;}}Status compare(ElemType a, ElemType b) //⽐较{if (a == b) return TRUE;else return FALSE;}int LocateElem(SqList L, ElemType e) //定位{Status compare(ElemType a, ElemType b);int i;for (i = 0; i<L.length; i++){if (compare(L.elem[i], e))return ++i;}if (i == L.length) return0;}Status PriorElem(SqList L, ElemType cur_e, ElemType &pre_e) //求直接前驱{int LocateElem(SqList L, ElemType e);int i = LocateElem(L, cur_e);if ((i == 0) || (i == 1)) return ERROR;pre_e = L.elem[i - 2];return OK;}int ListLength(SqList L) //求长度{int length = L.length;return length;}void MergeList(SqList La, SqList Lb, SqList &Lc) //归并{Lc.length = La.length + Lb.length;Lc.listsize = Lc.length;Lc.elem = (ElemType*)malloc(Lc.length*sizeof(ElemType));if (Lc.elem == NULL) exit(OVERFLOW);int i, j, k;for (i = 0, j = 0, k = 0; (i<La.length) && (j<Lb.length); k++){if (La.elem[i]<Lb.elem[j]){Lc.elem[k] = La.elem[i];i++;}else{Lc.elem[k] = La.elem[j];j++;}}while (i<La.length){Lc.elem[k] = La.elem[i];i++;k++;}while (j<Lb.length){Lc.elem[k] = Lb.elem[j];j++;k++;}}void vist(ElemType e){printf("%d ", e);}Status ListTraverse(SqList L) //遍历{int i;if (L.length == 0) printf("⽆元素");for (i = 0; i<L.length; i++){vist(L.elem[i]);}if (i == L.length){printf("\n");return OK;}else return ERROR;}Status ListClear(SqList L) //清空{if (L.elem == NULL) return ERROR;int i;for (i = 0; i<L.length; i++) L.elem[i] = 0;L.length = 0;return OK;}Status DestroyList(SqList &L) //销毁{if (L.elem == NULL) return ERROR;free(L.elem);L.length = 0;L.listsize = 0;return OK;}void PrnList(SqList L) //打印{int i;for (i = 0; i < L.length; ++i){printf("%5d", L.elem[i]);}printf("\n");}int main(){int j, l;ElemType e, e1;SqList La;if (InitList(La)) printf("OK\n");else exit(INFEASIBLE);CrtList(La);PrnList(La);int k;printf("1:判空\n2:插⼊\n3:删除\n4:定位\n5:求长度\n6:直接前驱\n");printf("7:归并\n8:遍历\n9:清空\n10:销毁\n\n0:退出\n");scanf("%d", &k);while (k != 0){switch (k){case1:if (ListEmpty(La)) printf("empty\n");else printf("non-empty\n");break;case2:printf("在第⼏个位置插⼊何数:");scanf("%d%d", &j, &e);if (ListInsert(La, j, e)) printf("OK\n");else printf("ERROR\n");break;case3:printf("删除第⼏个数:");scanf("%d", &j);if (ListDelet(La, j, e))PrnList(La);printf("删除数为:%d\n", e);break;case4:printf("定位数字:");scanf("%d", &e);if (LocateElem(La, e) != 0) printf("OK,位序为:%d\n", LocateElem(La, e));else printf("ERROR\n");break;case5:l = ListLength(La);printf("ListLength=%d\n", l);break;case6:printf("寻找何数直接前驱:");scanf("%d", &e);if (PriorElem(La, e, e1)) printf("前驱为:%d\n", e1);else printf("ERROR\n");break;case7:SqList Lb, Lc;if (InitList(Lb)) printf("OK\n");else printf("ERROR\n");CrtList(Lb);MergeList(La, Lb, Lc);printf("有序归并后:\n");PrnList(Lc);break;case8:if (ListTraverse(La)) printf("遍历成功\n");else printf("遍历失败\n");break;case9:if (ListClear(La)) printf("清空成功\n");else printf("清空失败\n");break;case10:if (DestroyList(La)) printf("销毁完成\n");else printf("销毁失败\n");return0;default:printf("ERROR\n");}scanf("%d", &k);}return0;}View Code第⼆种写法. 从txt⽂件读⼊⽣成线性表--完整代码如下:#include<stdio.h>#include<stdlib.h>#define OK 1#define ERROR 0#define OVERFLOW -1#define TRUE 1#define FALSE 0#define INIT_LIST_SIZE 100#define LISTINCREMENT 10typedef int Status;typedef int ElemType;typedef struct{ElemType *elem;int length;int listsize;}SqList;Status InitList(SqList *L){L->elem = (ElemType*)malloc(INIT_LIST_SIZE*sizeof(ElemType));if (!L->elem) exit(OVERFLOW);L->length = 0;L->listsize = INIT_LIST_SIZE;return OK;}Status ListEmpty(SqList L) //判空{if (L.length = 0) return TRUE;else return FALSE;}Status ListInsert(SqList *L, int i, ElemType e) //插⼊{ElemType *newbase, *q, *p;if (i<1 || i>L->length + 1) return ERROR;if (L->length>L->listsize){newbase = (ElemType*)realloc(L->elem, (L->listsize + LISTINCREMENT)*sizeof(ElemType));if (!newbase) exit(OVERFLOW);L->elem = newbase;L->listsize += LISTINCREMENT;}q = L->elem + i - 1; //q为插⼊位置for (p = L->elem + L->length - 1; p >= q; p--){*(p + 1) = *p;}*q = e;++L->length;return OK;}Status ListDelete(SqList *L, int i, ElemType * e) //删除{ElemType * p, *q;if (i<1 || i>L->length) return ERROR;p = L->elem + i - 1; //p为被删除元素位置*e = *p; //被删除元素的值赋值给eq = L->elem + L->length - 1; //表尾元素位置for (++p; p <= q; ++p){*(p - 1) = *p;}L->length--;return OK;}Status GetElem(SqList *L, int i, ElemType * e) //取值{if (i<1 || i>L->length) return ERROR;*e = *(L->elem + i - 1); //获取第i个元素的地址return OK;}int LocateElem(SqList L, ElemType e) //定位{int i;for (i = 0; i<L.length; i++){if (L.elem[i]==e)return ++i;}if (i == L.length) return0;}Status PriorElem(SqList L, ElemType e, ElemType &pre_e) //求直接前驱{int LocateElem(SqList L, ElemType e);int i = LocateElem(L, e);if ((i == 0) || (i == 1)) return ERROR;pre_e = L.elem[i - 2];return OK;}Status GetLength(SqList *L) //求长度{return L->length;}void PrnList(SqList *L) //遍历{int i;for (i = 0; i<(*L).length; i++){if (i == 0)printf("(");printf(" %d ", L->elem[i]);if (i == (*L).length - 1)printf(")\n");}}Status ClearList(SqList *L) //清空{L->length = 0;return OK;}Status Destroy(SqList *L) //销毁{free(L->elem);L->elem = NULL;L->length = 0;L->listsize = 0;return OK;}int main(){int n = 0, rc;int a, i;int e, e1;SqList L;if (InitList(&L)) printf("OK\n");FILE *fp = fopen("D:/1.txt", "r");if (fp == NULL){printf("打开⽂件失败");}printf("从1.txt⽂件读⼊⼏个数:");scanf("%d", &n);for (i = 0; i< n; i++){fscanf(fp, "%d", &a);ListInsert(&L, i+1, a);}fclose(fp);PrnList(&L);char k;printf("\n1.插⼊\n2.删除\n3.取值\n4.定位\n5.直接前驱\n6.求长度\n7.遍历\n8.清空\n9.销毁\n"); while (1){k = getchar();switch (k){case'1':printf("在第⼏个位置插⼊何数:");scanf("%d%d", &i, &e);if (ListInsert(&L, i, e))printf("i=%d,e=%d 已经插⼊\n", i, e);else printf("插⼊失败\n");break;case'2':printf("删除第⼏个数:\n");scanf("%d", &i);if (ListDelete(&L, i, &e))printf("i=%d,e=%d 已经删除\n", i, e);else printf("删除失败\n");break;case'3':printf("取第⼏个数:\n");scanf("%d", &i);if (GetElem(&L, i, &e))printf("第i=%d号,e=%d 被取出!\n", i, e);else printf("取值失败\n");break;case'4':printf("定位数字:");scanf("%d", &e);if (LocateElem(L, e) != 0) printf("OK,位序为:%d\n", LocateElem(L, e));else printf("ERROR\n");break;case'5':printf("寻找何数直接前驱:");scanf("%d", &e);if (PriorElem(L, e, e1)) printf("前驱为:%d\n", e1);else printf("ERROR\n");break;case'6':printf("表长为%d\n", GetLength(&L));break;case'7':printf("遍历:\n");PrnList(&L);break;case'8':if (ClearList(&L)) printf("清空成功\n");else printf("清空失败\n");break;case'9':printf("销毁\n");Destroy(&L);printf("销毁成功\n");exit(0);return0;}}return0;}View Code第三种写法:读数组⽣成线性表--完整代码如下:#include<stdlib.h>#define OK 1#define ERROR 0#define OVERFLOW -1#define TRUE 1#define FALSE 0#define INIT_LIST_SIZE 100#define LISTINCREMENT 10typedef int Status;typedef int ElemType;typedef struct{ElemType *elem;int length;int listsize;}Sqlist;Status InitList(Sqlist *L){L->elem = (ElemType *)malloc(INIT_LIST_SIZE *sizeof(ElemType));if (!L->elem)exit(OVERFLOW);L->length = 0;L->listsize = INIT_LIST_SIZE;return OK;}Status ListEmpty(Sqlist L){if (L.length = 0)return ERROR;else return FALSE;}Status ListInsert(Sqlist *L, int i, ElemType e){ElemType *newbase, *p, *q;if (i<1 || i>L->length + 1)return ERROR;if (L->length > L->listsize){newbase = (ElemType *)realloc(L, (L->listsize + LISTINCREMENT)*sizeof(ElemType));if (!newbase)exit(OVERFLOW);L->elem = newbase;L->listsize += LISTINCREMENT;}p = L->elem + i - 1;for (q = L->elem + L->length - 1; q >= p; q--){*(q + 1) = *q;}*p = e;L->length++;return OK;}Status CreateList(Sqlist *L, ElemType element[], int n) // 从数组⽣成线性表{int i;for (i = 0; i < n; ++i){if (!ListInsert(L, i + 1, element[i])) return ERROR;}return OK;}Status ListDelete(Sqlist *L, int i, ElemType *e){ElemType *p, *q;if (i<1 || i>L->length)return ERROR;p = L->elem + i - 1;q = L->elem + L->length - 1;*e = *p;for (p++; q >= p; p++){*(p - 1) = *p;}L->length--;return OK;}Status GetElem(Sqlist *L, int i, ElemType *e){if (i<1 || i>L->length)return ERROR;return OK;}int LocateElem(Sqlist L, ElemType e){int i;for (i = 0; i < L.length; i++)if (L.elem[i] == e)return i + 1;}Status PriorElem(Sqlist L, ElemType e, ElemType &pr_e){int LocateElem(Sqlist L, ElemType e);int i = LocateElem(L, e);if (i<1 || i>L.length)return ERROR;pr_e = L.elem[i - 2];return OK;}Status GetLength(Sqlist *L){return L->length;}void PrnList(Sqlist *L){int i;for (i = 0; i < L->length; i++)printf("%d ", L->elem[i]);printf("\n");}Status ClearList(Sqlist *L){L->length = 0;return OK;}Status Destroy(Sqlist *L){free(L->elem);L->elem = NULL;L->length = 0;L->listsize = 0;return OK;}int main(){int i;int a, n = 0;int e, e1;Sqlist L;ElemType element[] = { 15, 3, 59, 27, 8, 11, 32 };if (InitList(&L))printf("OK\n");CreateList(&L, element, 7);PrnList(&L);char k;printf("\n1.插⼊\n2.删除\n3.取值\n4.定位\n5.直接前驱\n6.求长度\n7.遍历\n8.清空\n9.销毁\n"); while (1){k = getchar();switch (k){case'1':printf("在第⼏个位置插⼊何数:");scanf("%d%d", &i, &e);if (ListInsert(&L, i, e))printf("i=%d e=%d已经插⼊\n", i, e);break;case'2':printf("删除第⼏个数:");scanf("%d", &i);if (ListDelete(&L, i, &e))printf("i=%d e=%d已经删除\n", i, e);break;case'3':printf("取第⼏个数:");scanf("%d", &i);if (GetElem(&L, i, &e))printf("第i=%d e=%d已经取出\n", i, e);break;case'4':printf("定位何数:");scanf("%d", &e);if (LocateElem(L, e))printf("位序为:%d\n", LocateElem(L, e));break;case'5':printf("寻找何数的直接前驱:");scanf("%d", &e);if (PriorElem(L, e, e1))printf("前驱为:%d\n", e1);break;case'6':printf("表长为:%d\n", GetLength(&L));break;case'7':printf("遍历:\n");PrnList(&L);break;case'8':if (ClearList(&L))printf("清空成功!\n");break;case'9':if (Destroy(&L))printf("销毁成功!\n");exit(0);return0;}}return0;}View Code看懂了左⼿给你个栗⼦,给我关注点赞;看不懂右⼿给你个锤⼦,砸开脑壳看看有没有带脑⼦。

顺序表实验

《数据结构》实验报告题目:_顺序表的实现学号:______姓名:___张磊_______ 东南大学成贤学院计算机系实验题目一、实验目的1.掌握顺序表的基本操作,实现顺序表的插入、删除、查找等基本运算。

二、实验内容1.完善顺序表的定义,并运用其实现线性表的操作。

2.(课上任务)选题一:集合的交、并、差运算【问题描述】编制一个能演示执行集合的交、并和差运算的程序。

【任务要求】1)集合元素用小写英文字母,执行各种操作应以对话方式执行。

2)算法要点:利用顺序表表示集合;理解好三种运算的含义【测试数据】自行设定,注意边界等特殊情况。

选题二:文章编辑功能:输入一页文字,程序可以统计出文字、数字、空格的个数。

静态存储一页文章,每行最多不超过80个字符,共N行;要求①分别统计出其中英文字母数和空格数及整篇文章总字数;②统计某一字符串在文章中出现的次数,并输出该次数;③删除某一子串,并将后面的字符前移。

存储结构使用顺序表,分别用几个子函数实现相应的功能;输入数据的形式和范围:可以输入大写、小写的英文字母、任何数字及标点符号。

输出形式:①分行输出用户输入的各行字符;②分4行输出"全部字母数"、"数字个数"、"空格个数"、"文章总字数";③输出删除某一字符串后的文章;选题三:构造有序顺序表要求:进一步完善SqList类模板,实现顺序表的按值插入元素,即顺序表为递增有序表,插入元素后仍递增有序。

方法:在sq_list.h中添加代码,在SqList类模板的定义中添加函数声明,在类模板实现部分实现该函数。

bool CreateListOrder();bool InsertOrder(ElemType e);三、实验步骤1.启动VC6.0:开始菜单→程序→Microsoft Visual Studio 6.0 →Microsoft Visual C++ 6.02.建立工程:文件(File)→新建(new)→在弹出的对话框中选择工程标签(Project)→选中选项:Win32 Console Application(不能选别的)→输入工程名(Project Name)→选择工程的存放位置(Location)→单击“确定”按钮(OK)→在弹出的对话框中选中选项:An Empty Project→单击“完成”按钮(Finish)→在弹出的对话框中单击“确定”按钮( OK )。

初始化顺序表代码

初始化顺序表代码顺序表的初始化是指在内存中为顺序表分配一定大小的存储空间,并将其初始状态设置为一个空表。

在C语言中,我们可以使用静态数组或动态数组来实现顺序表。

下面分别介绍这两种方法的初始化代码。

1. 使用静态数组初始化顺序表静态数组是在编译时就确定了大小的数组,它的大小是固定的。

我们可以通过定义一个具有固定大小的数组来实现顺序表的初始化。

```c#define MAX_SIZE 100 // 定义顺序表的最大容量typedef struct {int data[MAX_SIZE]; // 用数组存储顺序表的元素int length; // 顺序表的当前长度} SeqList;```上面的代码定义了一个SeqList结构体,其中data数组用来存储顺序表的元素,length表示顺序表的当前长度。

接下来我们可以编写初始化函数来初始化顺序表。

```cvoid init(SeqList *list) {list->length = 0; // 将顺序表的长度初始化为0}```在初始化函数中,我们将顺序表的长度初始化为0,表示顺序表为空表。

通过这种方式,我们就完成了静态数组的顺序表的初始化。

2. 使用动态数组初始化顺序表动态数组是在程序运行时根据需要动态分配内存空间的数组。

我们可以使用malloc函数来动态分配一块连续的内存空间,然后将其作为顺序表的存储空间。

```ctypedef struct {int *data; // 用指针存储顺序表的元素int length; // 顺序表的当前长度int maxSize; // 顺序表的最大容量} SeqList;```上面的代码定义了一个SeqList结构体,其中data指针用来存储顺序表的元素,length表示顺序表的当前长度,maxSize表示顺序表的最大容量。

接下来我们可以编写初始化函数来初始化顺序表。

```cvoid init(SeqList *list, int maxSize) {list->data = (int *)malloc(maxSize * sizeof(int)); // 动态分配存储空间list->length = 0; // 将顺序表的长度初始化为0list->maxSize = maxSize; // 设置顺序表的最大容量}```在初始化函数中,我们首先使用malloc函数动态分配了一块大小为maxSize的内存空间,然后将顺序表的长度初始化为0,最后设置顺序表的最大容量。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
cout<<"\nCreate list success!\n"; }
template <class dataType> void seqList<dataType>::empty(){
currentLength=0;
cout<<"\nEmpty list success!\n"; }
template <class dataType> int seqList<dataType>::getLength(){
empty(); delete []data; }
注意
1、这段代码是从线性表工程包里抽出来的,有必要可以去这里下载,工程包的内容如下:
list.h
-> 线性表抽象类的定义
seqList.h -> 顺序表类的定义
seqList.txt -> 顺序表类的实现
linkList.h -> 单链表类的定义
linkList.txt -> 单链表类的实现
} for(int i=0;i<currentLength-1;++i){
cout<<data[i]<<" "; } cout<<data[currentLength-1]<<endl; }
template <class dataType> seqList<dataType>::~seqList(){
return currentLength; }
template <class dataType> void seqList<dataType>::resize(){
dataType* tmp=data; maxLength*=2; //将表的容量扩大一倍 data=new dataType[maxLength]; for(int i=0;i<currentLength;++i){ //拷贝元素到新表
#include <iostream>
using namespace std;
template <class dataType> seqList<dataType>::seqList(int initSize){
maxLength=initSize; data=new dataType[maxLength]; currentLength=0;
//下标越界时抛出异常值 0 if(i<0||i>=currentLength){
throw 0; }
return data[i];
}
template <class dataType> void seqList<dataType>::traverse(){
if(currentLength==0){ cout<<"\nThe list is empty!\n"; return;
public: seqList(int initSize=10); //构造函数,默认设置表的初始容量为 10 void empty(); //清除函数 int getLength(); //求表的长度 void insert(int i,const dataType& x); //在表中第 i 个位置插入值为 x 的元素 void remove(int i); //删除表中第 i 个位置的元素 int search(const dataType& x); //查找并返回值为 x 的元素在表中的位置 dataType visit(int i); //访问表中第 i 个元素的值 void traverse(); //遍历线性表 ~seqList();
dLinkList.h -> 双链表类的定义
dLinkList.txt -> 双链表类的实现
test.h
-> 测试类的定义
test.txt
-> 测试类的实现
2、大家可以把这些代码作为参考,想要提高能力还是要自己写的;
3、所有的类都是模版类,如果想把模版类的定义与实现分离要注意,模版类的实现不能放
在.cpp 文件里,只能放在.txt 文件里;
}
if(currentLength==maxLength) resize(); //如果当前表满则扩容 for(int j=currentLength;j>i;--j){ //把 i 后面的元素后移一位
data[j]=data[j-1]; } data[i]=x; ++currentLength;
6. 涉及的知识主要分为三大方面: (1)顺序表的实现原理; (2)类的设计、封装; (3)设计抽象类 list 并让顺序表继承自 list,是为了和单链表、双链表配合,利用(纯)虚 函数实现多态。如果只用到顺序表您可以自己设计一个类解决,也可以直接用上面的代码。
C++模版类实现顺序表
先上代码
/********************************线性表抽象类的定义***************************/
template <class dataType> class list{
public: virtual void empty()=0; //清空线性表 virtual int getLength()=0; //求表的长度 virtual void insert(int i,const dataType& x)=0; //在表中第 i 个位置插入值为 x 的元素 virtual void remove(int i)=0; //删除表中第 i 个位置的元素 virtual int search(const dataType& x)=0; //查找并返回值为 x 的元素在表中的位置 virtual dataType visit(int i)=0; //访问表中第 i 个元素的值 virtual void traverse()=0; //遍历线性表
int i; for(i=0;i<currentLength;++i){
if(data[i]==x) break; } if(i==currentLength) return -1; return i; }
Байду номын сангаас
template <class dataType> dataType seqList<dataType>::visit(int i){
private: dataType* data; //表中第一个元素的地址 int maxLength; //表的最大容量 int currentLength; //表中元素的个数 void resize(); //将表的最大容量扩大一倍
};
/*********************************顺序表类的实现******************************/
};
/*******************************顺序表类的定义********************************/
#include “list.h”
template <class dataType> class seqList:public list<dataType>{ //公有继承自 list 类
}
for(int j=i;j<currentLength-2;++j){ data[j]=data[j+1];
} --currentLength;
//将 i 后面的元素前移一位
cout<<"\nDelete data sucess!\n"; }
template <class dataType> int seqList<dataType>::search(const dataType& x){
cout<<"\nInsert data success!\n"; }
template <class dataType> void seqList<dataType>::remove(int i){
if(i<0||i>=currentLength){ cout<<"\nThe index is out of range!\n"; return;
data[i]=tmp[i]; } delete tmp; }
template <class dataType> void seqList<dataType>::insert(int i,const dataType& x){
if(i<0||i>currentLength){ cout<<"\nThe index is out of range!\n"; return;
相关文档
最新文档