数据结构线性顺序表的C语言实现

合集下载

顺序表c语言的程序代码

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

数据结构经典题目及c语言代码

数据结构经典题目及c语言代码一、线性表1. 顺序表顺序表是一种利用连续存储空间存储元素的线性表。

以下是一个顺序表的经典题目及C语言代码实现：```c#define MaxSize 50typedef struct {int data[MaxSize]; // 存储元素的数组int length; // 顺序表的当前长度} SeqList;// 初始化顺序表void initList(SeqList *L) {L->length = 0;}// 插入元素到指定位置void insert(SeqList *L, int pos, int elem) {if (pos < 1 || pos > L->length + 1) {printf("插入位置无效\n");return;}if (L->length == MaxSize) {printf("顺序表已满，无法插入\n"); return;}for (int i = L->length; i >= pos; i--) { L->data[i] = L->data[i - 1];}L->data[pos - 1] = elem;L->length++;}// 删除指定位置的元素void delete(SeqList *L, int pos) {if (pos < 1 || pos > L->length) {printf("删除位置无效\n");return;}for (int i = pos - 1; i < L->length - 1; i++) {L->data[i] = L->data[i + 1];}L->length--;}// 获取指定位置的元素值int getElement(SeqList *L, int pos) {if (pos < 1 || pos > L->length) {printf("位置无效\n");return -1;}return L->data[pos - 1];}```2. 链表链表是一种利用非连续存储空间存储元素的线性表。

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语言版实验报告

数据结构C语言版实验报告一、实验目的本次实验旨在通过使用 C 语言实现常见的数据结构，加深对数据结构基本概念、原理和操作的理解，提高编程能力和解决实际问题的能力。

二、实验环境操作系统：Windows 10编程环境：Visual Studio 2019编程语言：C 语言三、实验内容1、线性表顺序表的实现与操作链表的实现与操作2、栈和队列栈的实现与应用（表达式求值）队列的实现与应用（模拟排队）3、树和二叉树二叉树的遍历（前序、中序、后序）二叉搜索树的实现与操作4、图图的存储结构（邻接矩阵、邻接表）图的遍历（深度优先搜索、广度优先搜索）四、实验步骤及结果1、线性表顺序表的实现与操作定义顺序表的数据结构，包括数组和表的长度。

实现顺序表的初始化、插入、删除、查找等操作。

测试顺序表的各种操作，输出操作结果。

