C语言实现顺序表的基本操作
c语言实现顺序表的基本操作
c语⾔实现顺序表的基本操作数据结构顺序表操作复制代码代码如下:#include <stdio.h>#include <stdlib.h>#include <malloc.h>#define LIST_INIT_SIZE 100#define LISINCREMENT 10#define ElemType int#define Status inttypedef struct Sq{ElemType *elem;int length;int listsize;}SqList;Status InitList(SqList *L){L->elem=(ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemType));if(!L->elem)return 0;L->length=0;L->listsize=LIST_INIT_SIZE;return 1;}Status ListInsert(SqList *L,int i,ElemType e){int *q,*p;if(i<1||i>L->length)return 0;if(L->length>L->listsize){ElemType *newbase=(ElemType*)realloc(L->elem,(LIST_INIT_SIZE+LISINCREMENT)*sizeof(ElemType)); if(!newbase)return 0;L->elem=newbase;L->listsize+=(LISINCREMENT);}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 ListDelete(SqList *L,int i,ElemType e){int *p,*q;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;}int main(void){int i,j,e,lo,temp;SqList *L=(SqList*)malloc(sizeof(SqList)); InitList(L);printf("请输顺序表的长度:\n");scanf("%d",&L->length);printf("请输⼊顺序表的各个元素:\n");for(i=0;i<L->length;++i)scanf("%d",&L->elem[i]);printf("输⼊的顺序表是:\n");for (i=0;i<L->length;++i){printf("%d ",L->elem[i]);}printf("\n");printf("请输⼊插⼊的位置以及节点:\n"); scanf("%d%d",&j,&e);ListInsert(L,j,e);printf("插⼊后的顺序表为:\n");for (i=0;i<L->length;++i){printf("%d ",L->elem[i]);}printf("\n");printf("请输⼊要删除的位置:");scanf("%d",&lo);ListDelete(L,lo,temp);for (i=0;i<L->length;++i){printf("%d ",L->elem[i]);}printf("\n");free(L);return 0;}。
数据结构实验报告-线性表(顺序表实现)
实验1:线性表(顺序表的实现)一、实验项目名称顺序表基本操作的实现二、实验目的掌握线性表的基本操作在顺序存储结构上的实现。
三、实验基本原理顺序表是由地址连续的的向量实现的,便于实现随机访问。
顺序表进行插入和删除运算时,平均需要移动表中大约一半的数据元素,容量难以扩充四、主要仪器设备及耗材Window 11、Dev-C++5.11五、实验步骤1.导入库和一些预定义:2.定义顺序表:3.初始化:4.插入元素:5.查询元素:6.删除元素:7.销毁顺序表:8.清空顺序表:9.顺序表长度:10.判空:11.定位满足大小关系的元素(默认小于):12.查询前驱:13.查询后继:14.输出顺序表15.归并顺序表16.写测试程序以及主函数对顺序表的每一个操作写一个测试函数,然后在主函数用while+switch-case的方式实现一个带菜单的简易测试程序,代码见“实验完整代码”。
实验完整代码:#include <bits/stdc++.h>using namespace std;#define error 0#define overflow -2#define initSize 100#define addSize 10#define compareTo <=typedef int ElemType;struct List{ElemType *elem;int len;int listsize;}L;void init(List &L){L.elem = (ElemType *) malloc(initSize * sizeof(ElemType)); if(!L.elem){cout << "分配内存失败!";exit(overflow);}L.len = 0;L.listsize = initSize;}void destroy(List &L){free(L.elem);L.len = L.listsize = 0;}void clear(List &L){L.len = 0;}bool empty(List L){if(L.len == 0) return true;else return false;}int length(List L){return L.len;}ElemType getElem(List L,int i){if(i < 1 || i > L.len + 1){cout << "下标越界!";exit(error);}return L.elem[i - 1];}bool compare(ElemType a,ElemType b) {return a compareTo b;}int locateElem(List L,ElemType e) {for(int i = 0;i < L.len;i++){if(compare(L.elem[i],e))return i;}return -1;}int check1(List L,ElemType e){int idx = -1;for(int i = 0;i < L.len;i++)if(L.elem[i] == e)idx = i;return idx;}bool check2(List L,ElemType e){int idx = -1;for(int i = L.len - 1;i >= 0;i--)if(L.elem[i] == e)idx = i;return idx;}int priorElem(List L,ElemType cur_e,ElemType pre_e[]) {int idx = check1(L,cur_e);if(idx == 0 || idx == -1){string str = "";str = idx == 0 ? "无前驱结点" : "不存在该元素";cout << str;exit(error);}int cnt = 0;for(int i = 1;i < L.len;i++){if(L.elem[i] == cur_e){pre_e[cnt ++] = L.elem[i - 1];}}return cnt;}int nextElem(List L,ElemType cur_e,ElemType next_e[]){int idx = check2(L,cur_e);if(idx == L.len - 1 || idx == - 1){string str = "";str = idx == -1 ? "不存在该元素" : "无后驱结点";cout << str;exit(error);}int cnt = 0;for(int i = 0;i < L.len - 1;i++){if(L.elem[i] == cur_e){next_e[cnt ++] = L.elem[i + 1];}}return cnt;}void insert(List &L,int i,ElemType e){if(i < 1 || i > L.len + 1){cout << "下标越界!";exit(error);}if(L.len >= L.listsize){ElemType *newbase = (ElemType *)realloc(L.elem,(L.listsize + addSize) * sizeof(ElemType));if(!newbase){cout << "内存分配失败!";exit(overflow);}L.elem = newbase;L.listsize += addSize;for(int j = L.len;j > i - 1;j--)L.elem[j] = L.elem[j - 1];L.elem[i - 1] = e;L.len ++;}void deleteList(List &L,int i,ElemType &e){if(i < 1 || i > L.len + 1){cout << "下标越界!";exit(error);}e = L.elem[i - 1];for(int j = i - 1;j < L.len;j++)L.elem[j] = L.elem[j + 1];L.len --;}void merge(List L,List L2,List &L3){L3.elem = (ElemType *)malloc((L.len + L2.len) * sizeof(ElemType)); L3.len = L.len + L2.len;L3.listsize = initSize;if(!L3.elem){cout << "内存分配异常";exit(overflow);}int i = 0,j = 0,k = 0;while(i < L.len && j < L2.len){if(L.elem[i] <= L2.elem[j])L3.elem[k ++] = L.elem[i ++];else L3.elem[k ++] = L2.elem[j ++];}while(i < L.len)L3.elem[k ++] = L.elem[i ++];while(j < L2.len)L3.elem[k ++] = L2.elem[j ++];}bool visit(List L){if(L.len == 0) return false;for(int i = 0;i < L.len;i++)cout << L.elem[i] << " ";cout << endl;return true;}void listTraverse(List L){if(!visit(L)) return;}void partion(List *L){int a[100000],b[100000],len3 = 0,len2 = 0; memset(a,0,sizeof a);memset(b,0,sizeof b);for(int i = 0;i < L->len;i++){if(L->elem[i] % 2 == 0)b[len2 ++] = L->elem[i];elsea[len3 ++] = L->elem[i];}for(int i = 0;i < len3;i++)L->elem[i] = a[i];for(int i = 0,j = len3;i < len2;i++,j++) L->elem[j] = b[i];cout << "输出顺序表:" << endl;for(int i = 0;i < L->len;i++)cout << L->elem[i] << " ";cout << endl;}//以下是测试函数------------------------------------void test1(List &list){init(list);cout << "初始化完成!" << endl;}void test2(List &list){if(list.listsize == 0)cout << "线性表不存在!" << endl;else{int len;ElemType num;cout << "选择插入的元素数量:" << endl;cin >> len;cout << "依次输入要插入的元素:" << endl;for(int i = 1;i <= len;i++){cin >> num;insert(list,i,num);}cout << "操作成功!" << endl;}}void test3(){if(L.listsize == 0)cout << "线性表不存在!" << endl;else{cout << "请输入要返回的元素的下标" << endl;int idx;cin >> idx;cout << "线性表中第" << idx << "个元素是:" << getElem(L,idx) << endl;}}void test4(){if(L.listsize == 0)cout << "线性表不存在!" << endl;else{int idx;ElemType num;cout << "请输入要删除的元素在线性表的位置" << endl;cin >> idx;deleteList(L,idx,num);cout << "操作成功!" << endl << "被删除的元素是:" << num << endl; }}void test5(){if(L.listsize == 0)cout << "线性表不存在!" << endl;else{destroy(L);cout << "线性表已被销毁" << endl;}}void test6(){if(L.listsize == 0)cout << "线性表不存在!" << endl;else{clear(L);cout << "线性表已被清空" << endl;}}void test7(){if(L.listsize == 0)cout << "线性表不存在!" << endl;else cout << "线性表的长度现在是:" << length(L) << endl;}void test8(){if(L.listsize == 0)cout << "线性表不存在!" << endl;else if(empty(L))cout << "线性表现在为空" << endl;else cout << "线性表现在非空" << endl;}void test9(){if(L.listsize == 0)cout << "线性表不存在!" << endl;else{ElemType num;cout << "请输入待判定的元素:" << endl;cin >> num;cout << "第一个与目标元素满足大小关系的元素的位置:" << locateElem(L,num) << endl;}}void test10(){if(L.listsize == 0)cout << "线性表不存在!" << endl;else{ElemType num,num2[initSize / 2];cout << "请输入参照元素:" << endl;cin >> num;int len = priorElem(L,num,num2);cout << num << "的前驱为:" << endl;for(int i = 0;i < len;i++)cout << num2[i] << " ";cout << endl;}}void test11(){if(L.listsize == 0)cout << "线性表不存在!" << endl;else{ElemType num,num2[initSize / 2];cout << "请输入参照元素:" << endl;cin >> num;int len = nextElem(L,num,num2);cout << num << "的后继为:" << endl;for(int i = 0;i < len;i++)cout << num2[i] << " ";cout << endl;}}void test12(List list){if(L.listsize == 0)cout << "线性表不存在!" << endl;else{cout << "输出线性表所有元素:" << endl;listTraverse(list);}}void test13(){if(L.listsize == 0)cout << "初始线性表不存在!" << endl; else{List L2,L3;cout << "初始化一个新线性表" << endl;test1(L2);test2(L2);cout << "归并两个线性表" << endl;merge(L,L2,L3);cout << "归并成功!" << endl;cout << "输出合并后的线性表" << endl;listTraverse(L3);}}void test14(){partion(&L);cout << "奇偶数分区成功!" << endl;}int main(){std::ios::sync_with_stdio(false);cin.tie(0),cout.tie(0);int op = 0;while(op != 15){cout << "-----------------menu--------------------" << endl;cout << "--------------1:初始化------------------" << endl;cout << "--------------2:插入元素----------------" << endl;cout << "--------------3:查询元素----------------" << endl;cout << "--------------4:删除元素----------------" << endl;cout << "--------------5:销毁线性表--------------" << endl;cout << "--------------6:清空线性表--------------" << endl;cout << "--------------7:线性表长度--------------" << endl;cout << "--------------8:线性表是否为空----------" << endl;cout << "--------------9:定位满足大小关系的元素--" << endl;cout << "--------------10:查询前驱---------------" << endl;cout << "--------------11:查询后继---------------" << endl;cout << "--------------12:输出线性表-------------" << endl;cout << "--------------13:归并线性表-------------" << endl;cout << "--------------14:奇偶分区---------------" << endl;cout << "--------------15: 退出测试程序-----------" << endl;cout << "请输入指令编号:" << endl; if(!(cin >> op)){cin.clear();cin.ignore(INT_MAX,'\n');cout << "请输入整数!" << endl;continue;}switch(op){case 1:test1(L);break;case 2:test2(L);break;case 3:test3();break;case 4:test4();break;case 5:test5();break;case 6:test6();break;case 7:test7();break;case 8:test8();break;case 9:test9();break;case 10:test10();break;case 11:test11();break;case 12:test12(L);break;case 13:test13();break;case 14:test14();break;case 15:cout << "测试结束!" << endl;default:cout << "请输入正确的指令编号!" << endl;}}return 0;}六、实验数据及处理结果1.初始化:2.插入元素3.查询元素(返回的是数组下标,下标从0开始)4.删除元素(位置从1开始)5.销毁顺序表6.清空顺序表7.顺序表长度(销毁或清空操作前)8.判空(销毁或清空操作前)9.定位满足大小关系的元素(销毁或清空操作前)说明:这里默认找第一个小于目标元素的位置且下标从0开始,当前顺序表的数据为:1 4 2 510.前驱(销毁或清空操作前)11.后继(销毁或清空操作前)12.输出顺序表(销毁或清空操作前)13.归并顺序表(销毁或清空操作前)七、思考讨论题或体会或对改进实验的建议通过本次实验,我掌握了定义线性表的顺序存储类型,加深了对顺序存储结构的理解,进一步巩固和理解了顺序表的基本操作,如建立、查找、插入和删除等。
数据结构(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. 单链表单链表是一种常见的链式存储结构,每个节点包含数据和指向下一个节点的指针。
顺序表的基本操作--实验报告
实验报告附:源程序:#include<stdio.h>#define Maxsize 100#define error 0#define ok 1typedef struct{int elem[Maxsize];int last;}SeqList;int InsList(SeqList *L,int a,int i); int Locate(SeqList L,int e);int Del(SeqList *L,int i);void main(){int i,e,a;int list1,list2;SeqList L;st=0;for(i=0;i<100;i++){printf("请输入顺序表元素\n");scanf("%d",&L.elem[i]);if(L.elem[i]==-1)break;st++;}if(L.elem[st]==-1)st--;printf("要插入的元素,位置为\n"); scanf("%d,%d",&a,&i);list1=InsList(&L,a,i);if(list1){printf("插入后的顺序表为:\n");for(i=0;i<=st;i++)printf("%d",L.elem[i]);printf("\n");}elseprintf("插入失败!");printf("要查找的元素为\n");scanf("%d",&e);list2=Locate(L,e);if(!list2)printf("该元素不存在\n");elseprintf("该元素所在位置的序号为:%d\n",list2);/*删除元素*/printf("是否要删除该元素?<是请输入1 ,否请输入0 >\n");int m;scanf("%d",&m);if(m){Del(&L,list2);printf("删除后的顺序表为:\n");for(i=0;i<=st;i++)printf("%d",L.elem[i]);printf("\n");}else printf("未删除元素%d\n",e);}int InsList(SeqList *L,int a,int i)//i位置,下标i-1{int p;if(L->last>=Maxsize-1){printf("表已满,无法插入");return(error);}for(p=L->last;p>=i-1;p--)L->elem[p+1]=L->elem[p];L->elem[i-1]=a;L->last++;return(ok);}int Locate(SeqList L,int e){int i=0;while((i<=st)&&(L.elem[i]!=e)) i++;if (i<=st)return(i+1);else return(error);}int Del(SeqList *L,int i){int k;for(k=i;k<=L->last;k++)L->elem[k-1]=L->elem[k];L->last--;return ok;}。
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);}以上就是本⽂的全部内容,希望对⼤家的学习有所帮助,也希望⼤家多多⽀持。
实验一顺序表的基本操作实验报告
元素之后的所有数据都前移一个位置,最将线性表长减1。
3.顺序表查找操作的基本步骤:要在顺序表中查找一个给定值的数据元素则可以采用顺序查找的方法,从表中第 1 个数据元素开始依次将值与给定值进行比较,若相等则返回该数据元素在顺序表中的位置,否则返回0 值。
线性表的动态分配顺序存储结构—C语言实现#define MaxSize 50//存储空间的分配量Typedef char ElemType;Typedef struct{ElemType data[MaxSize];int length; //表长度(表中有多少个元素)}SqList;动态创建一个空顺序表的算法:void InitList(SqList *&L) //初始化线性表{L=(SqList *)malloc(sizeof(SqList)); //分配存放线性表的空间L->length=0; //置空线性表长度为0}线性表的插入:status Sqlist_insert(Sqlist &L,int i,Elemtype x)/*在顺序表L中第i个元素前插入新元素x*/{ if (i<1||i>L.length+1) return ERROR; /*插入位置不正确则出错*/if (L.length>=MAXLEN)return OVERFLOW;/*顺序表L中已放满元素,再做插入操作则溢出*/for(j=L.length-1;j>=i-1;j--)L.elem[j+1]=L.elem[j]; /*将第i个元素及后续元素位置向后移一位*/L.elem[i-1]=x; /*在第i个元素位置处插入新元素x*/L.length++; /*顺序表L的长度加1*/return OK;}线性表的删除:status Sqlist_delete(Sqlist &L,int i,Elemtype &e)/*在顺序表L中删除第i个元素*{ if (i<1||i>L.length) return ERROR; /*删除位置不正确则出错*/for(j=i;j<=L.length-1;j++)L.elem[j-1]=L.elem[j]; /*将第i+1个元素及后继元素位置向前移一位*/L.length--;/*顺序表L的长度减1*/return OK;}线性表元素的查找:int LocateElem(SqList *L, ElemType e) //按元素值查找{int i=0;while (i<L->length && L->data[i]!=e)i++; //查找元素eif (i>=L->length) //未找到时返回0return 0;elsereturn i+1; //找到后返回其逻辑序号}输出线性表:void DispList(SqList *L) //输出线性表{int i;if (ListEmpty(L)) return;for (i=0;i<L->length;i++)printf("%c ",L->data[i]);printf("\n");}输出线性表第i个元素的值:bool GetElem(SqList *L,int i,ElemType &e)//求线性表中某个数据元素值{if (i<1 || i>L->length)return false; //参数错误时返回falsee=L->data[i-1]; //取元素值return true; //成功找到元素时返回true}代码:#include <stdio.h>#include <malloc.h>#define MaxSize 50typedef char ElemType;typedef struct{ElemType data[MaxSize];int length;} SqList;void InitList(SqList *&L);void DestroyList(SqList *L);bool ListEmpty(SqList *L);int ListLength(SqList *L);void DispList(SqList *L);bool GetElem(SqList *L,int i,ElemType &e);int LocateElem(SqList *L, ElemType e);bool ListInsert(SqList *&L,int i,ElemType e);bool ListDelete(SqList *&L,int i,ElemType &e);void InitList(SqList *&L)//初始化线性表{L=(SqList *)malloc(sizeof(SqList));//分配存放线性表的空间L->length=0;//置空线性表长度为0 }void DestroyList(SqList *L)//销毁线性表{free(L);}bool 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->data[i]);printf("\n");}bool GetElem(SqList *L,int i,ElemType &e)//求线性表中某个数据元素值{if (i<1 || i>L->length)return false;//参数错误时返回falsee=L->data[i-1];//取元素值return true;//成功找到元素时返回true}int LocateElem(SqList *L, ElemType e)//按元素值查找{int i=0;while (i<L->length && L->data[i]!=e)i++;//查找元素eif (i>=L->length)//未找到时返回0return 0;elsereturn i+1;//找到后返回其逻辑序号}bool ListInsert(SqList *&L,int i,ElemType e)//插入数据元素{int j;if (i<1 || i>L->length+1)return false;//参数错误时返回falsei--;//将顺序表逻辑序号转化为物理序号for (j=L->length;j>i;j--)//将data[i]及后面元素后移一个位置L->data[j]=L->data[j-1];L->data[i]=e;//插入元素eL->length++;//顺序表长度增1return true;//成功插入返回true}bool ListDelete(SqList *&L,int i,ElemType &e)//删除数据元素{int j;if (i<1 || i>L->length)//参数错误时返回falsereturn false;i--;//将顺序表逻辑序号转化为物理序号e=L->data[i];for (j=i;j<L->length-1;j++)//将data[i]之后的元素前移一个位置L->data[j]=L->data[j+1];L->length--;//顺序表长度减1return true;//成功删除返回true}void main(){SqList *L;ElemType e;printf("顺序表的基本运算如下:\n");printf(" (1)初始化顺序表L\n");InitList(L);printf(" (2)依次采用尾插法插入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(" (3)输出顺序表L:");DispList(L);printf(" (4)顺序表L长度=%d\n",ListLength(L));printf(" (5)顺序表L为%s\n",(ListEmpty(L)?"空":"非空"));GetElem(L,3,e);printf(" (6)顺序表L的第3个元素=%c\n",e);实验结果:心得体会:通过本次实验,实现了数据结构在程序设计上的作用,了解了数据结构语言,加深了对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. 顺序表的删除从顺序表中删除元素需要移动后面的元素,以保证元素的顺序性。
c语言优先级顺序表
c语言优先级顺序表C语言优先级顺序表简介C语言是一种广泛使用的编程语言,其优先级顺序表是用来确定不同操作符的计算顺序的工具。
在C语言中,不同操作符具有不同的优先级,通过使用优先级顺序表,可以确保表达式的计算按照预期的顺序进行,避免产生错误的结果。
一、基本概念1.1 操作符在C语言中,操作符是用来执行特定操作的符号。
常见的操作符包括算术操作符(如加法、减法等)、关系操作符(如大于、小于等)、逻辑操作符(如与、或等)等。
1.2 优先级操作符的优先级决定了它在表达式中的计算顺序。
具有高优先级的操作符会先于低优先级的操作符进行计算。
例如,在表达式中同时包含加法和乘法操作符时,乘法操作符的优先级高于加法操作符,因此会先进行乘法计算。
1.3 优先级顺序表优先级顺序表是一个用来确定不同操作符优先级的表格。
在C语言中,优先级顺序表按照操作符的优先级从高到低排列,同一优先级的操作符按照从左到右的顺序排列。
通过查阅优先级顺序表,可以确定操作符的计算顺序。
二、常见操作符的优先级顺序2.1 括号括号是用来改变操作符的优先级的工具,括号中的表达式会首先进行计算。
因此,括号具有最高的优先级。
2.2 一元操作符一元操作符是只对一个操作数进行操作的操作符,例如取反操作符(!)、递增操作符(++)等。
一元操作符的优先级高于其他操作符。
2.3 乘法和除法操作符乘法(*)和除法(/)操作符具有相同的优先级,高于加法(+)和减法(-)操作符。
乘法和除法操作符按照从左到右的顺序计算。
2.4 加法和减法操作符加法和减法操作符具有相同的优先级,低于乘法和除法操作符。
加法和减法操作符按照从左到右的顺序计算。
2.5 关系操作符关系操作符用于比较两个操作数的大小关系,例如大于(>)、小于(<)等。
关系操作符的优先级低于算术操作符。
2.6 逻辑操作符逻辑操作符用于进行逻辑运算,例如与(&&)、或(||)等。
逻辑操作符的优先级低于关系操作符。
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看懂了左⼿给你个栗⼦,给我关注点赞;看不懂右⼿给你个锤⼦,砸开脑壳看看有没有带脑⼦。
创建顺序表c语言
创建顺序表c语言创建顺序表是数据结构学习过程中的基础操作之一。
在C语言中,创建顺序表需要以下步骤:1. 定义结构体:首先需要定义一个结构体,用来表示顺序表。
结构体中包含一个指向数据区域的指针和当前顺序表的长度。
```typedef struct {int *data;int length;} SeqList;```2. 初始化顺序表:初始化顺序表需要动态分配内存,为顺序表的数据区域分配空间。
可以使用malloc函数来实现动态分配内存。
```void initSeqList(SeqList *L, int maxSize) {L->data = (int *)malloc(maxSize * sizeof(int));L->length = 0;}```3. 插入元素:插入元素需要先判断顺序表是否已满。
如果未满,则将新元素插入到顺序表的末尾。
```int insert(SeqList *L, int elem) {if (L->length >= MAXSIZE) {return -1; // 表示顺序表已满,插入失败}L->data[L->length] = elem; // 将新元素插入到顺序表末尾 L->length++; // 更新顺序表长度return 0;}```4. 删除元素:删除元素需要先判断顺序表是否为空。
如果非空,则将要删除的元素移除,并将后面的元素前移。
```int remove(SeqList *L, int index) {if (index < 0 || index >= L->length) {return -1; // 表示删除失败,索引越界}for (int i = index + 1; i < L->length; i++) {L->data[i - 1] = L->data[i]; // 将后面的元素前移}L->length--; // 更新顺序表长度return 0;}```5. 查找元素:查找元素需要先判断顺序表是否为空。
用C语言实现顺序表的基本操作
/******* *************************main.c *************************************/ #include<stdio.h> #include"SeqList.h"
void main() { SeqList L;
用 C 语言实现顺序表的基本操作
/********************************SeqList.h *************************************/ #ifndef _SEQLIST_H #define _SEQLIST_H
//函数结果状态码 #define TRUE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define INFEASIBLE -1 #define OVERFLOW -2
{ return list->node[pos]; } else if(!ret) { printf("\n 获取下标为%d 即第%d 个顺序表元素失败!\n",pos,pos+1); } }
/* pos:表示位置,0<=pos<list->length */ Status SeqList_Insert(SeqList*list,ElemType e,int pos) { Status ret=-1; int i=0;
typedef int Status; typedef int ElemType;
typedef struct {
ElemType *node;//存储空间基址 int capacity;//当前分配的最大存储容量 int le_Create(SeqList*list,int capacity); void SeqList_Destroy(SeqList*list); void SeqList_Clear(SeqList*list); int SeqList_Length(SeqList*list); int SeqList_Capacity(SeqList*list); ElemType SeqList_Get(SeqList *list,int pos); Status SeqList_Insert(SeqList*list,ElemType e,int pos); Status SeqList_Delete(SeqList*list,int pos);
数据结构 顺序表基本运算实现
; //依次打印输出顺序表中的元素
printf("\n");
}
//查找
locate(SeqList *list, int e)
{
int i;
printf("插入元素,请输入需要插入的位置:\n");
scanf("%d",&i);
insert(list,i,e);
printList(list);
break;
3.编写一个完整的程序实现顺序表的下列基本操作:
(1) 新建一个顺序表。。
(2) 打印输出顺序表中的元素。
(3) 在顺序表中查找某个元素。
(4) 在顺序表中指定位置插入元素。
(5) 在顺序表中删除指定位置的元素。
(6) 删除顺序表La中的某一元素。
编写一个主菜单,调用以上基本操作。
参考程序代码如下,请将其补充完整,并上机调试运行。
//顺序表的建立、查找、插入与删除,表元素为数字
#include <stdio.h>
#include <malloc.h>
#include <stdlib.h>
#define MAX 100 //表最大长度
//选择顺序表操作动作
printf("请输入操作对应的数字进行顺序表的操作:\n");
printf("————查询(1)\n);
printf("————插入(2)\n);
printf("————删除(3)\n);
printf("————退出(0)\n);
顺序表的基本操作【c语言】【创建、插入、删除、输出】
顺序表的基本操作【c语⾔】【创建、插⼊、删除、输出】作为数据结构初学者,上课时对⼀些知识点掌握得不是很透彻,所以利⽤课余时间通过微博平台总结所学知识,加深对知识的见解,记录学习历程便于后需要时参考。
1 #include<stdio.h>2 #include<malloc.h>3#define OK 14#define ERROR 05#define LIST_INIT_SIZE 1006#define LISTINCREMENT 107#define ElemType int顺序表的基本操作之结构体的创建:1 typedef struct2 {3int *elem;//存储空间基址,也就是该数据得到的内存分配的起始地址4int length;//当前长度5int listsize;//当前分配的存储容量6 } SqList;构造⼀个空的线性表:int InitList_Sq(SqList &L) //&此符号不是c语⾔⾥的取地址符号,⽽是C++⾥的引⽤符号,⽤法为为主函数⾥的T,取⼀个别名,这样⼦对L操作即相当于对T操作{// 该线性表预定义⼤⼩为LIST_INIT_SIZEL.elem=(ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemType));//ElemType即为intif(!L.elem) return0;//malloc返回值为void*,void* 类型可以强制转换为任何其它类型的指针,在这⾥L.elem为⾮零。
L.length=0;L.listsize=LIST_INIT_SIZE;//LIST_INIT_SIZE=100return OK;}在顺序线性表L中第i个位置之前插⼊新的元素e:1int ListInsert_Sq(SqList &L,int i,int e)2 {3int *newbase;//声明整型指针变量4int *q,*p;5if(i<1||i>L.length+1) return ERROR;//判断i值是否合法,1<i<L.length+16if(L.length>=L.listsize)//判断当前长度是否⼤于当前的存储容量,如果⼤于,则增加LISTINCREMENT长度,即107 {8 newbase=(ElemType*)realloc(L.elem,(L.listsize+LISTINCREMENT)*sizeof(ElemType));9if(!newbase) return0;10 L.elem=newbase;11 L.listsize+=LISTINCREMENT;12 }13 q=&(L.elem[i-1]);//把插⼊位置的地址赋值给q14for(p=&(L.elem[L.length-1]); p>=q; p--)15 *(p+1)=*p;//把i后⾯的元素都向后移⼀位16 *q=e;//在i位置插⼊e17 ++L.length;//长度增加18return OK;19 }在顺序线性表L中删除第i个位置的元素,并⽤e返回其值:int ListDelete_Sq(SqList &L,int i, int &e){// i的合法值为1≤i≤L.lengthint *p;int *q;if(i<1||i>L.length) return ERROR;p=&(L.elem[i-1]);//把i位置的地址赋值给pe=*p;//把i位置的值赋值给eq=L.elem+L.length-1;for(++p; p<=q; ++p)*(p-1)=*p;//i后⾯的元素向前移⼀位,直接覆盖i位置的值--L.length;//长度减少return OK;}顺序表基本操作之输出:int Load_Sq(SqList &L){// 输出顺序表中的所有元素int i;if(L.length==0) printf("The List is empty!");else{printf("The List is: ");for( i=0; i<L.length; i++) printf("%d ",L.elem[i]); // 请填空}printf("\n");return OK;}下⾯是主函数:1int main()2 {3 SqList T;4int a, i;5 ElemType e, x;6if(InitList_Sq(T)) // 判断顺序表是否创建成功7 {8 printf("A Sequence List Has Created.\n");9 }10while(1)11 {12 printf("1:Insert element\n2:Delete element\n3:Load all elements\n0:Exit\nPlease choose:\n");13 scanf("%d",&a);14switch(a)15 {16case1:17 scanf("%d%d",&i,&x);18if(!ListInsert_Sq(T,i,x)) printf("Insert Error!\n"); // 判断i值是否合法19else printf("The Element %d is Successfully Inserted!\n", x);20break;21case2:22 scanf("%d",&i);23if(!ListDelete_Sq(T,i,e)) printf("Delete Error!\n"); // 判断i值是否合法24else printf("The Element %d is Successfully Deleted!\n", e);25break;26case3:27 Load_Sq(T);28break;29case0:30return1;31 }32 }33 }。
顺序表的基本操作实验报告
顺序表的基本操作实验报告顺序表的基本操作实验报告引言:顺序表是一种常见的数据结构,它以连续的存储空间来存储数据元素,具有随机访问的特点。
在本次实验中,我们将通过实践来学习顺序表的基本操作,包括插入、删除、查找等,以加深对顺序表的理解和运用。
实验目的:1. 掌握顺序表的插入操作;2. 掌握顺序表的删除操作;3. 掌握顺序表的查找操作;4. 熟悉顺序表的基本操作的时间复杂度。
实验材料和方法:1. 实验材料:计算机、编程环境;2. 实验方法:使用编程语言实现顺序表的基本操作,并进行测试。
实验过程:1. 插入操作:在顺序表中插入一个元素,需要将插入位置之后的元素依次后移,并将新元素插入到指定位置。
实现代码如下:```pythondef insert_element(seq_list, index, value):seq_list.append(None) # 在顺序表末尾添加一个空位for i in range(len(seq_list)-1, index, -1):seq_list[i] = seq_list[i-1]seq_list[index] = value```通过测试,我们可以验证插入操作的正确性和时间复杂度。
2. 删除操作:顺序表的删除操作需要将删除位置之后的元素依次前移,并将最后一个元素删除。
实现代码如下:```pythondef delete_element(seq_list, index):for i in range(index, len(seq_list)-1):seq_list[i] = seq_list[i+1]seq_list.pop()```通过测试,我们可以验证删除操作的正确性和时间复杂度。
3. 查找操作:顺序表的查找操作可以通过遍历整个顺序表来实现,也可以利用有序性进行优化。
实现代码如下:```pythondef search_element(seq_list, value):for i in range(len(seq_list)):if seq_list[i] == value:return ireturn -1```通过测试,我们可以验证查找操作的正确性和时间复杂度。
数据结构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; } 运行及结果:
顺序表的基本操作(5篇)
顺序表的基本操作(5篇)第一篇:顺序表的基本操作*********************************** 实验题目:顺序表的基本操作班级:姓名:学号:专业:实验完成的时间:*********************************一、实验目的(1)(2)(3)(4)掌握顺序表的基本运算,熟悉对顺序表的一些基本操作和具体函数的定义。
掌握顺序表的存储结构及其基本操作。
熟悉c语言程序的基本结构,掌握函数定义、调用等功能。
熟悉c语言环境的使用及程序的输入、编辑、调试和运行的全过程。
二、实验要求(1)熟练掌握线性表的存储结构及其基本操作。
(2)理解所给出的算法,掌握顺序表在实际中的应用。
(3)将上机程序调试通过,并能独立完成一至两个拓展题目。
三、实验内容实现顺序表上的插入、删除等操作。
调试程序并对相应的输出作出分析;修改输入数据,预期输出并验证输出的结果。
加深对有关算法的理解。
(1)主要内容:#define MAXSIZE 100 /*宏定义*/ //#define OVERFLOW-2 #include “stdio.h” /*包含输入输出文件*/typedef int data;typedef struct /*定义顺序表的结构*/ {data vec[MAXSIZE];/*顺序表数据成员所占据的存储空间*/ int last;/*顺序表中最后一个元素在数组中的下标(或向量中的位置)从0开始*/ }sequenlist;int insert(L,i,x)/*在顺序表的第i个元素之前插入一个新元素x*/ sequenlist *L;int i;data x;{ int j;if(((*L).last)>=MAXSIZE-1){printf(“the list is overflow!n”);return(0);/*溢出判断*/ } else if((i<1)||(i>(*L).last+1)){printf(“position is not correct!n”);return(0);/*插入位置不正确*/ } else {for(j=(*L).last;j>=i-1;j--)/*后移元素*/(*L).vec[j+1]=(*L).vec[j];(*L).vec[i-1]=x;/*插入新元素*/(*L).last=(*L).last+1;/*修改last的值*/ } return(1);} void DELETET(L,i)sequenlist *L;int i;{ int j;if(i<1||(i>L->last+2)) printf(“删除的位置错误n”);else {for(j=i;j<=(*L).last;j++)(*L).vec[j-1]=(*L).vec[j];(*L).last--;} } void listprint(sequenlist *L)/*输出线性表*/ { int i;for(i=0;i<=(*L).last;i++)printf(“i,e=%d,%dn”,i,L->vec[i]);} main(){ sequenlist sl={{1,2,3,4,5,6,7,8,9,10},9};//直接给顺序表赋初值sequenlist *L;/*定义一个指向顺序表类型的指针变量*/ int i,j,x;//elemtype e;L=&sl;/*给指针变量赋值*/ printf(“请输入你插入的位置和数n”);scanf(“%d,%d”,&i,&x);printf(“这个插入的位置: %d n插入的数:%dn”,i,x);insert(L,i,x);listprint(L);printf(“请输入删除的位置:”);scanf(“%d”,&j);DELETET(L,j);listprint(L);}(2)预习思考题(1)定义一个定位函数locate(L,x),具有元素检索的功能。
顺序表的建立、输入、输出、查找、插入、删除(数据结构)
顺序表的建⽴、输⼊、输出、查找、插⼊、删除(数据结构)1.顺序表的基本操作实践。
(1)建⽴4个元素的顺序表list[]={2,3,4,5},实现顺序表建⽴的基本操作。
(2)在list[]={2,3,4,5}的元素4和5之间插⼊⼀个元素9,实现顺序表插⼊的基本操作。
(3)在list[]={2,3,4,9,5}中删除指定位置(i=3)上的元素4,实现顺序表的删除的基本操作。
#include <stdio.h>#include <stdlib.h>#include <iostream>#define MAXSIZE 10using namespace std;typedef int ElemType;typedef struct {ElemType a[MAXSIZE];int length;} S;void CreatList(S &L) {scanf("%d", &L.length);for(int i = 1; i <= L.length; i ++) scanf("%d",&L.a[i]);} //创建列表void PutList(S L) {for(int i = 1; i <= L.length; i ++) {printf("%d ",L.a[i]);}printf("\n");} //输出列表void InserElem(S &L, int i, ElemType x) { j iif(i < 1 || i > L.length) return; 2 3 4 5 9for(int j = L.length+1; j > i; j --) { j-1jL.a[j] = L.a[j-1]; 2 3 4 9 5}L.a[i] = x;L.length++;} //插⼊void DeleElem(S &L, int i) {for(int j = i; j < L.length; j ++) {L.a[j] = L.a[j+1]; j j+1} 2 3 4 9 5L.length--;}//删除int main() {S L;CreatList(L);InserElem(L,4,9);PutList(L);DeleElem(L,3);PutList(L);return0;}结果E:\c++>b42345234952395。
c++有序顺序表的建立与基本操作
c++有序顺序表的建立与基本操作【C++有序顺序表的建立与基本操作】一、引言在C++编程中,有序顺序表是非常常见的数据结构之一。
它可以帮助我们存储和操作一组有序的数据,是程序中非常实用的工具。
本文将从有序顺序表的概念入手,逐步深入探讨其建立和基本操作,帮助读者更好地理解和运用这一数据结构。
二、有序顺序表的概念有序顺序表是一种线性表,其中元素按照一定的顺序排列。
在C++中,我们通常使用数组来实现有序顺序表。
通过数组,我们可以轻松地存储一组有序的数据,并且可以方便地进行各种基本操作,如插入、删除、查找等。
三、有序顺序表的建立1. 定义结构体或类我们需要定义一个结构体或类,用于表示有序顺序表。
结构体或类中应包含元素存储的数组,以及记录当前元素个数和表长的变量。
2. 初始化在建立有序顺序表时,我们需要对其进行初始化。
可以通过动态内存分配来分配数组空间,并对其他变量进行初始化。
需要注意的是,数组的大小应该根据实际需要进行调整,以防止空间浪费。
3. 插入元素在有序顺序表中插入元素是一个常见的操作。
当插入元素时,我们需要保持顺序表的有序性。
可以通过比较元素大小的方式,找到合适的位置并将元素插入其中。
四、有序顺序表的基本操作1. 插入操作有序顺序表的插入操作是比较常见的操作之一。
当我们需要向顺序表中插入新元素时,我们首先需要找到合适的位置,然后将其插入其中。
2. 删除操作删除操作是有序顺序表中另一个重要的操作。
当我们需要删除某个元素时,我们可以通过查找元素的方式找到需要删除的元素,然后将其后的元素向前移动,从而达到删除的目的。
3. 查找操作有序顺序表中的查找操作也是常见的操作之一。
当我们需要查找某个元素时,可以通过顺序查找或二分查找的方式进行查找,以获取所需的元素。
五、个人观点和理解有序顺序表是C++编程中非常常见的数据结构之一。
它能够帮助我们高效地存储和操作数据,是程序中的重要工具。
在实际应用中,我们需要灵活地运用有序顺序表的建立和基本操作,以解决实际问题。
顺序表的基础操作
顺序表是一种线性表的数据结构,它由一个数组和指向数组第一个元素的指针构成,支持线性表中的基本操作。
以下是顺序表的基础操作。
1. 初始化操作:初始化顺序表时需要给数组分配内存空间,并且确定顺序表的长度,可使用calloc 函数来动态分配内存空间,初始化值为0。
2. 插入操作:在顺序表中插入元素时,需要判断插入位置是否合法(在数组中的下标范围内),并将插入位置后的元素后移,将新元素插入。
3. 删除操作:删除顺序表中的元素时,需要判断删除位置是否合法,将被删除元素后面的元素前移,覆盖被删除元素,同时调整顺序表的长度。
4. 查找操作:查找顺序表中的元素时,可以通过循环遍历数组的元素来进行查找,也可以使用二分查找算法进行查询,从而提高效率。
5. 遍历操作:遍历顺序表时,通过循环遍历数组的元素,逐个访问顺序表中的每一个元素。
6. 获取长度操作:获取顺序表的长度时,直接返回顺序表的长度值即可。
7. 清空操作:清空顺序表时,需要将数组中所有元素清空,并将顺序表的长度设置为0。
8. 销毁操作:销毁顺序表时,需要释放动态分配的内存空间。
以上是顺序表的基本操作,它们是实现线性表的常用操作,对于线性表的数据结构学习非常重要。
1.C语言顺序表实验报告
实验报告要求一、实验目的二、实验内容三、程序流程图实验结果(要求检测全部状况的正确性,写出测试条件及相应的测试结果)达成思虑题实验一次序表的基本操作(2学时)一、实验目的认识次序表的逻辑特色,掌握次序表的描绘方法、特色及相关的观点,掌握次序表上的插入和删除等基本操作算法。
二、实验内容在次序表List []中,实现次序表的基本操作,包含:初始化次序表,在表中插入元素、删除元素。
基本要求:次序表的元素个数可任意设定;可连续测试任意多个元素的插入、删除,(插入、删除地点及要插入元素数值均从键盘输入);任一操作结束后将次序表中的内容输出;可由用户选择退出程序。
三、实验重点及说明次序表又称为线性表的次序储存构造,它是用一组地点连续的储存单元挨次寄存线性表的各个元素。
可按以下格式定义次序表:#define MAXLEN 50/*定义次序表最大元素个数50 */ typedef struct{datatype List[MAXLEN];/*定义次序表List */int Num;/*定义次序表表长*/}Seqlist;模块区分:( 1)initiq( ) 函数:初始化次序表(2) insertq( )函数:实现插入功能(3) deleteq( )函数:实现删除功能(4) print( )函数:实现输出功能四、参照源程序#include <>#define MAXLEN 50typedef int datatype;typedef struct{datatype List[MAXLEN];int Num;}Seqlist;void initiq(Seqlist *la );int insertq(Seqlist *la,int n);int deleteq(Seqlist *la,int n);int print(Seqlist *la);void main(){ Seqlist la;int s,n;/* s选择输入,n 插入或删除数据的个数*/printf(" 请输入你的选择: 1---initiate 2---insert 3---delete 4---print 5---exit\nyour choice =");scanf("%d",&s);while(s!=5){ if(s==1){initiq( &la );printf(" 达成初始化!\n");}else if(s==2){printf(" 请输入待插入的数据个数 :");scanf("%d",&n);insertq(&la,n);print(&la);}else if(s==3){printf(" 请输入待删除的数据个数 :");scanf("%d",&n);deleteq(&la,n);print(&la);}else if(s==4){print(&la);}elseprintf(" 你的选择是错误的!\n ");printf("请输入你的选择: 1---initiate 2---insert 3---delete 4---print 5---exit\nyour choice =");scanf("%d",&s);}}/* 初始化 */void initiq(Seqlist *la ){ la-> Num=0; }/* 插入 */int insertq(Seqlist *la,int n){ int i,j;/*i 插入地点,datatype x;/*x 插入数据while(n)j 次序表下标*/*/{if (la->Num>=MAXLEN-1){printf ("\n表满,不可以插入!插入未达成,还有%d个数据未插入\n",n);return 0;}printf("请输入插入的地点和数据:");scanf("%d%d",&i,&x);if (i<0||i>la->Num){printf ("\n插入地点不合理!\n");}else{ if (i== la->Num)la->List[i]=x;else{for ( j=la->Num; j>i; j--)la->List[j]=la->List[j-1];la->List[i]=x;}la->Num++;n--; }}printf(" 插入达成 \n");return 1;}/* 删除 */int deleteq(Seqlist *la,int n)*/{ int i,j; /*i 删除地点,j 次序表下标while(n){if (la->Num<=0){printf ("\n 表空,不可以删除! \n");return 0;}printf(" 请输入删除的地点:");scanf("%d",&i);if (i<0||i>=la->Num){printf ("\n删除地点错误!\n");}else{for ( j=i+1; j<la->Num; j++) la->List[j-1]=la->List[j];la->Num--;n--; } }printf(" 删除达成!\n");return 1;}/* 显示输出 */int print (Seqlist *la){ int m;if (la->Num<=0){printf(" 次序表为空 !\n");return 0;}else{printf(" 目前的次序表为 :\n");for(m=0;m<la->Num;m++)printf("List[%d]=%d",m,la->List[m]);printf("\n表长为%d\n",la->Num);return 1;}}五、思虑题x 插入到1.设次序表 L 中的数据元素按递加摆列,编写一个算法,将数据元素次序表 L 的适合地点上,以保持次序表的有序性。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
函数文件function1.cpp
#include"Sqlist1.h"
#include<stdio.h>
void InitList(Sqlist &L)//构造一个空的顺序线性表L
{ L.elem=(ElemType *)malloc(LIST_INIT_SIZE*sizeof(ElemType));
}
int LocateElem(Sqlist L,ElemType e,Status(*compare)(ElemType,ElemType))////返回L中第1个与e满足关系compare()数据关系的位序,如果这样的数据不存在刚返回值为了0
{ int i=1;
ElemType *p=L.elem;//p的初值为第1个元素的存储位置
int ListLength(Sqlist L);//返回L中元素的个数
Status GetElem(Sqlist L,int i,ElemType &e);//用e返回L中第i个元素的值
int LocateElem(Sqlist L,ElemType e,Status(* compare)(ElemType,ElemType));//返回L中第1个与e满足关系compare()数据关系的位序,如果这样的数据不存在刚返回值为了0
Status equal(ElemType c1,ElemType c2);//判断是否相等的函数
Status PriorElem(Sqlist L,ElemType cur_e,ElemType &pre_e);//若cur_e是L的数据元素,而且不是第一个,就用pre_e返回它的前驱S
Status NextElem(Sqlist L,ElemType cur_e,ElemType &next_e);//若cur_e是L的数据元素,而且不是最后一个,就用next_e返回它的后继
typedef struct Sqlist
{ ElemType *elem;//存储空间基址
int length;//当前长度
int listsize;//当前分配的存储容量
}Sqlist;
//常用函数
void InitList(Sqlist &L);//初始化线性表
Status ListInsert(Sqlist &L,int i,ElemType e);//向线性表中插入元素
L.length--;
return OK;
}
Status equal(ElemType c1,ElemType c2)//判断是否相等
{ if(c1==c2)
return TRUE;
else return FALSE;
}
void print1(ElemType &c)
{ printf("%d",c);
if(!L.elem) //存储分配失败
exit(OVERFLOW);
L.length=0;//空表长度为了0
L.listsize=LIST_INIT_SIZE;//初始存储量
}
Status ListInsert(Sqlist &L,int i,ElemType e)//在L的第i个位置上插入新的数据元素e,L的长度加1
{ ElemType *newbase,*p,*q;
if(i<1||i>L.length+1) return ERROR;//i不合法
if(L.length==L.listsize)//当前存储空间已满,增加分配
{ newbase=(ElemType*)realloc(L.elem,(L.listsize+LISTINCREMENT)*sizeof(ElemType));
{ p++;
i++;
}
if(i==L.length)//到表尾还没有找到cur_e
return ERROR;
else
{ next_e=*++p;//p指向下一个元素,将所指元素的值赋给next_e
return OK;
}
}
Status ListDelete(Sqlist &L,int i,ElemType &e)
C语言实现顺序表的基本操作
2009-09-19 11:42:39| 分类: C语言实现数据结 |字号 订阅
头文件Sqlist1.h
#include<malloc.h>
#include<stdio.h>
#include<stdlib.h>
#define TRUE 1
#define FALSE 0
if(L.length==0) return TRUE;
else return FALSE;
}
void ClearList(Sqlist &L)//将L重置为空表
{ Lt ListLength(Sqlist L)//返回L中元素的个数
{ return L.length;
i++;
}
if(i>L.length)//到表结束还没有找到值为cur_e的元素
return ERROR;
else//找到值为cur_e,并由p指向
{ pre_e=*--p;//p指向前一个元素的前驱,并将所指元素的值赋给pre_e
return OK;
}
}
Status ListDelete(Sqlist &L,int i,ElemType &e);//删除L的第i个元素,并用e返回其值,L的长度减1
void MergeList(Sqlist La,Sqlist Lb,Sqlist &Lc);//归并la和lb得到新的顺序表lc,lc的元素也是按值非递减排列的
if(!newbase) //存储分配失败
exit(OVERFLOW);
L.elem=newbase;//新基址给L.elem
L.listsize+=LISTINCREMENT;//增加存储容量
}
q=L.elem+i-1;//q为插入点
for(p=L.elem+L.length-1;p>=q;--p)//插入位置及以后元素后移
{//归并La和Lb得到新的顺序表Lc,它的元素也按值非递减排列
ElemType *pa,*pa_last,*pb,*pb_last,*pc;
pa=La.elem;//pa指向表LA的第1个元素
pb=Lb.elem;//pb指向表LB的第2个元素
Lc.listsize=Lc.length=La.length+Lb.length;
while(i<=L.length&&!compare(*p++,e))//i没有超出表的范围,并且没有找到满足关系的数据元素
++i;
if(i<=L.length)//找到满足关系的数据元素
return i;
else
return 0;
}
Status PriorElem(Sqlist L,ElemType cur_e,ElemType &pre_e)
}
Status GetElem(Sqlist L,int i,ElemType &e)//用e返回L中第i个元素的值
{ if(i<1||i>L.length)//如果i的值不在表L的范围内
return ERROR;
e=*(L.elem+i-1);//将第i个元素的值赋给e
return OK;
void ListTraverse(Sqlist L,void(*visit)(ElemType &));//遍历L中的元素,并输出
void print1(ElemType &e);//输出元素
Status ListEmpty(Sqlist L);//判断表是否为空表
void ClearList(Sqlist &L);//将表重置为空表
pc=Lc.elem=(ElemType *)malloc(Lc.listsize*sizeof(ElemType));//分配所需空间
if(!Lc.elem)//存储分配失败
exit(OVERFLOW);
pa_last=La.elem+La.length-1;//pa_last指向最后一个元素
pb_last=Lb.elem+Lb.length-1;//pb_last指向最后一个元素
while(pa<=pa_last&&pb<=pb_last)//表LA和表LB中均有元素没有归并
{
if(*pa<=*pb)
*pc++=*pa++;//将pa所指单元的值赋给pc所指单元后,pa,pc分别加1
{ ElemType *p,*q;
if(i<1||i>L.length) return ERROR;
p=L.elem+i-1;//p为被删除的元素的位置
e=*p;
q=L.elem+L.length-1;//q为表尾的位置
for(++p;p<=q;++p)//被删除之后的元素前移
*(p-1)=*p;