顺序表基本操作(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;}。

顺序表的基本操作

四、程序流程：
采用的数据描述为：顺序表在C语言中用一维数组表示。
（1）定义线性表
#define MAXLEN 50/*线性表的最大长度*/
typedef struct{int elem[MAXLEN];/*顺序表中存放元素的数组*/
int last;/*顺序表的长度，即元素个数*/
}Sqlisttp;
3.对顺序表进行元素的删除操作
三、实验步骤：
1）输入一个顺序表，并输出，验证输入的内容与输出的内容是否一致。
2）实现顺序表的插入操作（在第I个元素之前插入一个元素，即将线性表中从第I个元素开始的所有元素依次后移一个位置，以便腾空一个位置，再把新元素插入到该位置）。
3）实现顺序表的删除操作（删除第I个元素，即把第I个元素之后的所有元素前移一个位置）。
st--;}/*顺序表V的长度减1*/
return V;}
（4）顺序表元素输出函数
void display(Sqlisttp V)
{ int j;
for(j=0;j<=st-1;j++) printf("%d ",V.elem[j]);
printf("\n"); }
（5）主函数
main()
return V;}
（3）在顺序表V中删除第i个元素
Sqlisttp delete(Sqlisttp V,int i)
{int j;
if(i<1||i>st) printf("ERROR!");/*删除位置不正确则出错*/
else { for(j=i;j<=st-1;j++)
V.elem[j-1]=V.elem[j];/*将第i+1个元素及后继元素位置向前移一位*/

顺序表基本操作

顺序表基本操作顺序表是一种常见的数据结构，用于存储一组具有顺序关系的元素。

它在计算机科学中有着广泛的应用，例如在数据库中存储表格数据、在编程语言中存储数组等。

顺序表的基本操作包括插入、删除、查找、修改和遍历等。

我们来介绍插入操作。

插入操作可以向顺序表中的指定位置插入一个新元素。

具体步骤如下：1. 判断顺序表是否已满，如果已满则进行扩容操作；2. 将插入位置之后的元素依次后移，为新元素腾出位置；3. 将新元素插入到指定位置。

接下来是删除操作。

删除操作可以从顺序表中删除指定位置的元素。

具体步骤如下：1. 判断删除位置是否合法，如果不合法则抛出异常；2. 将删除位置之后的元素依次前移，覆盖被删除的元素；3. 更新顺序表的长度。

然后是查找操作。

查找操作可以根据指定条件在顺序表中查找元素。

常见的查找方式有按值查找和按索引查找。

具体步骤如下：1. 按值查找：从顺序表的第一个元素开始，依次比较每个元素的值，直到找到目标元素或遍历完整个顺序表；2. 按索引查找：直接根据索引获取对应位置的元素。

接着是修改操作。

修改操作可以修改顺序表中指定位置的元素的值。

具体步骤如下：1. 判断修改位置是否合法，如果不合法则抛出异常；2. 根据指定位置找到对应的元素；3. 修改元素的值。

最后是遍历操作。

遍历操作可以依次访问顺序表中的每个元素。

具体步骤如下：1. 从顺序表的第一个元素开始，依次访问每个元素；2. 根据需要进行相应的操作，例如输出元素的值或对元素进行其他处理。

顺序表的基本操作可以通过编程语言实现。

下面是一个使用Python 语言实现顺序表的例子：```pythonclass SeqList:def __init__(self, capacity):self.data = [None] * capacityself.length = 0def insert(self, index, value):if self.length == len(self.data):self._expand()for i in range(self.length, index, -1):self.data[i] = self.data[i-1]self.data[index] = valueself.length += 1def delete(self, index):if index < 0 or index >= self.length:raise IndexError("Index out of range") for i in range(index, self.length-1):self.data[i] = self.data[i+1]self.length -= 1def search_by_value(self, value):for i in range(self.length):if self.data[i] == value:return ireturn -1def search_by_index(self, index):if index < 0 or index >= self.length:raise IndexError("Index out of range") return self.data[index]def modify(self, index, value):if index < 0 or index >= self.length:raise IndexError("Index out of range") self.data[index] = valuedef traverse(self):for i in range(self.length):print(self.data[i], end=" ")print()def _expand(self):new_data = [None] * (2 * len(self.data)) for i in range(self.length):new_data[i] = self.data[i]self.data = new_data# 测试代码seq_list = SeqList(5)seq_list.insert(0, 1)seq_list.insert(1, 2)seq_list.insert(2, 3)seq_list.traverse() # 输出：1 2 3seq_list.delete(1)seq_list.traverse() # 输出：1 3print(seq_list.search_by_value(3)) # 输出：1print(seq_list.search_by_index(1)) # 输出：3seq_list.modify(1, 4)seq_list.traverse() # 输出：1 4```通过以上代码，我们可以看到顺序表的基本操作是如何实现的。

实验1顺序表和链表基本操作(学生)

实验一线性表运算的实现班级学号姓名一、实验预备知识1．复习C中函数的相关内容。

2．复习如何用主函数将多个函数连在一起构成一个C完整程序。

3．复习多文件结构。

二、实验目的1．掌握线性表的顺序和链式存储结构2．熟练运用线性表在顺序存储方式下的初始化、创建、输出、插入和删除运算3．熟练运用线性表在链式存储方式下的创建、输出、插入和删除运算三、实验要求1．编写初始化并创建线性表和输出线性表的算法。

2．编写对线性表插入和删除运算算法，要判断位置的合法性和溢出问题。

3．编写有序表的插入和删除运算算法。

4．编写一个主函数，将上面函数连在一起，构成一个完整的程序。

5．将实验源程序调试并运行，写出输入、输出结果，并对结果进行分析。

四、实验内容顺序表实验内容：1．给定的线性表为L=（12，25，7，42，19，38），元素由键盘输入。

2．初始化并建立顺序表。

（开辟的存储空间大小为8）3．编写顺序表输出算法。

4．依次插入3，21，15三个数，分别插入在第4，6和2位置，每插入一次都要输出一次顺序表。

5．删除第5，第3和第12个位置上的元素，每删除一个元素都要输出一次顺序表。

6．编写一个排序算法，对线性表中元素从小到大排列。

7．向有序表分别插入20和50，插入后表仍然有序。

（修改开辟的存储空间大小为15）单链表实验内容：1．给定的线性表为L=（12，25，7，42，19，38），元素由键盘输入。

2．建立一个带表头结点的单链表（前插入法和尾插入法都可以）。

3．编写单链表输出算法。

4．依次插入3，21，15三个数，分别插入在第4，6和12位置，每插入一次都要输出一次单链表。

5．删除第5，第3和第12个位置上的元素，每删除一个元素都要输出一次单链表。

6．编写一个排序算法，对线性表中元素从小到大排列。

7．分别删除值为25和42的元素，删除后表仍然有序。

五、实验结果给出程序清单及输入/输出结果六、总结1．实验过程中遇到的问题及解决方法2．收获北华航天工业学院《数据结构》课程实验报告实验题目：作者所在系部：作者所在专业：作者所在班级：作者学号：作者姓名：任课教师姓名：完成时间：北华航天工业学院教务处制一、实验目的1 掌握线性表的顺序和链式存储结构；2 熟练运用线性表在顺序存储方式下的初始化、创建、输出、插入和删除运算；3 熟练运用线性表在链式存储方式下的创建、输出、插入和删除运算。

数据结构(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. 单链表单链表是一种常见的链式存储结构，每个节点包含数据和指向下一个节点的指针。

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语言实现顺序表的基本操作（从键盘输入生成线性表，读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看懂了左⼿给你个栗⼦，给我关注点赞；看不懂右⼿给你个锤⼦，砸开脑壳看看有没有带脑⼦。

顺序表的基本操作与应用实验报告

实验报告课程名称数据结构实验名称顺序表基本操作与应用姓名专业班级学号试验日期试验地点E3-502指导老师邹汉斌成绩一、实验目的1.学会定义线性表的顺序存储类型，实现C程序的基本结构，对线性表的一些基本操作和具体的函数定义。

2.掌握顺序表的基本操作，实现顺序表的插入、删除、查找以及求并集等运算。

3.掌握对多函数程序的输入、编辑、调试和运行过程。

二、实验要求1．预习C语言中结构体的定义与基本操作方法。

2．对顺序表的每个基本操作用单独的函数实现。

3．编写完整程序完成下面的实验内容并上机运行。

4．整理并上交实验报告。

三、实验内容：1．编写程序实现顺序表的下列基本操作：(1) 初始化顺序表La；(2) 将La置为空表；(3) 销毁La (4) 在La中插入一个新的元素；(5) 删除La中的某一元素；(6) 在La中查找某元素，若找到，则返回它在La中第一次出现的位置，否则返回0 ；(7) 打印输出La中的元素值。

2．定义一个包含学生信息（学号，姓名，成绩）的顺序表，使其具有如下功能：(1) 根据指定学生个数，逐个输入学生信息；(2) 逐个显示学生表中所有学生的相关信息；(3) 根据姓名进行查找，返回此学生的学号和成绩；(4) 根据指定的位置可返回相应的学生信息（学号，姓名，成绩）；(5) 给定一个学生信息，插入到表中指定的位置；(6) 删除指定位置的学生记录；(7) 统计表中学生个数。

实验提示：第2题可在第1题的基础上将数据结构的定义修改成下面形式后，程序适当修改即可。

学生信息的定义：typedef struct {char no[8]; //8位学号char name[20]; //姓名int score; //成绩}Student;typedef Student ElemType;顺序表的定义typedef struct {ElemType *elem; //指向数据元素的基地址int length; //线性表的当前长度}SqList；四、思考与提高1.编写程序完成下面的操作：（每位同学必做）(1)构造两个顺序线性表La和Lb，其元素都按值非递减顺序排列；(2)实现归并La和Lb得到新的顺序表Lc，Lc的元素也按值非递减顺序排列；(3)假设两个顺序线性表La和Lb 分别表示两个集合A和B，利用union_Sq操作实现A=A∪B。

用C语言实现顺序表的基本操作

return ret; }
/******* *************************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);

实验1线性表的基本操作

实验一线性表的基本操作一、线性结构的顺序表基本操作实验目的1.学会定义单链表的结点类型、线性表的顺序存储类型，实现C程序的基本结构，对线性表的一些基本操作和具体的函数定义。

2.掌握顺序表的基本操作，实现顺序表的插入、删除、查找以及求并集等运算。

3.掌握对多函数程序的输入、编辑、调试和运行过程。

实验要求1．预习C语言中结构体的定义与基本操作方法。

2．对顺序表的每个基本操作用单独的函数实现。

3．编写完整程序完成下面的实验内容并上机运行。

实验内容1．编写程序实现顺序表的下列基本操作：(1)初始化顺序表La。

(2)将La置为空表。

(3)销毁La。

(4)在La中插入一个新的元素。

(5)删除La中的某一元素。

(6)在La中查找某元素，若找到，则返回它在La中第一次出现的位置，否则返回0。

(7)打印输出La中的元素值。

2．（选做）编写程序完成下面的操作：(1)构造两个顺序线性表La和Lb，其元素都按值非递减顺序排列。

(2)实现归并La和Lb得到新的顺序表Lc，Lc的元素也按值非递减顺序排列。

(3)假设两个顺序线性表La和Lb分别表示两个集合A和B，利用union_Sq操作实现A=A∪B。

二、单链表基本操作(选做)实验目的1. 学会定义单链表的结点类型、线性表的链式存储类型，实现对单链表的一些基本操作和具体的函数定义，了解并掌握单链表的类定义以及成员函数的定义与调用。

2. 掌握单链表基本操作及两个有序表归并、单链表逆置等操作的实现。

实验要求1．预习C语言中结构体的定义与基本操作方法。

2．对单链表的每个基本操作用单独的函数实现。

3．编写完整程序完成下面的实验内容并上机运行。

实验内容1．编写程序完成单链表的下列基本操作：(1)初始化单链表La。

(2)在La中插入一个新结点。

(3)删除La中的某一个结点。

(4)在La中查找某结点并返回其位置。

(5)打印输出La中的结点元素值。

2．构造一个单链表L，其头结点指针为head，编写程序实现将L逆置。

实验一顺序表的基本操作实验报告

元素之后的所有数据都前移一个位置，最将线性表长减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 #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 }。

顺序表的基本操作

2.输入5个数，分别为1,2,3,4,5
3.求线性表是否为空：
4.求线性表的长度：
5.输出顺序表的第4个元素：
6.输出第一次出现元素3的位置：
7.向线性表中插入一个元素：
8.删除元素4，并输出
9.输出线性表的元素：
10.在线性表的-1位置插入数据：
11.清空线性表的所有元素
五、实验总结
1.由于线性表是采用的是数组存储，因此，在第i个位置添加或删除
一个元素时，需要移动n-i个位置，其时间复杂度为O(n)
2.顺序表的删除并非真正意义的删除，由于数组的特殊原因，只是
显示的一种“假象”，如果采用动态的扩展空间，可以实现真正意。

c语言的优先级顺序表

c语言的优先级顺序表
C语言的运算符优先级顺序如下：
1. 括号(Parentheses)
2. 一元运算符(Unary Operators)
3. 乘法运算符*、除法运算符/、求余运算符%
4. 加法运算符+、减法运算符-
5. 移位运算符<<、>>
6. 大于运算符>、大于等于运算符>=、小于运算符<、小于等于运算符<=
7. 等于运算符==、不等于运算符!=
8. 按位与运算符&
9. 按位异或运算符^
10. 按位或运算符|
11. 逻辑与运算符&&
12. 逻辑或运算符||
13. 三目条件运算符? :
14. 赋值运算符=、+=、-=、*=、/= 等
15. 逗号运算符,
注意：尽管这个顺序大致上是对的，但是不同的编译器可能会有些许的差异，所以建议在编写代码时始终使用括号来明确优先级。

数据结构c++顺序表、单链表的基本操作,查找、排序代码

实验1：顺序表的基本操作实验2：单链表的基本操作实验3：查找实验4：排序实验1代码及结果：#include <iostream>using namespace std;template <class T>class sq_LList{private:int mm;int nn;T *v;public:sq_LList(){mm=0;nn=0;return;}sq_LList(int);void prt_sq_LList();int flag_sq_LList();void ins_sq_LList(int,T);void del_sq_LList(int);};//建立空顺序表template <class T>sq_LList<T>::sq_LList(int m){mm=m;v=new T[mm];nn=0;return;}//顺序输出顺序表中的元素与顺序表长度template <class T>void sq_LList<T>::prt_sq_LList(){int i;cout<<"nn="<<nn<<endl;for(i=0;i<nn;i++)cout<<v[i]<<endl; return;}//检测顺序表的状态template <class T>int sq_LList<T>::flag_sq_LList(){if(nn=mn)return(-1);if(nn=0)return(0);return (1);}//在表的指定元素前插入新元素template<class T>void sq_LList<T>::ins_sq_LList(int i,T b){int k;if(nn==mm){cout<<"overflow"<<endl;return;}if(i>nn)i=nn+1;if(i<1)i=1;for(k=nn;k>=i;k--)v[k]=v[k-1];v[i-1]=b;nn=nn+1;return ;}//在顺序表中删除指定元素template<class T>void sq_LList<T>::del_sq_LList(int i){int k;if(nn==0){cout<<"underflow!"<<endl;return;}for(k=i;k<nn;k++)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;}运行及结果：实验2代码#include<iostream>#include<iomanip>using namespace std;struct node{float data;node *next;};node *create(){ //建立单链表node *head,*p,*s;head=new node;p=head;p->data=0;p->next=0; //表头创建完成float newnum=0;cin>>newnum;if(newnum<0){cout<<"未输入数据...\n";//输入负数则结束system("pause");}while(newnum>=0 ){ //??如何用字符型作为结束标志s=new node; //创建表中数据s->data=newnum;p->next=s;p=s;cin>>newnum;}p->next=NULL; //最后元素指针return(head); //返回空表头}//插入一个结点x，将成为第i个节点void insertnode(node *head,int i,float x){node *s,*p;int j;s=new node;s->data=x;p=head;j=1; //查找第i个结点，由p指向while(p!=NULL && j<i){j++;p=p->next;}s->next=p->next;p->next=s;}//删除结点xvoid deletenode(node *head,float x){node *p,*s;if(head->next==NULL)cout<<"这是空链表,不能执行删除操作\n"; else{s=head;p=head->next;while(p!=NULL && p->data!=x)if(p->data!=x){s=p;p=p->next;}if(p!=NULL){s->next=p->next;delete(p);}else cout<<"未找到!\n";}}//存取链表某节点Kvoid read(node*head,int k){while(head->next!=0&&k>0){head=head->next;k--;}cout<<"该处数据为"<<head->data<<".\n\n"; }int main( ) {node *linktable=0;int choice=1;cout<<"1.创建链表\n";cout<<"2.显示信息\n";cout<<"3.删除信息\n";cout<<"4.查找信息\n";cout<<"5.插入信息\n";cout<<"6.读取信息\n";cout<<"0.退出程序\n";cout<<"请输入您的选择：";cin>>choice;while(1){switch (choice){case 0: exit(0);case 1:{cout<<"输入正数数据，并以负数作为结束标记\n";linktable=create();break;}case 2:{cout<<"链表长度为"<<length(linktable)<<",详细信息：\n";printlist(linktable);break;}case 3:{cout<<"要删除的数据为？\n";float del;cin>>del;deletenode(linktable,del);break;}case 4:{if(linktable->next==0)cout<<"链表为空，不能查找\n";else{cout<<"要查找数据为?";float search;cin>>search;find(linktable,search);} break;}case 5:{cout<<"存储数据为？";int des;float it;cin>>it;cout<<"想让该数据存储为第几个节点？";cin>>des;if((des>(length(linktable)+1)||des<1))cout<<"输入错误\n";elseinsertnode(linktable,des,it);break;}case 6:{cout<<"想读取第几个节点？";int c;cin>>c;if(c<1||c>length(linktable))cout<<"位置不合法\n";elseread(linktable,c);break;}default :cout<<"输入错误!\n";}system("pause");system("cls");cout<<"当前信息：\n";printlist(linktable);cout<<"\n1.创建链表\n";cout<<"2.显示信息\n";cout<<"3.删除信息\n";cout<<"4.查找信息\n";cout<<"5.插入信息\n";cout<<"6.读取信息\n";cout<<"0.退出程序\n";cout<<"继续选择：\n";cin>>choice;}return 0;}实验三查找实验名称：实验3 查找实验目的：掌握顺序表和有序表的查找方法及算法实现；掌握二叉排序树和哈希表的构造和查找方法。

c++有序顺序表的建立与基本操作

c++有序顺序表的建立与基本操作【C++有序顺序表的建立与基本操作】一、引言在C++编程中，有序顺序表是非常常见的数据结构之一。

它可以帮助我们存储和操作一组有序的数据，是程序中非常实用的工具。

本文将从有序顺序表的概念入手，逐步深入探讨其建立和基本操作，帮助读者更好地理解和运用这一数据结构。

二、有序顺序表的概念有序顺序表是一种线性表，其中元素按照一定的顺序排列。

在C++中，我们通常使用数组来实现有序顺序表。

通过数组，我们可以轻松地存储一组有序的数据，并且可以方便地进行各种基本操作，如插入、删除、查找等。

三、有序顺序表的建立1. 定义结构体或类我们需要定义一个结构体或类，用于表示有序顺序表。

结构体或类中应包含元素存储的数组，以及记录当前元素个数和表长的变量。

2. 初始化在建立有序顺序表时，我们需要对其进行初始化。

可以通过动态内存分配来分配数组空间，并对其他变量进行初始化。

需要注意的是，数组的大小应该根据实际需要进行调整，以防止空间浪费。

3. 插入元素在有序顺序表中插入元素是一个常见的操作。

当插入元素时，我们需要保持顺序表的有序性。

可以通过比较元素大小的方式，找到合适的位置并将元素插入其中。

四、有序顺序表的基本操作1. 插入操作有序顺序表的插入操作是比较常见的操作之一。

当我们需要向顺序表中插入新元素时，我们首先需要找到合适的位置，然后将其插入其中。

2. 删除操作删除操作是有序顺序表中另一个重要的操作。

当我们需要删除某个元素时，我们可以通过查找元素的方式找到需要删除的元素，然后将其后的元素向前移动，从而达到删除的目的。

3. 查找操作有序顺序表中的查找操作也是常见的操作之一。

当我们需要查找某个元素时，可以通过顺序查找或二分查找的方式进行查找，以获取所需的元素。

五、个人观点和理解有序顺序表是C++编程中非常常见的数据结构之一。

它能够帮助我们高效地存储和操作数据，是程序中的重要工具。

在实际应用中，我们需要灵活地运用有序顺序表的建立和基本操作，以解决实际问题。

《数据结构》实验指导书(C语言版)(浦江学院)

实验1: 顺序表的操作实验一、实验名称和性质二、实验目的1．掌握线性表的顺序存储结构的表示和实现方法。

2．掌握顺序表基本操作的算法实现。

3．了解顺序表的应用。

三、实验内容1．建立顺序表。

2．在顺序表上实现插入、删除和查找操作（验证性内容）。

3．删除有序顺序表中的重复元素（设计性内容）。

四、实验的软硬件环境要求硬件环境要求：PC机（单机）使用的软件名称、版本号：Windows环境下的VC++6.0五、知识准备前期要求熟练掌握了C语言的编程规则、方法和顺序表的基本操作算法。

六、验证性实验1．实验要求编程实现如下功能：（1）根据输入顺序表的长度n和各个数据元素值建立一个顺序表，并输出顺序表中各元素值，观察输入的内容与输出的内容是否一致。

（2）在顺序表的第i个元素之前插入一个值为x的元素，并输出插入后的顺序表中各元素值。

（3）删除顺序表中第i个元素，并输出删除后的顺序表中各元素值。

（4）在顺序表中查找值为e的数据元素，如果查找成功，则显示“查找成功”和该元素在顺序表中的位置，否则显示“查找失败”。

2. 实验相关原理线性表的顺序存储结构称为顺序表，顺序表的存储结构描述为：#define MAXLEN 30 /*线性表的最大长度*/typedef struct{Elemtype elem[MAXLEN]; /*顺序表中存放元素的数组，其中elemtype为抽象数据类型，在程序具体实现时可以用任意类型代替*/int length; /*顺序表的长度，即元素个数*/}Sqlist; /*顺序表的类型*/【核心算法提示】（1）顺序表插入操作的基本步骤：要在顺序表中的第i个数据元素之前插入一个数据元素x,首先要判断插入位置i是否合法，假设线性表的表长为n，则i的合法值范围：1≤i ≤n+1，若是合法位置，就再判断顺序表是否满，如果满，则增加空间或结束操作，如果不满，则将第i个数据元素及其之后的所有数据元素都后移一个位置，此时第i个位置已经腾空，再将待插入的数据元素x插入到该位置上，最后将线性表的表长增加1。

实验一顺序表的基本操作1

实验⼀顺序表的基本操作1实验⼀：顺序表的基本操作⼀、实验⽬的1．掌握线性表的顺序存储结构的表⽰和实现⽅法。

2．掌握顺序表基本操作的算法实现。

3．了解顺序表的应⽤。

⼆、实验环境硬件环境要求：PC 机（单机）使⽤的软件名称、版本号以及模块：Visual C++ 6.0 或 Turbo C 或 Win-TC 等。

三、实验内容编写⼀个程序，实现顺序表的各种基本运算（假设顺序表的元素类型为 char），并在此基础上设计⼀个主程序完成如下功能：（1）初始化顺序表L;（2）依次采⽤尾插法插⼊a、b、c、d、e元素;（3）输出顺序表L;（4）输出顺序表L的长度；（5）判断顺序表L是否为空；（6）输出顺序表L的第3个元素；（7）输出元素a的位置；（8）在第4个元素位置上插⼊f元素；（9）输出顺序表L；（10）删除L的第3个元素；（11）输出顺序表L；（12）释放顺序表L;四、实验要求1、⽤ Visual C++ 6.0 或 Turbo C 或 Win-TC ⼯具创建⽂件或程序，输⼊代码后，进⾏编译运⾏或在控制台执⾏。

2、观看程序运⾏结果，并根据结果进⾏思考，对程序进⾏修改和总结。

3、请在实验报告上写上实验要求、规范的程序代码、运⾏结果和你的总结体会。

【核⼼算法提⽰】1．顺序表插⼊操作的基本步骤：要在顺序表中的第 i 个数据元素之前插⼊⼀个数据元素 x，⾸先要判断插⼊位置 i 是否合法，假设线性表的表长为 n，则 i 的合法值范围：1≤i≤n+1，若是合法位置，就再判断顺序表是否满，如果满，则增加空间或结束操作，如果不满，则将第 i 个数据元素及其之后的所有数据元素都后移⼀个位置，此时第 i 个位置已经腾空，再将待插⼊的数据元素 x 插⼊到该位置上，最后将线性表的表长增加 1。

2．顺序表删除操作的基本步骤：要删除顺序表中的第 i 个数据元素，⾸先仍然要判断i 的合法性，i 的合法范围是1≤i≤n，若是合法位置，则将第i 个数据元素之后的所有数据元素都前移⼀个位置，最后将线性表的表长减 1。

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 的适合地点上，以保持次序表的有序性。

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)。

ห้องสมุดไป่ตู้
//----------主函数--------------------------int main() { int choice=0; int i; SqList L; ElemType e; InitList_Sq(L); cout<<"选项："<<endl <<"1、创建"<<endl <<"2、查找"<<endl <<"3、删除"<<endl <<"4、插入"<<endl <<"5、退出"<<endl <<"请选择："; while(choice!=5) { cin>>choice; switch(choice) {
for(i=0;i<n;i++) cin>>L.elem[i]; L.length=n; return OK; } //----------查找-----------------------int LocateElem_Sq(SqList L,ElemType e) { for(int i=0;i<L.length;i++) if(L.elem[i]==e) return i+1; return 0; } //-----------插入-----------------------Status ListInsert_Sq(SqList &L,int i,ElemType e) { //在顺序表 L 中的第 i 个位置之前插入新的元素 e //i 值的合法范围是 1<=i<=L.length+1 if(i<1||i>L.length+1) return ERROR;//i 值不合法 if(L.length==MAXSIZE) return ERROR;//当前存储空间已满 for(j=L.length-1;j>=i-1;j--) L.elem[j+1]=L.elem[j];//插入位置及之后的元素后移 L.elem[i-1]=e;//将新元素 e 放入第 i 个位置 ++L.length;//表长增 1 return OK; } //-----------删除第 i 个元素-------------------------Status ListDelete_Sq(SqList &L,int i,ElemType &e) { //在顺序表 L 中删除第 i 个元素，并用 e 返回其值 //i 的值的合法范围是 1<=i<=L.length if((i<1)||(i>L.length)) return ERROR; e=L.elem[i-1];//将欲删除的元素保留在 e 中 for(j=i;j<=L.length-1;j++) L.elem[j-1]=L.elem[j]; --L.length; return OK; }
} case 5: return 0; default: break; } cout<<"请选择："; } return 0; }
#include<iostream> using namespace std; int OVERFLOW=-2; int ERROR=0; int OK=1; int j; //---------顺序表的存储结构---------#define MAXSIZE 10 //当前顺序表可能达到的最大长度 #define LISTINCREMENT 5 typedef int ElemType; typedef int Status; typedef struct { ElemType *elem;//存储空间的基地址 int length;//当前长度,表中有多少个元素 int listsize; }SqList; //----------初始化-------------------Status InitList_Sq(SqList &L) { //构造一个空的顺序表 L L.elem=new ElemType[MAXSIZE];//为顺序表分配一个大小为 MAXSIZE 的数组空间 if(!L.elem) exit(OVERFLOW);//存储空间分配失败 L.listsize=MAXSIZE; L.length=0;//空表的长度为 0 return OK; } //----------建立-----------------------Status Build_Sq(SqList &L) { int i,n; cout<<"请输入要建立的顺序表的中元素的个数："<<endl; cin>>n; if(n>MAXSIZE)//如果 n 的值大于当前空间 { L.elem=new ElemType[n+LISTINCREMENT]; if(!L.elem) exit(OVERFLOW); L.listsize=n+LISTINCREMENT; } cout<<"请输入这 n 个元素："<<endl;
case 1: Build_Sq(L); break; case 2: int n; cout<<"值为："; cin>>e; n=LocateElem_Sq(L,e); cout<<"该元素的位置："<<n<<endl; break; case 3: { int choice1; cout<<"1、删除第 i 个元素"<<endl <<"2、删除元素为 e 的元素"<<endl <<"请选择："; cin>>choice1; switch(choice1) { case 1: cout<<"元素位置："; cin>>i; ListDelete_Sq(L,i,e); cout<<e<<"被删除"<<endl; break; case 2: cout<<"元素值为："; cin>>e; ListDel_Sq(L,e); cout<<e<<"被删除"<<endl; break; default: break; } break; } case 4: { cout<<"位置："; cin>>i; cout<<"值为："; cin>>e; ListInsert_Sq(L,i,e); break;
//-----------删除值为 e 的结点----------------------Status ListDel_Sq(SqList &L,int e) { int j; int temp=0; for(int i=0;i<L.length;i++) { if(L.elem[i]==e) { j=i+1; for(int k=j;k<=L.length-1;j++) L.elem[j-1]=L.elem[j]; --L.length; i--; temp=1; } } if(temp==0) cout<<"没有该元素"<<endl; return OK; }