｀｀｀cinclude ＜stdioh>include ＜stdlibh>define MAX_SIZE 100typedef struct ｛int dataMAX_SIZE;int length;｝ SeqList;／／初始化顺序表void initList(SeqList L) ｛L>length ＝ 0;｝／／插入元素到顺序表int insertList(SeqList L, int pos, int element) ｛if （L>length ＞＝ MAX_SIZE ｜｜ pos ＜ 0 ｜｜ pos ＞ L>length) ｛return 0;｝for （int i ＝ L>length 1; i ＞＝ pos; i) ｛L>datai ＋ 1 ＝ L>datai;｝L>datapos ＝ element;L>length+＋；return 1;｝／／删除顺序表中的元素int deleteList(SeqList L, int pos) ｛if （pos ＜ 0 ｜｜ pos ＞＝ L>length) ｛return 0;｝for （int i ＝ pos; i ＜ L>length 1; i+＋）｛L>datai ＝ L>datai ＋ 1;｝L>length;return 1;｝／／查找顺序表中的元素int searchList(SeqList L, int element) ｛for （int i ＝ 0; i ＜ Llength; i+＋）｛if （Ldatai ＝＝ element) ｛return i;｝｝return －1;｝int main(）｛SeqList L;initList(＆L)；insertList(＆L, 0, 10)；insertList(＆L, 1, 20)；insertList(＆L, 2, 30)；printf(＂顺序表元素: ＂）；for （int i ＝ 0; i ＜ Llength; i+＋）｛printf(＂％d ＂， Ldatai)；｝printf(＂＼n"）；int pos ＝ searchList(L, 20)；if （pos!＝－1) ｛printf(＂元素 20 在顺序表中的位置: ％d\n"， pos)；｝ else ｛printf(＂顺序表中未找到元素 20\n"）；｝deleteList(＆L, 1)；printf(＂删除元素后的顺序表元素: ＂）；for （int i ＝ 0; i ＜ Llength; i+＋）｛printf(＂％d ＂， Ldatai)；｝printf(＂＼n"）；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语⾔实现顺序表的具体代码，供⼤家参考，具体内容如下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);}以上就是本⽂的全部内容，希望对⼤家的学习有所帮助，也希望⼤家多多⽀持。

C语言数据结构线性表的基本操作实验报告

实验一线性表的基本操作一、实验目的与基本要求1．掌握数据结构中的一些基本概念。

数据、数据项、数据元素、数据类型和数据结构，以及它们之间的关系。

2．了解数据的逻辑结构和数据的存储结构之间的区别与联系；数据的运算与数据的逻辑结构的关系。

3．掌握顺序表和链表的基本操作：插入、删除、查找以及表的合并等运算。

4．掌握运用C语言上机调试线性表的基本方法。

二、实验条件1．硬件：一台微机2．软件：操作系统和C语言系统三、实验方法确定存储结构后，上机调试实现线性表的基本运算。

四、实验内容1．建立顺序表，基本操作包括：初始化，建立一个顺序存储的链表，输出顺序表，判断是否为空，取表中第i个元素，定位函数（返回第一个与x相等的元素位置），插入，删除。

2．建立单链表，基本操作包括：初始化，建立一个链式存储的链表，输出顺序表，判断是否为空，取表中第i个元素，定位函数（返回第一个与x相等的元素位置），插入，删除。

3．假设有两个按数据元素值非递减有序排列的线性表A和B，均以顺序表作为存储结构。

编写算法将A表和B表归并成一个按元素值非递增有序（允许值相同）排列的线性表C。

（可以利用将B中元素插入A中，或新建C表）4．假设有两个按数据元素值非递减有序排列的线性表A和B，均以单链表作为存储结构。

编写算法将A表和B表归并成一个按元素值递减有序（即非递增有序，允许值相同）排列的线性表C。

五、附源程序及算法程序流程图1.源程序（1）源程序(实验要求1和3)#include<stdio.h>#include<malloc.h>#include<stdlib.h>#define LIST_INIT_SIZE 100#define LISTINCREMENT 10typedef struct arr{int * elem;int length;int listsize;}Sqlist;void menu(); //菜单void InitList(Sqlist *p); // 创建线性表void ShowList(Sqlist *p); // 输出顺序线性表void ListDelete(Sqlist *p,int i,int &e); // 在顺序线性表中删除第i个元素，并用e返回其值void ListInsert(Sqlist *p); // 在顺序线性表中第i个元素前插入新元素evoid ListEmpty(Sqlist *p); // 判断L是否为空表void GetList(Sqlist *p,int i,int &e); // 用e返回L中第i个数据元素的值void ListInsert(Sqlist *p,int i,int e);bool compare(int a,int b);void LocateElem(Sqlist *L,int e); // 在顺序线性表L中查找第1个值与e满足compare()d元素的位序void MergeList_L(Sqlist *La,Sqlist *Lb); // 归并void main(){Sqlist La;Sqlist Lb;int n,m,x;menu();scanf("%d",&n);while(n){switch(n){case 0: ; break;case 1:InitList(&La);break;case 2:ListEmpty(&La);break;case 3:printf("请输入插入的位序:\n");scanf("%d",&m);printf("请出入要插入的数:\n");scanf("%d",&x);ListInsert(&La,m,x);break;case 4:printf("请输入删除元素的位序:\n");scanf("%d",&m);ListDelete(&La,m,x);printf("删除的元素为:%d\n",x);break;case 5:printf("请输入要找的与线性表中相等的数:\n");scanf("%d",&m);LocateElem(&La,m);break;case 6:printf("请输入查找的位序:\n");scanf("%d",&m);GetList(&La,m,x);printf("La中第%d个元素的值为%d\n",m,x);break;case 7:ShowList(&La);break;case 8:InitList(&Lb);break;case 9:MergeList_L(&La,&Lb);printf("归并成功!");break;}menu();scanf("%d",&n);}}/*菜单*/void menu(){printf("********************\n\n");printf(" 0.退出\n\n");printf(" 1.创建线性表La\n\n");printf(" 2.判断La是否为空表\n\n");printf(" 3.插入元素(La)\n\n");printf(" 4.删除元素(La)\n\n");printf(" 5.定位元素(La)\n\n");printf(" 6.取元素(La)\n\n");printf(" 7.输出线性表\n\n");printf(" 8.创建线性表Lb\n\n");printf(" 9.归并为一个线性表La\n\n");printf("********************\n\n");}/*创建顺序线性表L*/void InitList(Sqlist *L){int n;int i=0;L->elem=(int *)malloc(LIST_INIT_SIZE*sizeof(int));if(NULL==L->elem)printf("储存分配失败!\n");else{L->length=0;L->listsize=LIST_INIT_SIZE;printf("输入顺序表a:\n");scanf("%d",&n);while(n){L->elem[i]=n;i++;L->length++;L->listsize=L->listsize-4;scanf("%d",&n);}}}/*输出顺序线性表*/void ShowList(Sqlist *p){int i;if(0==p->length)printf("数组为空!\n");elsefor(i=0;i<p->length;i++)printf("%d ",p->elem[i]);printf("\n");}/*判断L是否为空表*/void ListEmpty(Sqlist *p)if(0==p->length)printf("L是空表!\n");elseprintf("L不是空表!\n");}/*在顺序线性表中第i个元素前插入新元素e */void ListInsert(Sqlist *p,int i,int e){int *newbase;int *q1;int *q2;while(i<1||i>p->length+1){printf("您输入的i超出范围!\n请重新输入要插入的位置\n:");scanf("%d",&i);}if(p->length>=p->listsize){newbase=(int *)realloc(p->elem,(p->listsize+LISTINCREMENT)*sizeof(int));if(!newbase)exit(0);else{p->elem=newbase;p->listsize+=LISTINCREMENT;}}q1=&(p->elem[i-1]);for(q2=&(p->elem[p->length-1]);q2>=q1;--q2)*(q2+1)=*q2;*q1=e;++p->length;}/*/在顺序线性表中删除第i个元素，并用e返回其值*/void ListDelete(Sqlist *p,int i,int &e){int *q1,*q2;while(i<1||i>p->length){printf("您输入的i超出范围!请重新输入:");scanf("%d",&i);}q1=&(p->elem[i-1]);e=*q1;q2=p->elem+p->length-1;for(++q1;q1<=q2;++q1)*(q1-1)=*q1;--p->length;}/*对比a与b相等*/bool compare(int a,int b){if(a==b)return 1;elsereturn 0;}/*在顺序线性表L中查找第1个值与e满足compare()d元素的位序*/ void LocateElem(Sqlist *L,int e){int i=1;int *p;p=L->elem;while(i<=L->length && !compare(*p++,e))++i;if(i<=L->length)printf("第1个与e相等的元素的位序为%d\n",i);elseprintf("没有该元素!\n");}/*用e返回L中第i个数据元素的值*/void GetList(Sqlist *p,int i,int &e){Sqlist *p1;p1=p;e=p1->elem[i-1];}/* 已知顺序线性表La和Lb是元素按值非递减排列*//* 把La和Lb归并到La上,La的元素也是按值非递减*/void MergeList_L(Sqlist *La,Sqlist *Lb){int i=0,j=0,k,t;int *newbase;Sqlist *pa,*pb;pa=La;pb=Lb;while(i<pa->length && j<pb->length){if(pa->elem[i] >= pb->elem[j]){if(pa->listsize==0){newbase=(int*)realloc(pa->elem,(pa->listsize+LISTINCREMENT)*sizeof(int));if(!newbase)exit(0);}for(k=pa->length-1; k>=i; k--)pa->elem[k+1]=pa->elem[k];pa->length++;pa->elem[i]=pb->elem[j];i++;j++;}elsei++;}while(j<pb->length){if( pa->listsize < pb->length-j ){newbase=(int*)realloc(pa->elem,(pa->listsize+LISTINCREMENT)*sizeof(int));if(!newbase)exit(0);}for(j;j<pb->length;j++,i++){pa->elem[i]=pb->elem[j];pa->length++;}}for(i=0;i<pa->length/2;i++){t=pa->elem[i];pa->elem[i]=pa->elem[pa->length-i-1];pa->elem[pa->length-i-1]=t;}}（2）源程序(实验要求2和4)#include<stdio.h>#include<malloc.h>#include<stdlib.h>typedef struct LNode{int data;struct LNode *next;}LNode, *LinkList;void menu();LinkList InitList();void ShowList(LinkList L);void ListDelete(LinkList L,int i,int &e);void ListEmpty(LinkList L);void GetList(LinkList L,int i,int &e);void ListInsert(LinkList L,int i,int e);bool compare(int a,int b);void LocateElem(LinkList L,int e);LinkList MergeList_L(LinkList La,LinkList Lb);int total=0;void main(){LinkList La;LinkList Lb;La=(LinkList)malloc(sizeof(struct LNode));La->next=NULL;Lb=(LinkList)malloc(sizeof(struct LNode));Lb->next=NULL;int n;int m;int x;menu();scanf("%d",&n);while(n){switch(n){case 0: ; break;case 1:La->next=InitList();break;case 2:ListEmpty(La);break;case 3:printf("请输入要插入到第几个节点前:\n");scanf("%d",&m);printf("请输入插入的数据:\n");scanf("%d",&x);ListInsert(La,m,x);break;case 4:printf("请输入删除元素的位序:\n");scanf("%d",&m);ListDelete(La,m,x);printf("删除的元素为:%d\n",x);break;case 5:printf("请输入要找的与线性表中相等的数:\n");scanf("%d",&m);LocateElem(La,m);break;case 6:printf("请输入查找的位序:\n");scanf("%d",&m);GetList(La,m,x);printf("La中第%d个元素的值为%d\n",m,x);break;case 7:ShowList(La);break;case 8:Lb->next=InitList();break;case 9:La=MergeList_L(La,Lb);printf("归并成功\n");break;}menu();scanf("%d",&n);}}void menu(){printf("********************\n\n");printf(" 0.退出\n\n");printf(" 1.创建线性表La\n\n");printf(" 2.判断是否为空表\n\n");printf(" 3.插入元素\n\n");printf(" 4.删除元素\n\n");printf(" 5.定位元素\n\n");printf(" 6.取元素\n\n");printf(" 7.输出线性表\n\n");printf(" 8.创建线性表Lb\n\n");printf(" 9.归并两线性表\n\n");printf("********************\n\n");}// 创建链式线性表LLinkList InitList(){int count=0;LinkList pHead=NULL;LinkList pEnd,pNew;pEnd=pNew=(LinkList)malloc(sizeof(struct LNode));printf("请输入数据:\n");scanf("%d",&pNew->data);while(pNew->data){count++;if(count==1){pNew->next=pHead;pEnd=pNew;pHead=pNew;}else{pNew->next=NULL;pEnd->next=pNew;pEnd=pNew;}pNew=(LinkList)malloc(sizeof(struct LNode));printf("请输入数据:\n");scanf("%d",&pNew->data);}free(pNew);total=total+count;return pHead;}// 判断L是否为空表void ListEmpty(LinkList L){if(NULL==L->next)printf("此表为空表!\n");elseprintf("此表不为空表!\n");}// 在链式线性表中第i个元素前插入新元素e void ListInsert(LinkList L,int i,int e){LinkList p;LinkList s;p=L;int j=0;while(p&&j<i-1){p=p->next;++j;}if(!p||j>i-1)printf("不存在您要找的节点!\n");else{s=(LinkList)malloc(sizeof(int));s->data=e;s->next=p->next;p->next=s;printf("插入节点成功!\n");}}// 输出链式线性表void ShowList(LinkList L){LinkList p;p=L->next;if(p==NULL)printf("此表为空表!\n");elsewhile(p){printf("%d ",p->data);p=p->next;}printf("\n");}// 在链式线性表中删除第i个元素，并用e返回其值void ListDelete(LinkList L,int i,int &e){LinkList p;LinkList q;p=L;int j=0;while(p->next && j<i-1){p=p->next;++j;}if(!(p->next)||j>i-1)printf("没有找到要删除的位置!");else{q=p->next;p->next=q->next;e=q->data;free(q);}}// 用e返回L中第i个数据元素的值void GetList(LinkList L,int i,int &e){LinkList p;p=L->next;int j=0;while(p->next && j<i-1){p=p->next;++j;}if(!(p)||j>i-1)printf("没有找到要查找的位置!");elsee=p->data;}// 对比a与b相等bool compare(int a,int b){if(a==b)return 1;elsereturn 0;}// 在链式线性表L中查找第1个值与e满足compare()d元素的位序void LocateElem(LinkList L,int e){int i=0;LinkList p;p=L;while(p->next && !compare(p->data,e)){p=p->next;i++;}if(NULL==p->next){if(0==compare(p->data,e))printf("没有该元素!\n");elseprintf("第1个与e相等的元素的位序为%d\n",i);}elseif(compare(p->data,e))printf("没有该元素!\n");}LinkList MergeList_L(LinkList La,LinkList Lb){int i,j,k;LinkList pa_1,pb_1,pa_2,pb_2,pc,pd;pa_1=La->next;pc=pa_2=La;pb_1=pb_2=Lb->next;if(pa_1->data > pb_1->data){pc=pa_2=Lb;pa_1=Lb->next;pb_1=pb_2=La->next;}while(pa_1 && pb_1){if(pa_1->data >= pb_1->data){pa_2->next=pb_1;pb_2=pb_1->next;pb_1->next=pa_1;pb_1=pb_2;pa_2=pa_2->next;}else{pa_1=pa_1->next;pa_2=pa_2->next;}}if(pb_1)pa_2->next=pb_1;pd=(LinkList)malloc(sizeof(struct LNode));pd->next=NULL;pa_2=pd;k=total;for(i=0;i<total;i++){pa_1=pc->next;for(j=1;j<k;j++)pa_1=pa_1->next;pb_1=(LinkList)malloc(sizeof(struct LNode));pa_2->next=pb_1;pa_2=pa_2->next;pa_2->data=pa_1->data;k--;}pa_2->next=NULL;return pd;}2.流程图(实验要求1和3)图1 主函数流程图图2创建线性表La流程图图3判断La是否为空表流程图图4 插入元素(La)流程图图5删除元素(La)流程图图6定位元素(La)流程图图7取元素(La)流程图图8输出线性表流程图图9输出线性表流程图流程图(实验要求2和4)图10主函数流程图图11创建线性表La流程图图12判断是否为空表流程图图13插入元素流程图图14删除元素流程图图15定位元素流程图图图16取元素流程图图17创建Lb流程图图18归并两表流程图六、运行结果1. (实验要求1和3)点击运行，首先出现的是菜单界面，选择菜单选项进行操作，如图所示。

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

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

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

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

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

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

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

新手数据结构（C语言）版线性表简单实例操作

新手数据结构（C语言）版线性表简单实例操作#include //百度ID：yaokong4 写，适合初学数据结构者（其实我也是刚学数据结构，大神匆喷）#include //最好在Microsoft Visual C++6.0上运行，其它软件中可能出错。

typedef struct num //结点的存储结构。

{int data;struct num *next;}linknode,*linklist;menu() //主功能菜单{printf("可供用户选择的功能有:\n");printf("1.创建新的链表。

\n");printf("2.求创建的链表的长度。

\n");printf("3.向已经创建的链表中插入元素。

\n");printf("4.向已经创建的链表中删除元素。

\n");printf("0.退出程序。

\n\n");printf("请用户选择一项功能:");return 0;}linklist createnewlinklist(linklist head) //创建新的单链表。

{linklist p1,p2,top;unsigned int lenlinklist,i=1;printf("\n请输入创建的单链表的长度(>0的整数):");scanf("%d",&lenlinklist);printf("依次输入各元素的数据:\n");p1=p2=head=top=(linklist)malloc(sizeof(linknode));while(i<=lenlinklist){p2=p1; //注意此语句要放在此位置，不可放在以下第4行位置。

scanf("%d",&p2->data);p1=(linklist)malloc(sizeof(linknode));p2->next=p1;i++;}free(p1);p2->next=NULL;printf("——————你创建的单链表为:\n"); //输出链表代码。

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. 顺序表顺序表是一种存储结构，它将元素顺序存放在一块连续的存储区域中。

C语言中常用数组来实现顺序表。

以下是一些常见题目的解答：题目1：已知顺序表中存储了n个整数，请编写一个算法，将这个顺序表中的所有负数挑选出来，并将它们按照原有顺序存放在新的顺序表中。

解答：```#include <stdio.h>#define MAX_SIZE 100int main() {int A[MAX_SIZE], neg[MAX_SIZE];int n, i, j = 0;printf("Enter the number of elements: ");scanf("%d", &n);printf("Enter the elements: ");for (i = 0; i < n; i++) {scanf("%d", &A[i]);if (A[i] < 0) {neg[j] = A[i];j++;}}printf("Negative numbers: ");for (i = 0; i < j; i++) {printf("%d ", neg[i]);}return 0;}```题目2：假设顺序表A和B中的元素递增有序排列，编写一个算法合并这两个顺序表，并使合并后的顺序表仍然递增有序。

解答：```#include <stdio.h>#define MAX_SIZE 100int main() {int A[MAX_SIZE], B[MAX_SIZE], C[MAX_SIZE * 2]; int m, n, i, j, k;printf("Enter the number of elements in the first list: "); scanf("%d", &m);printf("Enter the elements in increasing order: ");for (i = 0; i < m; i++) {scanf("%d", &A[i]);C[i] = A[i];}printf("Enter the number of elements in the second list: "); scanf("%d", &n);printf("Enter the elements in increasing order: ");for (i = 0; i < n; i++) {scanf("%d", &B[i]);C[m + i] = B[i];}// Merge A and B into Ci = j = k = 0;while (i < m && j < n) { if (A[i] < B[j]) {C[k] = A[i];i++;} else {C[k] = B[j];j++;}k++;}while (i < m) {C[k] = A[i];i++;k++;}while (j < n) {C[k] = B[j];j++;k++;}printf("Merged list in increasing order: ");for (i = 0; i < m + n; i++) {printf("%d ", C[i]);}return 0;}```2. 链表链表是一种动态的数据结构，它通过结点之间的指针联系起来。

数据结构实验报告(C语言)顺序表__排序

//冒泡排序 void BubbleSort(SqeList *L){
int i,j,n,x,change; n=L->length; change=1; for(i=1;i<=n-1 && change;++i){
change=0; for(j=1;j<=n-i-1;++j)
if(L->r[j] > L->r[j+1]){ x=L->r[j]; L->r[j]=L->r[j+1]; L->r[j+1]=x; change=1;
void QuickSort(SqeList *L,int low,int high){ int mid; if(low<high){ mid=Partition(L,low,high); QuickSort(L,low,mid-1); QuickSort(L,mid+1,high); }
}
//直接选择排序
printf("\n7-直接选择排序结果为:\n"); SelectSort(&l); PrintList(&l); printf("\n"); printf("\n8-二路归并结果为:\n"); MergeSort(&l);
PrintList(&l); printf("\n"); } else printf("请输入大于 0 的值: "); return 0; }
} else{
MR->r[k]=R->r[j]; ++j; } ++k; } while(i<=mid) MR->r[k++]=R->r[i++]; while(j<=high) MR->r[k++]=R->r[j++]; }

