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语⾔实现顺序表的具体代码,供⼤家参考,具体内容如下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
创建顺序表:创建顺序表需要先确定表的大小,即容量。
可以通过动态分配内存来创建顺序表,或者直接在程序中定义一个静态数组作为顺序表的存储空间。
创建时需要初始化表中元素的数量为0。
插入元素:在顺序表中插入元素时,需要先判断表是否已满。
如果表已满,则需要扩容。
扩容可以通过动态分配更大的内存空间,并将原有元素拷贝到新的内存空间中来实现。
如果表未满,则可以直接在表的末尾插入元素。
如果要在指定位置插入元素,则需要先将该位置及其后面的元素依次后移一个位置,再在该位置插入新元素。
删除元素:在顺序表中删除元素时,需要先判断要删除的元素是否存在。
如果不存在,则无需进行任何操作。
如果存在,则可以直接删除该元素。
如果要删除指定位置的元素,则需要先将该位置后面的元素依次前移一个位置,再将表中元素的数量减1。
查找元素:在顺序表中查找元素时,可以使用顺序查找或二分查找算法。
顺序查找的时间复杂度为O(n),而二分查找的时间复杂度为O(log n)。
在使用二分查找时,需要保证顺序表中的元素已经按照升序或降序排列。
修改元素:在顺序表中修改元素时,需要先查找该元素的位置,然后将其修改为新值。
输出顺序表:输出顺序表时,需要遍历表中所有元素,并将它们依次输出。
可以使用循环来实现遍历。
总之,实现顺序表的基本运算需要涉及到动态内存分配、数组操作、循环遍历和查找算法等知识点。
在实际应用中,还需要考虑如何优化算法效率、如何处理异常情况等问题。
用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算法实现模板
模板二:多文件结构模板 大型程序一般都采用多文件结构,以下是多文件结构的顺序表合并的例子。 模板的基本结构如下:
⑴ 包含必要的标准头文件,如标准的输入输出头文件 "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语言实现顺序表的增删查改逆置简单代码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,最后设置顺序表的最大容量。
C语言中实现模板函数
C语言中实现模板函数在C语言中,没有内置的模板函数的概念,但是可以使用宏定义来实现类似于模板函数的功能。
宏定义能够根据传入的参数自动生成相关的代码,以实现代码的复用和泛化。
下面将详细介绍如何使用宏定义来实现模板函数。
C语言中的宏定义使用`#define`关键字,可以用于定义常量、函数和代码块。
在这里,我们将使用宏定义来实现一个模板函数,以便根据参数类型自动生成相应的代码。
下面是实现一个模板函数的步骤:1. 定义宏函数:我们可以使用宏定义来创建一个通用的函数,其中参数类型用宏参数来表示。
例如,我们可以定义一个通用的`max`函数来返回两个参数中的较大值:```c#define MAX(a, b) (a > b ? a : b)```在这个例子中,`MAX`是宏函数的名称,`a`和`b`是函数的参数,`(a>b?a:b)`是返回值。
调用`MAX`函数时,编译器会自动将函数调用替换为相应的代码。
2.使用宏函数:我们可以在代码中使用`MAX`宏函数来代替原始的函数调用。
例如,我们可以调用`MAX`函数来比较两个整数的最大值:```cint a = 10;int b = 20;int max_value = MAX(a, b);```在这个例子中,`max_value`将被赋值为`20`,因为`b`的值大于`a`的值。
3.使用宏函数的限制:使用宏函数的一个重要限制是,它只能用于生成表达式,而不能用于定义局部变量或执行复杂的逻辑操作。
因此,使用宏函数时应该注意避免出现副作用或不符合预期的行为。
4.对于更复杂的模板函数:如果想要实现更复杂的模板函数,可以使用更高级的技术,如泛型编程。
泛型编程可以通过使用无类型指针和类型转换来实现对任意类型的支持。
然而,泛型编程在C语言中需要更复杂的技术和代码,超过了本文介绍的范围。
总结来说,虽然C语言中没有内置的模板函数的概念,但可以使用宏定义来实现类似的功能。
宏定义可以根据传入的参数类型来生成相应的代码,实现代码的复用和泛化。
数据结构实验报告(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++]; }
简单实用的c++快速排序模板类
(一)目标在实际问题的解决过程中,我们发现,很多问题都可以归结为对数据的排序和查询。
而查询的效率则在很大程度上依赖于排序的效率;尤其是在数据量达到海量级的时候。
因此,设计一个有效的排序算法是至关重要的。
本文设计了一个通用的c++ quicksort 模板类。
通过简单的提供一个data类,可以实现任意数据的快速排序算法,提高了开发效率。
(二)快速排序算法的思想最基本的快速排序的思想是基于分治策略的:对于输入的子序列l[p..r],如果规模足够小则直接进行排序,否则分三步处理:1 分解(divide):将输入的序列l[p..r]划分成两个非空子序列l[p..q]和l[q+1..r],使l[p..q]中任一元素的值不大于l[q+1..r]中任一元素的值。
2 递归求解(conquer):通过递归调用快速排序算法分别对l[p..q]和l[q+1..r]进行排序。
3 合并(merge):由于对分解出的两个子序列的排序是就地进行的,所以在l[p..q]和l[q+1..r]都排好序后不需要执行任何计算l[p..r]就已排好序。
(三)准备工作和源代码1 使用vc6建立console工程2 加入下面的模板类(快速排序的模板类。
):template<typename datatype>//datatype是模板参数,代表了欲排序的数据类型class quicksorttemp{public:quicksorttemp(){}~quicksorttemp(){}public:// 快速排序的实现,array是要排序数据的数组,nlower,nupper范围是0 ~ 数据总个数-1static void quicksort(datatype* array, int nlower, int nupper){// 测试是否排序完毕if (nlower < nupper){// 分解和分别进行排序int nsplit = partition (array, nlower, nupper);//数据切分为两个部分quicksort (array, nlower, nsplit - 1);//左半部分递归排序quicksort (array, nsplit + 1, nupper);//右半部分递归排序}}// 切分数据为左右两个部分,返回中间元素x的编号// 主要的过程就是:选择一个元素x作为分界点,将比x大的元素放到x右边,其余放到x左边。
c语言万能编程模板C语言程序设计50例经典收藏
c语言万能编程模板C语言程序设计50例经典收藏C语言万能编程模板:C语言程序设计50例经典收藏一、简介C语言是一种高效、通用的编程语言,被广泛应用于各种计算机平台上。
为了更好地学习和应用C语言,程序设计的模板是非常重要的。
本文将提供一套万能的C语言编程模板,并收藏了50个经典的C语言程序设计实例。
二、基本结构任何一个C语言程序都包含一些基本的结构,以下是一个基本的C语言程序框架:```c#include <stdio.h>int main() {// 在此处编写程序代码return 0;}```三、模板示例下面是一个使用C语言编写的经典示例,展示了如何使用模板来编程:```c#include <stdio.h>int main() {int num1, num2, sum;printf("请输入两个数字:");scanf("%d %d", &num1, &num2);sum = num1 + num2;printf("两个数字的和为:%d\n", sum);return 0;}```四、程序设计实例1. 逆序输出数字```c#include <stdio.h>int main() {int num, reverse = 0;printf("请输入一个数字:");scanf("%d", &num);while(num != 0) {int remainder = num % 10;reverse = reverse * 10 + remainder;num /= 10;}printf("逆序输出的数字为:%d\n", reverse); return 0;}```2. 判断素数```c#include <stdio.h>int isPrime(int num) {if(num < 2) {return 0;}for(int i = 2; i * i <= num; i++) {if(num % i == 0) {return 0;}}return 1;}int main() {int num;printf("请输入一个数字:");scanf("%d", &num);if(isPrime(num)) {printf("%d是素数\n", num); } else {printf("%d不是素数\n", num); }return 0;}```3. 字符串反转#include <stdio.h>#include <string.h>void reverseString(char str[]) {int length = strlen(str);char temp;for(int i = 0; i < length/2; i++) {temp = str[i];str[i] = str[length - i - 1];str[length - i - 1] = temp;}}int main() {char str[100];printf("请输入一个字符串:");scanf("%s", str);reverseString(str);printf("反转后的字符串为:%s\n", str); return 0;```五、总结本文提供了一套万能的C语言编程模板,并收藏了50个经典的C 语言程序设计实例,涵盖了C语言的各个方面,希望能对C语言学习者和应用者有所帮助。
在c语言中实现模板函数的方法
Long sum = SumInt(array, 100);
…..
4.总结:
第一种方法,易于跟踪调试,但是效率低下,适用于对可变函数(函数指针)的效率要求不高,但程序出错的可能性较大(复杂),模板函数(Sum)本身很复杂,模板参数也比较复杂(add)的场合。
第二种方法,效率高,但很难跟踪调试,在模板函数和模板参数本身都很复杂的时候更是如此。
#undef Add
#define AddInt(x, y) ((x) += (y))
#define RetType long
#define FunName SumInt
#define ElemType int
#define Add AddInt
#include ];
{
*(long*)r1 += *(int*)r2;
}
AddClass addClass = {AddInt, 2, 0 };
Int array[100];
Read(array);
Sum(&addClass, array, 100);
…..
2.用宏作为Functor的替换者
#define GenSumFun(SumFunName, Add, RetType, ElemType) \
RetType SumFunName (const ElemType *array, int n) \
{ \
RetType sum = 0; \
for (int i = 0 ; i < n ; ++i) \
Add(sum, i); \
return sum; \
}
使用时:
c语言顺序表实现完整版
#include <stdio.h>#include<stdlib.h>#include<malloc.h>#define LIST_INIT_SIZE 100#define LISTINCREMENT 10typedef int Elemtype;typedef int Status;typedef struct{Elemtype *elem;int length;int listsize;}SqList; //定义顺序表类型Status InitList_Sq(SqList &L) //初始化顺序表{L.elem=(Elemtype *)malloc(LIST_INIT_SIZE* sizeof(Elemtype)); L.length=0;L.listsize=LIST_INIT_SIZE;return 1;}void CreateList(SqList &L) //创建顺序表{int i;printf("请输入你要创建的顺序表元素个数");scanf("%d",&L.length);printf("请输入你要创建的顺序表:\n");for(i=0;i<L.length;i++)scanf("%d",&L.elem[i]);}void print( SqList &L)//输出顺序表{int i;for(i=0;i<L.length;i++)printf("%3d",L.elem[i]);}Status location( SqList L,Elemtype e)//查找元素的位置{int i=0;while(L.elem[i]!=e && i<L.length)i++;if(i>L.length)return -1;elsereturn i+1;//因为c语言是从下标0开始的当i=0时实际上是顺序表的第i+1个元素}Status ListInsert_Sq(SqList &L,int i,Elemtype e)//在顺序表的第i个位置插入值为e的元素{Elemtype *newbase,*q,*p;if(i<1||i>L.length+1)return 0;if(L.length>=L.listsize){newbase=(Elemtype *)realloc(L.elem,(L.listsize+LISTINCREMENT)* sizeof(Elemtype));L.elem=newbase;L.listsize+=LISTINCREMENT;}q=&(L.elem[i-1]);for(p=&(L.elem[L.length-1]);p>=q;--p)*(p+1)=*p;*q=e;++L.length;return 1;}Status ListDelect_Sq(SqList &L,int i,Elemtype e)//在顺序表的第i个位置删除值为e的元素并返回e的值{Elemtype *q,*p;if(i<1||(i>L.length))return 0;p=&(L.elem[i-1]);e=*p;q=L.elem+L.length-1;for(++p;p<=q;++p)*(p-1)=*p;--L.length;return 1;}void Combine(SqList La,SqList Lb,SqList &Lc)//将两个非递减的顺序表合并成一个顺序表,合并后元素也按值非递减排列{Elemtype *pa_last,*pb_last,*pa,*pb,*pc;pa=La.elem;pb=Lb.elem;Lc.listsize=Lc.length=La.length+Lb.length;pc= Lc.elem=(Elemtype *)malloc(Lc.listsize* sizeof(Elemtype)); pa_last=La.elem+La.length-1;pb_last=Lb.elem+Lb.length-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++;}void main(){SqList la,lb,lc,ld;int i,j;Elemtype e;InitList_Sq(la);CreateList(la);print(la);printf("请输入要查找的元素:\n");scanf("%d",&e);j=location(la,e);printf("该元素的位置为%d\n",j);printf("请输入要插入的位置和元素:\n");scanf("%d%d",&i,&e);ListInsert_Sq(la,i,e);printf("输出插入后的顺序表:\n"); print(la);printf("请输入要删除的位置:\n"); scanf("%d",&i);ListDelect_Sq(la,i,e);printf("删除的那个元素是:%d\n",e); printf("输出删除后的顺序表:\n"); print(la);InitList_Sq(lb);CreateList(lb);print(lb);InitList_Sq(lc);CreateList(lc);print(lc);InitList_Sq(ld);Combine(lb,lc,ld);printf("合并后的顺序表为:\n"); print(ld);}。
数据结构c++顺序表、单链表的基本操作,查找、排序代码
} return 0; }
实验三 查找
实验名称: 实验3 查找 实验目的:掌握顺序表和有序表的查找方法及算法实现;掌握二叉排序 树和哈希表的构造和查找方法。通过上机操作,理解如何科学地组织信 息存储,并选择高效的查找算法。 实验内容:(2选1)内容1: 基本查找算法;内容2: 哈希表设计。 实验要求:1)在C++系统中编程实现;2)选择合适的数据结构实现查 找算法;3)写出算法设计的基本原理或画出流程图;4)算法实现代码 简洁明了;关键语句要有注释;5)给出调试和测试结果;6)完成实验 报告。 实验步骤: (1)算法设计 a.构造哈希函数的方法很多,常用的有(1)直接定址法(2)数字分析法;(3) 平方取中法;(4)折叠法;( 5)除留余数法;(6)随机数法;本实验采用的是除 留余数法:取关键字被某个不大于哈希表表长m的数p除后所得余数为哈 希地址 (2)算法实现 hash hashlist[n]; void listname(){ char *f; int s0,r,i; NameList[0].py="baojie"; NameList[1].py="chengቤተ መጻሕፍቲ ባይዱoyang"; ……………………………… NameList[29].py="wurenke"; for(i=0;i<q;i++){s0=0;f=NameList[i].py; for(r=0;*(f+r)!='\0';r++) s0+=*(f+r);NameList[i].k=s0; }} void creathash(){int i;
v[k-1]=v[k]; nn=nn-1; return ; } int main() {sq_LList<double>s1(100); cout<<"第一次输出顺序表对象s1:"<<endl; s1.prt_sq_LList(); s1.ins_sq_LList(0,1.5); s1.ins_sq_LList(1,2.5); s1.ins_sq_LList(4,3.5); cout<<"第二次输出顺序表对象s1:"<<endl; s1.prt_sq_LList(); s1.del_sq_LList(0); s1.del_sq_LList(2); cout<<"第三次输出顺序表对象s1:"<<endl; s1.prt_sq_LList(); return 0; } 运行及结果:
写一算法输出已知顺序表a中元素最大值和次最大值,并编写c语言程序
写一算法输出已知顺序表a中元素最大值和次最大值,并编写c语言程序下面是一个C语言程序,实现查找已知顺序表a中元素最大值和次最大值的算法:c#include<stdio.h>#define MAX_SIZE 100 // 定义顺序表的最大长度int main() {int a[MAX_SIZE], n, max, second_max;printf("请输入顺序表长度:");scanf("%d", &n);printf("请输入%d个元素:\n", n);for (int i = 0; i < n; i++) {scanf("%d", &a[i]);}max = a[0]; // 假设第一个元素为最大值second_max = a[0]; // 假设第一个元素为次最大值for (int i = 1; i < n; i++) {if (a[i] > max) {second_max = max;max = a[i];} else if (a[i] > second_max && a[i] < max) {second_max = a[i];}}printf("最大值为:%d\n", max);printf("次最大值为:%d\n", second_max);return0;}该程序首先定义了一个长度为MAX_SIZE的整型数组a,用于存储输入的顺序表元素。
然后,程序提示用户输入顺序表的长度n和n个元素,将它们存储在数组a中。
接下来,程序使用一个循环遍历数组a,查找最大值和次最大值。
在循环中,程序首先假设第一个元素为最大值和次最大值,然后遍历数组中的其他元素,更新最大值和次最大值。
如果当前元素比最大值还大,则将最大值和次最大值都更新为当前元素;如果当前元素比次最大值大且比最大值小,则将次最大值更新为当前元素。
C++模板学习:函数模板、结构体模板、类模板
C++模板学习:函数模板、结构体模板、类模板C++模板:函数、结构体、类模板实现1.前⾔:(知道有模板这回事的童鞋请忽视) 普通函数、函数重载、模板函数认识。
//学过c的童鞋们⼀定都写过函数sum吧,当时是这样写的:int sum(int a,int b){return a+b;}//实现了整数的相加//如果再想同时实现⼩数的相加,就再多写个⼩数的相加。
普通实现我就不写了,知道函数重载的童鞋们会这样写:int sum(int a,int b){//第⼀个functionreturn a+b;}double sum(double a,double b){//第⼆个functionreturn a+b;}//这样我们就可以只⽤⼀个sum函数就可以实现整数相加与⼩数相加。
//但是这样我们还是要定义两个函数。
//C++考虑了怎么避免这种重复的操作,代码如下:函数模板的声明。
template <typename T>T sum(T a,T b){return a+b;}//只需要定义⼀个函数与只使⽤⼀个函数实现两数相加。
2.函数、结构体、类模板的定义样例://函数模板---使⽤体现:调⽤函数时传递的参数类型。
template<class 数据类型参数标识符><返回类型><函数名>(参数表){函数体}//结构体模板---使⽤体现:声明结构元素时 StackNode<类型> s;template<class T>struct StackNode{ struct T data; struct StackNode<T> *next;};//类模板---使⽤体现:声明类对象时 Stack<类型> s;template<class T>class Stack{ public: T pop(); bool push(T e); private: StackNode<T> *p;}template<class T>//类模板外的成员函数实现T Stack<T>::pop(){...} 其中,template是定义模板函数的关键字;template后⾯的尖括号不能省略;class(或typename)是声明数据类型参数标识符的关键字,⽤以说明它后⾯的标识符是数据类型标识符。
C语言顺序表基本函数
if(L->data[i]==x)
return i;
i++;
}
printf("顺序表中不存在此数据!\n");
return -2;
if(!(*L).elem) return OVERFLOW;
(*L).length=LIST_SEQLIST_INIT_SIZE;
(*L).last=0;
return OK;
}
int Initlist_Seqlist_2(Seqlist *L)
/*初始化链表:1.先决条件:初始化结构体数据;2.函数作用:删除已有链表,
break;
case 2:printf("请输入数据:");
scanf("%d",&e);
status=Increase_Seqlist(&L,e);
if(status==OK)
printf("成功增加数据!\n");
else if(status==OVERFLOW)
printf("申请空间失败,所有数据丢失!\n");
scanf("%d%d",&i,&k);
getchar();
if(i<1||i>(*L).last)
{
printf("删除起点越界!\n");
return ERROR;
}
if(k<0)
{
printf("删除个数有误!\n");
return ERROR;
}
if(i+k-1>(*L).last)
{
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
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;