您的位置：360文档中心› 顺序表的基本操作

顺序表的基本操作

合集下载

java顺序表的基本操作代码

java顺序表的基本操作代码

Java顺序表的基本操作代码一、什么是顺序表顺序表（Sequential List）是一种常见的线性数据结构，它由一组按照顺序存储的元素组成，其中每个元素都有唯一的索引值。

顺序表中的元素在物理存储上是连续的。

在Java中，顺序表可以通过数组进行实现，也可以通过ArrayList类来实现。

本文将分别介绍这两种实现方式。

二、数组实现顺序表1. 创建顺序表int[] array = new int[capacity];int size = 0;上述代码创建了一个容量为capacity的整型数组array，同时将顺序表的大小初始化为0。

2. 插入元素在顺序表的末尾插入元素：public void addLast(int element) {if (size == array.length) {// 扩容操作int[] newArray = new int[array.length * 2];System.arraycopy(array, 0, newArray, 0, array.length);array = newArray;}array[size] = element;size++;}在指定位置插入元素：public void add(int index, int element) {if (index < 0 || index > size) {throw new IndexOutOfBoundsException();}if (size == array.length) {// 扩容操作int[] newArray = new int[array.length * 2];System.arraycopy(array, 0, newArray, 0, index);System.arraycopy(array, index, newArray, index + 1, size - index); array = newArray;} else {System.arraycopy(array, index, array, index + 1, size - index);}array[index] = element;size++;}3. 删除元素删除末尾元素：public void removeLast() {if (size == 0) {throw new NoSuchElementException();}size--;}删除指定位置的元素：public void remove(int index) {if (index < 0 || index >= size) {throw new IndexOutOfBoundsException();}System.arraycopy(array, index + 1, array, index, size - index - 1);size--;}4. 获取元素获取指定位置的元素：public int get(int index) {if (index < 0 || index >= size) {throw new IndexOutOfBoundsException();}return array[index];}修改指定位置的元素：public void set(int index, int element) {if (index < 0 || index >= size) {throw new IndexOutOfBoundsException();}array[index] = element;}5. 查询元素查找指定元素的索引：public int indexOf(int element) {for (int i = 0; i < size; i++) {if (array[i] == element) {return i;}}return -1;}判断顺序表是否为空：public boolean isEmpty() {return size == 0;}三、ArrayList实现顺序表ArrayList是Java提供的一个动态数组类，它实现了List接口，可以方便地进行顺序表的操作。

codeblock数据结构算法实现-顺序表基本操作

codeblock数据结构算法实现-顺序表基本操作

数据结构算法实现-顺序表基本操作序号一、引言二、顺序表的定义三、顺序表的基本操作1.初始化操作2.插入操作3.删除操作4.查找操作四、顺序表的实现五、总结一、引言数据结构是计算机科学中非常重要的一部分，它是计算机存储、组织数据的方式。

而顺序表是其中的一种基本数据结构，它采用一组位置区域连续的存储单元依次存放线性表中的元素。

本文将着重介绍顺序表的基本操作及其算法实现。

二、顺序表的定义顺序表是一种基本的线性表，顺序表中元素的逻辑顺序和物理顺序是一致的。

顺序表的特点是利用一组连续的存储单元依次存放线性表中的元素。

顺序表可以用数组实现，其元素在内存中是连续存储的，可以通过下标直接访问元素。

由于顺序表的存储方式，使得其在查找、插入和删除等操作上具有较好的性能。

三、顺序表的基本操作顺序表的基本操作包括初始化、插入、删除和查找等。

下面分别介绍这些操作的实现方法。

1.初始化操作初始化操作是指将一个空的顺序表初始化为一个具有初始容量的顺序表，并为其分配内存空间。

初始化操作的实现方法主要有两种，一种是静态分配内存空间，另一种是动态分配内存空间。

静态分配内存空间时，需要预先指定顺序表的容量大小，然后在程序中创建一个数组，并为其分配指定大小的内存空间。

动态分配内存空间时，可以根据需要动态创建一个数组，并为其分配内存空间。

下面是一个简单的初始化操作的实现示例：```C代码#define MAXSIZE 100 // 定义顺序表的最大容量typedef struct {ElementType data[MAXSIZE]; // 定义顺序表的元素数组int length; // 定义顺序表的当前长度} SeqList;2.插入操作插入操作是指将一个新元素插入到顺序表的指定位置。

插入操作的实现方法主要包括在指定位置插入元素，同时对其他元素进行后移操作。

下面是一个简单的插入操作的实现示例：```C代码Status Insert(SeqList *L, int i, ElementType e) {if (i < 1 || i > L->length + 1) { // 判断插入位置是否合法return ERROR;}if (L->length >= MAXSIZE) { // 判断顺序表是否已满return ERROR;}for (int j = L->length; j >= i; j--) { // 插入位置及之后的元素后移L->data[j] = L->data[j - 1];}L->data[i - 1] = e; // 插入新元素L->length++; // 顺序表长度加1return OK;}```3.删除操作删除操作是指将顺序表中指定位置的元素删除。

顺序表基本算法实验报告

顺序表基本算法实验报告

顺序表基本算法实验报告顺序表基本算法实验报告一、实验目的本次实验旨在深入了解顺序表的基本操作和算法，包括顺序表的创建、插入、删除、遍历等操作，通过实际操作加深对顺序表的理解和应用能力。

二、实验内容和步骤1.顺序表的创建我们首先需要创建一个顺序表。

顺序表在内存中以数组的形式存在。

我们定义一个数组，并使用数组的索引来访问和操作其中的元素。

def create_sequential_list(size):sequential_list = []for i in range(size):sequential_list.append(0)return sequential_list2.插入操作顺序表的插入操作包括在指定位置插入一个元素。

这个操作需要注意插入位置及其前后的元素的处理。

def insert_sequential_list(sequential_list, index, value):sequential_list.insert(index, value)3.删除操作删除操作则是从顺序表中移除一个指定位置的元素。

这个操作需要注意被删除元素的前后元素的处理。

def delete_sequential_list(sequential_list, index):sequential_list.pop(index)4.遍历操作遍历操作则是访问顺序表中的每一个元素。

我们可以使用for循环来遍历顺序表中的所有元素。

def traverse_sequential_list(sequential_list):for element in sequential_list:print(element)三、实验结果和分析通过以上实验，我们成功实现了顺序表的创建、插入、删除和遍历操作。

插入和删除操作的时间复杂度为O(n)，其中n为顺序表的大小。

遍历操作的时间复杂度为O(n)。

顺序表是一种简单高效的数据结构，适用于元素数量固定且频繁进行插入、删除和遍历操作的场景。

java顺序表的基本操作代码

java顺序表的基本操作代码

java顺序表的基本操作代码Java顺序表是一种基于数组实现的线性结构，具有随机访问、元素插入和删除等基本操作。

在Java中，我们可以通过定义一个数组来创建一个顺序表，并通过编写一些基本操作代码来实现对该顺序表的操作。

一、顺序表的定义和初始化在Java中，我们可以通过定义一个数组来创建一个顺序表。

下面是一个简单的代码示例：```public class SeqList<T> {private Object[] elementData; // 存储元素的数组private int size; // 当前元素个数// 构造函数public SeqList(int capacity) {elementData = new Object[capacity];size = 0;}}```在上述代码中，我们定义了一个SeqList类，其中包含了存储元素的数组elementData和当前元素个数size两个成员变量。

构造函数SeqList(int capacity)用于创建指定长度为capacity的数组，并将当前元素个数初始化为0。

二、顺序表的插入操作1. 在指定位置插入元素在Java中，我们可以通过下标来访问数组中的元素。

因此，在进行插入操作时，需要先将要插入位置之后的所有元素向后移动一位，然后再将新元素插入到指定位置上。

下面是一个简单的代码示例：```// 在指定位置插入元素public void insert(int index, T element) {if (index < 0 || index > size) {throw new IndexOutOfBoundsException("插入位置越界"); }// 判断数组是否已满，若已满则扩容if (size == elementData.length) {ensureCapacity(size * 2);}// 将要插入位置之后的所有元素向后移动一位for (int i = size - 1; i >= index; i--) {elementData[i + 1] = elementData[i];}// 插入新元素elementData[index] = element;size++;}// 扩容方法private void ensureCapacity(int minCapacity) {if (minCapacity > elementData.length) {Object[] newArray = new Object[minCapacity];System.arraycopy(elementData, 0, newArray, 0, size);elementData = newArray;}}```在上述代码中，我们首先判断要插入的位置是否越界。

顺序表的基本操作-完整代码和拆开分析

顺序表的基本操作-完整代码和拆开分析

顺序表的基本操作-完整代码和拆开分析1 #include<stdio.h> //增+删+改+初始化+输出2 #include<stdlib.h>3#define MaxSize 10 此数决定了后⾯插⼊数据的多少，超过该数字输出顺序表的时候不是正确的数4 typedef int ElementType;5struct SqList {6 ElementType elem[MaxSize];7int Length;8 };910 typedef struct SqList *PtrNode;11 typedef PtrNode List;1213 List InitList();14int InSert(List L, int i, ElementType x) ;15int Delete(List L, int i);16int GetElem(List L, int i);17int Print(List L);1819int main() {20int a;21 ElementType x;22 List list;23 list=InitList();24 InSert(list, 1, 1);25 InSert(list, 2, 2);26 InSert(list, 3, 3);27 Print(list);28 printf("第⼀处的元素为:%d\n",GetElem(list,1));29 printf("要删除第⼏处的数据");30 scanf("%d", &a);31 Delete(list, a);32 Print(list);33 }34 List InitList() { //初始化35 List L;36 L = (List)malloc(sizeof(struct SqList));37 L->Length = 0;38 printf("初始化成功\n");39return L;40 }41//插⼊42int InSert(List L, int i, ElementType x) {43int j;44if (i<1 || i>L->Length + 1) {45 printf("越界"); return0;46 }47for (j = L->Length; j >= i; j--) {48 L->elem[j] = L->elem[j-1]; L—>elem[j+1]=L->elem[j];是错误的，j是数组长度，⽤作数组索引时要⼩⼼，所以上⾯的条件不应该是j>i49 }50 L->elem[i - 1] = x; //第i处，因为是数组所以减⼀51 L->Length++;52return1;53 }54//删除55int Delete(List L, int i) {56int j;57if (i<1 || i>L->Length) {58 printf("越界"); return0;59 }60for (j = i - 1; j < L->Length-1; j++)61 L->elem[j] = L->elem[j+1];62 L->Length--;63return1;6465 }66//查找第i处的数据67int GetElem(List L, int i) {68if (i<1 || i>L->Length) {69 printf("越界"); return0;70 }71return L->elem[i - 1];72 }73//遍历输出74int Print(List L) {75int i = 0;76for (i; i < L->Length; i++)77 printf("%d\n", L->elem[i]);78 }1. 初始化：1 List InitList() { //初始化2 List L;3 L = (List)malloc(sizeof(struct SqList));4 L->Length = 0;5 printf("初始化成功\n");6return L;7 }（1）malloc开辟空间，L指向该空间（2）空间的Length属性赋值为零；2.插⼊：int InSert(List L, int i, ElementType x) {43int j;44if (i<1 || i>L->Length + 1) {45 printf("越界"); return0;46 }47for (j = L->Length; j > i; j--) {48 L->elem[j + 1] = L->elem[j];49 }此处错误，修改见上⾯完整代码50 L->elem[i - 1] = x; //第i处，因为是数组所以减⼀51 L->Length++;52return1;53 }（1）判断输⼊的待插⼊位置是否合理------要插⼊的位置是否⼩于1，或者⼤于顺序表的长度Length+1【与其他的不同：可以在Length+1位置插⼊】（2）如果不满⾜（1），则循环赋值------从顺序表最后⼀个位置开始，从后向前依次将前⼀个位置的值赋给后⼀个位置（3）插⼊待插⼊数x-------将x赋值给待插⼊位置（4）顺序表长度加⼀3.删除：int Delete(List L, int i) {56int j;57if (i<1 || i>L->Length) {58 printf("越界"); return0;59 }60for (j = i - 1; j < L->Length-1; j++)61 L->elem[j] = L->elem[j+1];62 L->Length--;63return1;6465 }（1）判断输⼊的待插⼊位置是否合理------要插⼊的位置是否⼩于1，或者超出顺序表的长度Length（2）如果不满⾜（1），则循环赋值-------从待删除位置开始，从前向后依次将后⼀个位置的值赋值给前⼀个位置（3）顺序表长度减⼀4.查找：67int GetElem(List L, int i) {68if (i<1 || i>L->Length) {69 printf("越界"); return0;70 }71return L->elem[i - 1];72 }（1）判断输⼊的待插⼊位置是否合理------要插⼊的位置是否⼩于1，或者超出顺序表的长度Length（2）直接根据数组下标返回该值5.输出：74int Print(List L) {75int i = 0;76for (i; i < L->Length; i++)77 printf("%d\n", L->elem[i]);78 }根据数组下标直接循环输出**********************************************Tips:初始化和查找必须有返回值（初始化要将创建的顺序表名返回；查找要将找到的值返回），其他函数可以不设返回值或者返回1。

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

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

湖南第一师范学院信息科学与工程系实验报告课程名称：数据结构与算法成绩评定：实验项目名称：顺序表的基本操作指导教师：王杰文学生姓名：沈丽桃学号：10403080118 专业班级：教育技术实验项目类型：验证性实验地点：科B305 实验时间： 2011年 10月8 日一、实验目的与要求：实验目的：实现顺序表的创建、查找、插入、删除与输出基本原理：顺序表的基本操作二、实验环境：（硬件环境、软件环境）1.硬件环境：奔ⅣPC。

2.软件环境：Windows XP 操作系统，TC2.0或VC＋＋。

三、实验内容：（原理、操作步骤、程序代码等）#include<stdio.h># define maxlength 100 /#后不应该有空格/struct LIST{int elements[maxlength];int last;}L;typedef int position;void main(){position p,p1; /p和x最好赋值/int x,x1,i,choice;position Locate(int x,struct LIST*y);void Insert(int x,position p,struct LIST*y);void Delete(position p,struct LIST *y);printf("option:Locate 1,Insert 2,Delete 3\n");printf("please choice:");scanf("%d",&choice);switch(choice){case 1:{printf("please input a number:");scanf("%d",&x);p1=Locate(x,&L);if(p1==101)printf(“the number does not exist”);else printf("the position is:%d",p1); /break；/}case 2:{printf("please input a numer:");scanf("%d",x1); /x1钱应加取地址符&/printf("please input the position:");scanf("%d",&p);Insert(x1,p,&L);for(i=0;i<=st;i++)printf("%d",L.elements[i]);printf("\n"); /break；/}case 3:{printf("please input the position:");scanf("%d",&p);Delete(p,&L);for(i=0;i<=st;i++)printf("%d",L.elements[i]);printf("\n"); /break；/}}position Locate(int x,struct LIST*y) /把变量x改为m/{int q;if(st>maxlength-1)printf("error:list is full");else if((p>st)||(p<1))printf("error:position does not exist");else{for(q=1;q<st;q++){if(elements[q]==x) /x改为m/（主要错误是elements[q]应改为L.elements[q] return q;else return 101;}}}void Insert(int x,position p,struct LIST*y){position q;if(st>maxlength-1)printf("error:list is full");else if((p>st)||(p<1))printf("error:position does not exist");else{for(q=st;q>=p;q--){L.elements[q+1]=L.elements[q];st=st+1;L.elements[q]=x;}}}Void Delete(position p,struct LIST*y) /这个问题重复出现，V要改为小写/ {position q;if(st>maxlength-1)printf("error:list is full");else if((p>st)||(p<1))printf("error:position does not exist");else{st=st-1;for(q=p;q<=st;q++)L.elements[q]=L.elements[q+1];}}error C2146:syntax error:missing’)’before identifier’p’error C2081:’position’:name in formal parameter list illegalerror C2146:syntax error:missing’:’before identifier’p’error C2059:syntax error:’type’error C2059:syntax error:’)’error C2143:syntax error:missing’;’before’type’warning C4020:’Insert’:too many actual parameterswarning C4013:’delete’undefined;assuming extern returning interror C2065:’position’:undeclared identifiererror C2146:syntax error:missing’)’before identifier ‘Locate’error C2143:syntax error:missing’)’before ‘type’error C2198:’Locate’:too few avtual parameterserror C2059:syntax error:’)’error C2065:’q’:undeclared identifiererror C2065:’elements’:undeclared identifiererror C2109:subscript requires array or pointer typewarning C4098:’main’:’void’function returning a valuewarning C4098:’main’:’void’function returning a valueerror C2146:syntax error:missing’);before identifier ’p’error C2081:’position’:name in formal parameter list illegalerror C2061:syntax error:identifier’p’error C2059:syntax error:’;’error C2059:syntax error:’,’error C2059:syntax error :’)’四、实验体会# define maxlength 100 /#后不应该有空格/要先对数组进行初始化，存入一些数据position p,p1; /p和x最好赋值/scanf("%d",x1); /x1钱应加取地址符&/if(elements[q]==x) /x改为m/（主要错误是elements[q]应改为L.elements[q]Void Delete(position p,struct LIST*y) /这个问题重复出现，V要改为小写/switch每个case语句写完要加break;一开始不知所措，首先应该有一个大的方向，把主程序编号，再逐步求精，落实到每一个函数的编写。

顺序表基本操作的实现

顺序表基本操作的实现

【实验名称】顺序表基本操作的实现【实验目的】1. 熟悉调试工具VC++6.0的使用2. 温习C++相关程序的编写与应用3. 掌握顺序表的基本操作：构造顺序表、插入、删除、查找等4. 掌握顺序表的应用：顺序表的合并等运算【实验原理】VC6.0工具的使用，C++类实现顺序表的定义及基本操作算法的实现，应用顺序表解决实际问题。

【学时安排】2学时上机实践【具体操作内容及要求】1．创建一个目录（学号命名），然后创建项目和源文件完成本次实验内容：（1）创建项目或源文件名为“Ex1_(学号后四位).cpp”；（2）编写并调试线性表的C++模板类定义，即调试运行课本中44页程序2.2（3）编写并调试顺序表类定义（由线性表类派生）及顺序表基本操作的算法实现。

即调试运行课本46~50页程序2.5~2.9。

（4）编写主函数main，实现课本52页程序2.10中顺序表的合并操作应用。

（注意算法的改进）（5）注意所有变量、类名、方法名的命名规范。

2. 撰写实验报告（下载实验报告模板），内容包括：实验原理、实验目的、实验具体步骤及实验结果（运行效果截图）。

3. 将实验报告和程序源文件放在一个以学号命名的文件夹中，然后压缩（如2010011213.rar）提交，注意提交截止时间。

实验结果：①编程代码：A： LinearList.h头文件代码：#include <iostream.h>#include <stdlib.h>class LinearList{public:LinearList(){};~LinearList(){};virtual int Size()const=0;virtual int Length()const=0;virtual int Search(T& x)const=0;virtual int Locate(int i)const=0;virtual bool getData(int i,T& x)const=0;virtual void setData(int i,T& x)=0;virtual bool Insert(int i,T& x)=0;virtual bool Remove(int i,T& x)=0;virtual bool IsEmpty()const=0;virtual bool IsFull()const=0;// virtual void Sort()=0;virtual void input()=0;virtual void output()=0;// virtual LinearList<T> operator=(LinearList<T>& L)=0;};B：SeqList.h头文件代码：#include "linearlist.h"const int DefaultSize = 100;class SeqList:public LinearList<T>{public:SeqList ( int size = DefaultSize );SeqList(SeqList<T>& L);~SeqList() { delete[] data; }int Size()const{ return maxSize;}int Length()const { return last+1; } int Search( T& x ) const;int Locate(int i)const;bool getData(int i,T& x)const{if(i>0 && i<=last+1){x=data[i-1];return true;}elsereturn false;}void setData(int i,T& x){if(i>0 && i<=last+1){}}bool Insert(int i, T& x);bool Remove(int i,T& x);bool IsEmpty()const { return (last == -1)?true:false; }bool IsFull()const { return (last == maxSize - 1)?true:false; } void input();void output();SeqList<T> operator=(SeqList<T>& L);protected:T *data;int maxSize;int last;void reSize(int newSize);};template <class T>SeqList<T>::SeqList( int sz){if ( sz > 0 ) {maxSize = sz; last = -1; //置表的实际长度为空data = new T[maxSize]; //创建顺序表存储数组if(data==NULL) //动态分配失败{exit(1);}}}//赋值构造函数，用参数表中给出的已有顺序初始化新建的顺序表。

c语言创建顺序表

c语言创建顺序表

c语言创建顺序表C语言是一种广泛应用于各种领域的编程语言，其功能强大和易学性使得它成为很多领域的首选语言。

创建顺序表是C语言中的基础知识之一，下面将会分步骤阐述如何在C语言中创建顺序表。

一、什么是顺序表顺序表是一种线性表结构，它的元素是以连续的存储空间存储的。

顺序表的存储结构是计算机内存中的连续空间。

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

二、顺序表的创建步骤1.定义顺序表结构体在C语言中，我们首先需要定义顺序表的结构体来存储顺序表的数据。

顺序表结构体通常包含以下元素：```#define MaxSize 100 // 定义顺序表的最大长度typedef struct SeqList {int data[MaxSize]; // 顺序表存储数据的数组int length; // 顺序表的长度} SeqList;```其中，MaxSize是顺序表的最大长度，data是顺序表存储数据的数组，length是顺序表的长度，即其中元素的个数。

2.初始化顺序表初始化顺序表包括给顺序表的length元素赋值为0，即初始化一个空的顺序表。

```void InitList(SeqList *list){list->length = 0;}```3.插入元素插入元素是常见的操作，它可以将一个元素插入到顺序表中。

在插入元素之前，我们需要判断顺序表是否已经满了。

```bool InsertList(SeqList *list, int index, int element){if (list->length >= MaxSize) {return false;}if (index < 1 || index > list->length+1) {return false;}for (int i = list->length; i >= index; i--) {list->data[i] = list->data[i-1];}list->data[index-1] = element;list->length++;return true;}```4.删除元素删除元素是另一个常见的操作，它可以将顺序表中的一个元素删除。

  1. 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

《数据结构》实验报告一
顺序表的基本操作
班级：网络工程学号：12015242183
实验日期：2016.9.25 姓名：邓宗永
程序文件名及说明：sequenlist 顺序表
一、实验目的
1、掌握使用Turbo C3.0上机调试线性表的基本方法；
2、掌握顺序表的基本操作：插入、删除、查找以及线性表合并等运算。

二、实验要求
1、认真阅读和掌握实验的程序。

2、上机运行程序。

3、保存和打印出程序的运行结果，并结合程序进行分析。

4、按照你对线性表的操作需要，编写写主程序并运行，打印出文件清单和运行结果
三、注意事项：
在磁盘上创建一个目录，专门用于存储数据结构实验的程序。

四、实验内容
1.顺序表的查找、插入与删除。

设计算法，实现线性结构上的顺序表的产生以及元素的查找、插入与删除。

具体实现要求：
（1）从键盘输入10个整数，产生顺序表，并输入结点值。

（2）从键盘输入1个整数，在顺序表中查找该结点的位置。

若找到，输出结点的位置；若找不到，则显示“找不到”。

（3）从键盘输入2个整数，一个表示欲插入的位置i，另一个表示欲插入的数值x，将x 插入在对应位置上，输出顺序表所有结点值，观察输出结果。

（4）从键盘输入1个整数，表示欲删除结点的位置，输出顺序表所有结点值，观察输出结果。

五、实验报告必须写明内容
1.程序设计的基本思想，原理和算法描述：（包括程序的结构，数据结构，输入/输出设
计，符号名说明等）
程序的结构：通过子函数实现输出，删除，插入，查找等功能，高耦合低内聚
数据结构：线性结构，顺序储存
输入/输出设计：根据屏幕提示，从键盘读取数据
2.源程序及注释：
#include <stdio.h>
#include <stdio.h>
typedef int datatype;
#define maxsize 10
typedef struct //创建一个顺序表包含10个整数
datatype data[maxsize];
int last;
}sequenlist;
void Delete(sequenlist *L,int i)//删除前移节点{int j;
if((i<1)||(i>L->last+1))
{printf("error");}
else
{for(j=i;j<=L->last;j++)
L->data[j-1]=L->data[j];
L->last--;
}
}
int get(sequenlist L,datatype x)
{ int i=0;
for(i=0;i<=st;i++)
{
if(L.data[i]==x)
{return i+1; break;}
}
return 0;
}
int Insert (sequenlist *L,datatype x,int i)
{
int j;
if((L->last)>=maxsize-1)
{
printf("overflow\n");
return 0;
}
else
{
for(j=L->last;j>=i-1;j--)
L->data[j+1]=L->data[j];
L->data[i-1]=x;
L->last=L->last+1;
return(1);
}
void PPrint(sequenlist L)//输出
{int i;
printf("the list is \n:");
for(i=0;i<= st;i++)
{
printf("%d ",L.data[i]);
}
printf("\n");
}
int main(void)
{
sequenlist L;datatype t,th,mh,wh,eh;
int i,s;
printf("请输入十个整数：\n");
for(i=0 ;i<maxsize;i++)
{
scanf("%d",&(L.data[i]));
if(L.data[i]=='$') break;
}
st=i-1;
printf("\n");
PPrint(L);
printf("\n");
printf("请输入要查找的数：\n");
scanf("%d",&th);
s=get(L,th);
printf("第%d节点\n",s);
printf("请输入要删除的位置：\n");
scanf("%d",&eh);
Delete(&L,eh);
PPrint(L);
printf("请输入要插入的数和位置：数值，位置\n");
scanf("%d,%d",&mh,&wh);
Insert(&L,mh,wh);
PPrint(L);
return 1;
}
3.运行输出结果：
4.调试和运行程序过程中产生的问题及采取的措施：
正常输入插入后，顺序表没有改变，通过调试发现，子函数里的顺序表的变化没有传递给主函数，最后将子函数参数改为指针类型。

5.对算法的程序的讨论、分析，改进设想，其它经验教训。

输入可以改为以某个结束符为标志，而不是以确定的大小为标志，能提高程序的可扩展性。

相关文档
最新文档