数据结构(C语言版) 线性表详细举例介绍

// La中不存在和 e 相同的数据元素，则插入之
}
} // union
O(ListLength2(Lb))
算法2.1’’
试改变结构, 选用有序表表示集合。
有序表: 其数据元素依值从小到大（非递减）有序排列的线性表。
例如：（2，3，3，5，6，6，6，8，12）
void purge(List &La, List Lb) {
（求数据元素的后继）
初始条件：线性表L已存在。
若cur_e是L的元素，但不是操作结果：
最后一个，则用next_e返回它的后继，否则操作失败， next_e无定义。
GetElem( L, i, &e ) （求线性表中某个数据元素）
线性表L已存在，初始条件：且 1≤i≤LengthList(L)
算法2.1’’
InitList(LA); La_len = ListLength(La); Lb_len =ListLength(Lb); // 求线性表的长度
for (i = 1; i <= Lb_len; i++) { GetElem(Lb, i, e);
// 取Lb中第i个数据元素赋给e
if (ListEmpty(La) || !equal (en, e)) { ListInsert(La, ++La_len, e); 算法2.1’ en = e;
} // La中不存在和 e 相同的数据元素，则插入之
}
}
O(ListLength(Lb))
例2-2 （教材P.20）
归并两个“其数据元素按值非递减有序排列”的线性表 LA 和 LB，求得线性表 LC 也具有同样特性。

数据结构中的,线性表的c语言表示和插入,删除,查找操作程序

数据结构中的,线性表的c语言表示和插入,删除,查找操作程序#include#include#define MaxSize 100typedef struct {int data[MaxSize];int length;} SqList;void InitList(SqList *L) { // 传入的参数用指针L->length = 0;return;}int GetLength(SqList L) {return L.length;}int GetElem(SqList L, int i, int *e) {if (i < 1 || i > L.length){ /*无效的i值*/return 0;}else {*e = L.data[i - 1]; //改变指针的值前面用*return 1;}}int Locate(SqList L, int x) /*按值查找*/{int i = 0;while (L.data[i] != x){ /*查找值为x的第1个结点*/i++;}if (i > L.length){return (0); /*未找到*/}else{return (i+1);}}int InsElem(SqList *L, int x, int i) {int j;if (i < 1 || i > L->length +1){ /*无效的参数i*/return 0;}for (j = L->length; j >= i; j--) { /*将位置为i的结点及之后的结点后移*/ L->data[j] = L->data[j - 1];}L->data[i - 1] = x; /*在位置i处放入x*/L->length++; /*线性表长度增1*/return 1;}int DelElem(SqList *L, int i) {int j;if (i < 1 || i > L->length){ //删除时，i大于线性表的长度return 0;}for (j = i; j < L->length; j++){L->data[j - 1] = L->data[j];}L->length--;return 1;}void DispList(SqList L) {int i;for (i = 1; i <= L.length; i++){printf("%c", L.data[i - 1]);}printf("\n");}int main() {int i;int e;SqList L;InitList(&L); // 参数是指针时，实参应为地址int chr;memset(&L,0,sizeof(L));while ((chr = getchar())!= '\n'){InsElem(&L, chr, L.length+1); //连续插入元素} printf("线性表:");DispList(L);printf("长度:%d\n", GetLength(L));i = 3;GetElem(L, i, &e);printf("第%d个元素:%c\n", i, e);e = 'a';printf("元素%c是第%d个元素\n", e, Locate(L, e));i = 4;printf("删除第%d个元素\n", i);DelElem(&L, i);printf("线性表:");DispList(L);return 0; }。

数据结构顺序表基本运算实现

printf("这些元素分别是：\n");
; //依次打印输出顺序表中的元素
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语言版(题目)

分类：编程思想和算法2012-09-15 22:24 1759 人阅读评论（0）收藏举报如果TCPhashlistJuli 采用线性表的顺序存储结构，则可以随机存取表中任一终端，但插入和删除终端时，需要移动大量元素，巧妙地终端离线不进行删除操作。

数组，存储的元素应该是线性表顺序存储结构的数据结构。

线性表题目类型：线性表在顺序结构上各种操作的实现；线性链表的各种操作；两个或多个线性表的各种操作；循环链表和双向链表；稀疏多项式及其运算在线性表的两种存储结构上的实现。

线性表在顺序结构上各种操作的实现题目1：（线性表顺序存储结构上的操作—Delete ）从顺序存储结构的线性表a 中删除第i个元素起的k个元素。

（《数据结构题集C语言版》P16)题目2：（线性表顺序存储结构上的操作_lnsert ）设顺序表va中的数据元素递增有序。

试写一算法，将x插入到循序表的适当位置上，以保持该表的有序性。

（《数据结构题集C语言版》P17）题目3：（线性表顺序存储结构上的操作_逆置）试写一算法，实现顺序表的就地逆置，即利用原表的存储空间将线性表逆置。

（《数据结构题集C语言版》2.21）线性表线性链表的各种操作题目1:( Insert ）试写一算法，在无头结点的动态单链表上实现线性表的Insert(L,i,b), 并和在带头结点的动态单链表上实现同样操作的算法进行比较。

（《数据结构题集C语音版》P17）题目2：（Delete ）同上题要求，实现线性表操作Delete（L,i）.题目3:已知线性表中的元素以值递增有序排序，并以单链表作为存储结构。

试写一高效算法，删除表中所有值大于mink且小于maxk的元素（若表中存在这样的元素）同时释放被删除结点空间，并分析你的算法的事件复杂度（注意：mink和maxk是给定的两个参变量，它们的值可以和表中的元素相同，也可以不同）。

（《数据结构题集C语言版》P17)题目4：同上题条件，试写一高效算法，删除表中所有值相同的多余元素（使得操作后的线性表所有元素的值均不相同），同是释放被删结点空间，并分析你算法的时间复杂度。

【数据结构】线性表顺序表详解和代码实例

【数据结构】线性表顺序表详解和代码实例线性表(List)是零个或者多个数据元素的有限序列.⾸先它是⼀个序列.⾥⾯的元素是有顺序的,如果有多个元素,除开头和结尾以外的元素都有⼀个前驱和⼀个后继.⽽开头元素只有后继,结尾元素只有前驱.其次线性表是有限的，也就是⾥⾯的元素个数是有限的。

1ADT 线性表（List）2Data3线性表的数据对象集合为{a1, a2, a3, ......, an},每个元素类型为DataType。

4Operation5InitList(L); //初始化线性表6 IsEmptyList(L); //判断线性表是否为空7 ClearList(L); //清空线性表8 GetElemList(L, i, *e); //获取第i个位置的数据9 SearchList(L, e); //查找与数据e相等的元素10 InsertNodeList(L, i, e);//在第i个位置插⼊元素11 DeleteNodeList(L, i, *e);//删除第i个位置的元素，e获取删除元素12 GetLengthList(L); //获取线性表的长度13endADT关于线性表的基本操作就上⾯⼏种，还有⼏个例如线性表的排序，合并，逆序等等操作。

为了⽂章篇幅，就下次再介绍了。

线性表的顺序存储结构，就是指⽤⼀段地址连续的存储单元⼀次存储线性表的数据元素。

学过⾼级语⾔的朋友，相信对数组这玩意⼉都不会陌⽣吧。

数组就是⼀种顺序存储结构。

链式存储结构就是可以⽤⼀组任意的内存单元存储线性表中的元素。

与顺序存储不同的是，这组内存单元可以是连续的，也可以是不连续的。

这就意味着，元素可以存储在内存的任意位置。

正因为如此，在链式结构中，每个元素不仅要存它的信息，还需要存储它后继元素的存储地址。

我们把存储元素信息的域称为数据域，⽽把存储后继元素地址的域称为指针域。

由这两部分共同组成的数据元素ai，则可以称之为节点(Node)。

数据结构——使用C语言版(朱战立)线性表

结点结构如下图示：
数据域指针域或
data next
数据域：存储元素数值数据
指针域：存储直接后继的存
储位置
第二十一页，编辑于星期三：三点分。
(2)头指针、头结点和首元结点的区别
示意图如下：
hea d
头指针
a0
a1
头结点
首元结点
…
an ^
第二十二页，编辑于星期三：三点分。
头指针是指向链表中第一个结点（或为头结点、或为首元结点）的指针；
struct Node *next;
} SLNode
（1）初始化ListInitiate(head)
void ListInitiate(SLNode **head)
{ *head = (SLNode *)malloc(sizeof(SLNode));
(*head)->next = NULL;
}
第三十页，编辑于星期三：三点分。
L->list[j] = L->list[j-1];
L->list[i] = x;
L->size ++;
return 1;
}
}
第八页，编辑于星期三：三点分。
0
1
2
3
4
5
list
10
11
12
14
15
16
6
7
... MaxSize-1
i=3
size=6
0
1
2
3
4
5
6
7
list
10
11 i=3 12
13
(1)单链表中构成链表的结点只有一个指向直接后继结点的指针域。其结构特点：逻辑上相邻的数据元素在物理上不一定相邻。

数据结构实验 C语言版线性表__C版

17
2. 求表长
L.length
3. 取第i个元素
L.elem[i-1]
(0<i<L.length+1)
18
4. 元素定位操作
分析：依次取出每个元素和给定值进行比较 int LocateElem_Sq (SqList L, ElemType e, Status (*compare)(ElemType, ElemType))
6. 删除操作
线性表的删除运算是指将表的第i(1≦i≦n)个元素删除，使长度为n的线性表： (a1，…a i-1，ai，a i+1…，an) 变成长度为n-1的线性表 (a1，…a i-1，a i+1，…，an)
操作步骤： ① 判断线性表是否为空 ② 判断i值是否合法：1≦i≦n ③ 元素前移 ④ 表长减1
2
线性结构：数据元素之间存在1对1的关系。四个特征： ① 存在惟一的一个“第一元素” ② 存在惟一的一个“最后元素” ③ 除最后元素外，其它元素均有惟一的“后继” ④ 除第一元素外，其它元素均有惟一的“前驱”
3
2.1 线性表的类型定义
一.定义
线性表(Linear List) ：由n(n≧0)个数据元素组成的有限序列。记作： (a1，a2，…an) 其中数据元素的个数n定义为表的长度。当n=0时称为空表这里的数据元素ai(1≦i≦n)只是一个抽象的符号，其具体含义在不同的情况下可以不同。例1、26个英文字母组成的字母表（A，B，C、…、Z）例2、某校从1978年到1983年各种型号的计算机拥有量的变化情况。 4 （6，17，28，50，92，188）
思考：若要直接查相等的呢？
19
5. 插入操作
线性表的插入运算是指在表的第i(1≦i≦n+1)个位置上，插入一个新元素e，使长度为n的线性表(a1，…a i-1，ai，…，an) 变成长度为n+1的线性表 (a1，…a i-1，e，ai，…，an) 操作步骤： ① 判断i是否符合要求：1≦i≦n+1 ② 判断表长是否溢出 ③ 元素右移 ④ 插入 ⑤ 表长增1

数据结构实验C语言版

数据结构实验C语言版数据结构实验C语言版文档一、实验目的本实验旨在通过实践操作，加深对C语言中数据结构的理解，掌握常用数据结构的实现方法，提高编程能力。

二、实验内容本实验共包含以下几个章节：1.线性表1.1 顺序表的实现1.2 链表的实现1.3 环形链表的实现2.栈与队列2.1 栈的实现2.2 队列的实现3.树与图3.1 二叉树的实现与遍历3.2 图的实现与遍历4.排序与查找4.1 冒泡排序4.2 快速排序4.3 二分查找5.其他常用数据结构5.1 哈希表5.2 AVL树5.3 并查集三、实验步骤1.线性表1.1 顺序表的实现- 定义顺序表结构体 - 初始化顺序表- 插入元素- 删除元素- 查找元素1.2 链表的实现- 定义链表结构体- 初始化链表- 插入节点- 删除节点- 查找节点1.3 环形链表的实现- 定义环形链表结构体 - 初始化环形链表- 插入节点- 删除节点- 查找节点2.栈与队列2.1 栈的实现- 定义栈结构体- 初始化栈- 入栈操作- 出栈操作- 获取栈顶元素2.2 队列的实现- 定义队列结构体- 初始化队列- 入队操作- 出队操作- 获取队首元素3.树与图3.1 二叉树的实现与遍历 - 定义二叉树结构体 - 创建二叉树- 先序遍历- 中序遍历- 后序遍历3.2 图的实现与遍历- 定义图结构体- 创建图- 广度优先搜索- 深度优先搜索4.排序与查找4.1 冒泡排序- 实现冒泡排序算法- 对数组进行排序4.2 快速排序- 实现快速排序算法- 对数组进行排序4.3 二分查找- 实现二分查找算法- 在有序数组中查找指定元素5.其他常用数据结构5.1 哈希表- 定义哈希表结构体- 初始化哈希表- 插入元素- 删除元素- 查找元素5.2 AVL树- 定义AVL树结构体- 插入节点- 删除节点- 查找节点5.3 并查集- 定义并查集结构体- 初始化并查集- 合并集合- 查找根节点四、附件本文档未涉及附件。