线性表的基本操作讲解
线性表 知识点总结
线性表知识点总结线性表的特点:1. 有序性:线性表中的元素是有序排列的,每个元素都有唯一的前驱和后继。
2. 可变性:线性表的长度是可变的,可以进行插入、删除操作来改变表的元素数量。
3. 线性关系:线性表中的元素之间存在明确的前驱和后继关系。
4. 存储结构:线性表的存储结构有顺序存储和链式存储两种方式。
线性表的操作:1. 查找操作:根据元素的位置或值来查找线性表中的元素。
2. 插入操作:将一个新元素插入到线性表中的指定位置。
3. 删除操作:将线性表中的某个元素删除。
4. 更新操作:将线性表中的某个元素更新为新的值。
线性表的顺序存储结构:顺序存储结构是将线性表的元素按照其逻辑顺序依次存储在一块连续的存储空间中。
线性表的顺序存储结构通常采用数组来实现。
数组中的每个元素都可以通过下标来访问,因此可以快速的进行查找操作。
但是插入和删除操作会导致元素位置的变动,需要进行大量数据搬移,效率较低。
线性表的链式存储结构:链式存储结构是将线性表的元素通过指针相连,形成一个链式结构。
每个元素包含数据和指向下一个元素的指针。
链式存储结构不需要连续的存储空间,可以动态分配内存,适合插入和删除频繁的场景。
但是链式结构的元素访问不如顺序结构高效,需要通过指针来逐个访问元素。
线性表的应用场景:1. 线性表适用于数据元素之间存在明确的前后关系,有序排列的场景。
2. 顺序存储结构适用于元素的插入和删除操作较少,对元素的随机访问较频繁的场景。
3. 链式存储结构适用于插入和删除操作较频繁的场景,对元素的随机访问较少。
线性表的操作的时间复杂度:1. 查找操作:顺序存储结构的时间复杂度为O(1),链式存储结构的时间复杂度为O(n)。
2. 插入和删除操作:顺序存储结构的时间复杂度为O(n),链式存储结构的时间复杂度为O(1)。
线性表的实现:1. 顺序存储结构的实现:使用数组来存储元素,通过下标来访问元素。
2. 链式存储结构的实现:使用链表来实现,每个元素包含数据和指向下一个元素的指针。
实验01 线性表的基本操作
实验01 线性表的基本操作一、实验目的1. 了解线性表的结构特点及有关概念;2. 理解线性表的存储结构;3. 掌握顺序表及单链表的基本操作算法。
二、实验内容1、编写程序实现顺序表的各种基本运算:初始化、插入、删除、取表元素、求表长、输出表、销毁、判断是否为空表、查找元素。
在此基础上设计一个主程序完成如下功能:(1)初始化顺序表L;(2)依次在表尾插入a,b,c,d,e五个元素;(3)输出顺序表L;(4)输出顺序表L的长度;(5)判断顺序表L是否为空;(6)输出顺序表L的第4个元素;(7)输出元素c的位置;(8)在第3个位置上插入元素f,之后输出顺序表L;(9)删除L的第2个元素,之后输出顺序表L;(10)销毁顺序表L。
2、编写程序实现单链表的各种基本运算:初始化、插入、删除、取表元素、求表长、输出表、销毁、判断是否为空表、查找元素。
在此基础上设计一个主程序完成如下功能:(1)初始化单链表L;(2)依次在表尾插入a,b,c,d,e五个元素;(3)输出单链表L;(4)输出单链表L的长度;(5)判断单链表L是否为空;(6)输出单链表L的第4个元素;(7)输出元素c的位置;(8)在第3个位置上插入元素f,之后输出单链表L;(9)删除L的第2个元素,之后输出单链表L;(10)销毁单链表L。
三、实验要点及说明一.顺序表1.顺序表初始化:(1)为顺序表L动态分配一个预定大小的数组空间,使elem 指向这段空间的基地址。
(2)将表的当前长度设为0.2.顺序表的取值:(1)判断指定的位置序号i值是否合理(1<=i<=L.length),若不合理则返回ERROR.(2)若i值合理,则将i个数据元素L.elem[i]赋给参数e,通过e返回第i个数据元素的传值。
3.顺序表的查找:(1)从第一个元素起,依次和e相比较,若找到与e相等的元素L.elem[i],则查找成功,返回该元素的序号i+1.(2)若查遍整个顺序表都没要找到,则查找失败,返回0.4.顺序表的插入:(1)判断插入位置i是否合法(i值的合法范围是1<=i<=n+1),若不合法则返回值ERROR.(2)判断顺序表的存储空间是否已满,若满则返回值ERROR(3)将第n个至第i个位置的元素依次向后移动一个位置,空出第i个位置(i=n+1时无需移动)。
线性表的逻辑结构及其基本操作.
1<=i<=n
a1 a2 … ai … an
3.Байду номын сангаас顺序表的类定义
template<class Type>class Array { private: Type *elements; //数组元素 int ArraySize; //数组元素的个数 int MaxSize; //数组元素的最大个数 BOOL GetArray(); BOOL GetArray(Type *pa); };
4. 线性表的运算
(1) 置空表:建立一个空表; (2) 存 (3) 插 (4) 删 (6) 查 (7) 合 取:访问线性表的某个元素,使用或改变其值; 入:在第i个位置插入一个同类型的结点; 除:删除第i个结点; 找:在线性表中查找满足某种条件的结点; 并:将两个线性表合并成一个线性表;
(5) 求表长:求出线性表中结点的个数;
顺序存储结构的特点为: 1)表中逻辑上相邻的结点,存储在相邻的物理
位置上;2)可以随机存取表中的元素;3)存储密度 大,存储空间利用率高。
2. 线性表的地址计算:
设线性表的基地址为LOC(a1), ai的存储地址为: LOC(ai) = LOC(a1)+(i-1)*k
1 2 i n a1 a2 … ai … an Loc(a1) Loc(a1)+k Loc(a1)+(i-1)*k
(8) 分
(9) 排
拆:将一个线性表分拆成多个线性表;
序:按某数据项的值递增或递减的顺序重新排列;
(10)显示,建立,读写盘等.
1
2 3 4
线性表的逻辑结构及其基本操作
线性表的顺序存储结构 线性表的链式存储结构 静态链表 应用实例
实验一线性表的基本操作
实验⼀线性表的基本操作⼀、线性结构的顺序表基本操作实验⽬的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:定义1.1 线性表的概念1.2 线性表的特点2:基本操作2.1 初始化操作2.1.1 空表的创建2.1.2 非空表的创建2.2 插入操作2.2.1 在指定位置插入元素2.2.2 在表头插入元素2.2.3 在表尾插入元素2.3 删除操作2.3.1 删除指定位置的元素2.3.2 删除表头的元素2.3.3 删除表尾的元素2.4 查找操作2.4.1 按值查找元素2.4.2 按位置查找元素2.5 修改操作2.5.1 修改指定位置的元素 2.5.2 修改指定值的元素3:综合操作3.1 反转线性表3.2 合并两个线性表3.3 排序线性表3.4 删除重复元素3.5 拆分线性表4:线性表的应用场景4.1 数组的应用4.2 链表的应用4.3 栈的应用4.4 队列的应用附件:无法律名词及注释:- 线性表:根据某种规则排列的一组元素的有限序列。
- 初始化操作:创建一个空的线性表,或者创建一个已经包含一定元素的线性表。
- 插入操作:在线性表的指定位置或者表头、表尾插入一个新元素。
- 删除操作:从线性表中删除掉指定位置或者表头、表尾的元素。
- 查找操作:在线性表中按照指定的元素值或者位置查找元素。
- 修改操作:更改线性表中指定位置或者值的元素。
- 反转线性表:将线性表中的元素顺序颠倒。
- 合并线性表:将两个线性表合并成一个新的线性表。
- 排序线性表:按照某种规则对线性表中的元素进行排序。
- 删除重复元素:将线性表中重复的元素删除,只保留一个。
- 拆分线性表:将一个线性表分成多个不重叠的子线性表。
线性表的存储结构定义及基本操作(实验报告)
线性表的存储结构定义及基本操作(实验报告)线性表的存储结构定义及基本操作一掌握线性表的逻辑特征掌握线性表顺序存储结构的特点熟练掌握顺序表的基本运算熟练掌握线性表的链式存储结构定义及基本操作理解循环链表和双链表的特点和基本运算加深对顺序存储数据结构的理解和链式存储数据结构的理解逐步培养解决实际问题的编程能力二一基本实验内容顺序表建立顺序表完成顺序表的基本操作初始化插入删除逆转输出销毁置空表求表长查找元素判线性表是否为空1 问题描述利用顺序表设计一组输入数据假定为一组整数能够对顺序表进行如下操作创建一个新的顺序表实现动态空间分配的初始化根据顺序表结点的位置插入一个新结点位置插入也可以根据给定的值进行插入值插入形成有序顺序表根据顺序表结点的位置删除一个结点位置删除也可以根据给定的值删除对应的第一个结点或者删除指定值的所有结点值删除利用最少的空间实现顺序表元素的逆转实现顺序表的各个元素的输出彻底销毁顺序线性表回收所分配的空间对顺序线性表的所有元素删除置为空表返回其数据元素个数按序号查找根据顺序表的特点可以随机存取直接可以定位于第 i 个结点查找该元素的值对查找结果进行返回按值查找根据给定数据元素的值只能顺序比较查找该元素的位置对查找结果进行返回判断顺序表中是否有元素存在对判断结果进行返回编写主程序实现对各不同的算法调用2 实现要求对顺序表的各项操作一定要编写成为C C 语言函数组合成模块化的形式每个算法的实现要从时间复杂度和空间复杂度上进行评价初始化算法的操作结果构造一个空的顺序线性表对顺序表的空间进行动态管理实现动态分配回收和增加存储空间位置插入算法的初始条件顺序线性表L已存在给定的元素位置为i且1≤i ≤ListLength L 1操作结果在L中第i个位置之前插入新的数据元素eL的长度加1位置删除算法的初始条件顺序线性表L已存在1≤i≤ListLength L 操作结果删除L的第i个数据元素并用e返回其值L的长度减1逆转算法的初始条件顺序线性表L已存在操作结果依次对L的每个数据元素进行交换为了使用最少的额外空间对顺序表的元素进行交换输出算法的初始条件顺序线性表L已存在操作结果依次对L的每个数据元素进行输出销毁算法初始条件顺序线性表L已存在操作结果销毁顺序线性表 L置空表算法初始条件顺序线性表L已存在操作结果将L重置为空表求表长算法初始条件顺序线性表L已存在操作结果返回L中数据元素个数按序号查找算法初始条件顺序线性表 L 已存在元素位置为 i且 1≤i≤ListLength L 操作结果返回 L 中第 i 个数据元素的值按值查找算法初始条件顺序线性表 L 已存在元素值为 e 操作结果返回 L 中数据元素值为 e 的元素位置判表空算法初始条件顺序线性表 L 已存在操作结果若 L 为空表则返回 TRUE否则返回 FALSE分析修改输入数据预期输出并验证输出的结果加深对有关算法的理解二基本实验内容单链表建立单链表完成链表带表头结点的基本操作建立链表插入删除查找输出求前驱求后继两个有序链表的合并操作其他基本操作还有销毁链表将链表置为空表求链表的长度获取某位置结点的内容搜索结点1 问题描述利用线性表的链式存储结构设计一组输入数据假定为一组整数能够对单链表进行如下操作初始化一个带表头结点的空链表创建一个单链表是从无到有地建立起一个链表即一个一个地输入各结点数据并建立起前后相互链接的关系又分为逆位序插在表头输入 n 个元素的值和正位序插在表尾输入 n 个元素的值插入结点可以根据给定位置进行插入位置插入也可以根据结点的值插入到已知的链表中值插入且保持结点的数据按原来的递增次序排列形成有序链表删除结点可以根据给定位置进行删除位置删除也可以把链表中查找结点的值为搜索对象的结点全部删除值删除输出单链表的内容是将链表中各结点的数据依次显示直到链表尾结点编写主程序实现对各不同的算法调用其它的操作算法描述略2 实现要求对链表的各项操作一定要编写成为 C C 语言函数组合成模块化的形式还要针对每个算法的实现从时间复杂度和空间复杂度上进行评价初始化算法的操作结果构造一个空的线性表 L产生头结点并使 L 指向此头结点建立链表算法初始条件空链存在操作结果选择逆位序或正位序的方法建立一个单链表并且返回完成的结果链表位置插入算法初始条件已知单链表 L 存在操作结果在带头结点的单链线性表 L 中第 i 个位置之前插入元素 e链表位置删除算法初始条件已知单链表 L 存在操作结果在带头结点的单链线性表 L 中删除第 i 个元素并由 e 返回其值输出算法初始条件链表 L 已存在操作结果依次输出链表的各个结点的值三扩展实验内容顺序表查前驱元素查后继元素顺序表合并等1 问题描述根据给定元素的值求出前驱元素根据给定元素的值求出后继元素对已建好的两个顺序表进行合并操作若原线性表中元素非递减有序排列要求合并后的结果还是有序有序合并对于原顺序表中元素无序排列的合并只是完成 A A∪B 无序合并要求同样的数据元素只出现一次修改主程序实现对各不同的算法调用2 实现要求查前驱元素算法初始条件顺序线性表 L 已存在操作结果若数据元素存在且不是第一个则返回前驱否则操作失败查后继元素算法初始条件顺序线性表 L 已存在操作结果若数据元素存在且不是最后一个则返回后继否则操作失败无序合并算法的初始条件已知线性表 La 和 Lb操作结果将所有在线性表 Lb 中但不在 La 中的数据元素插入到 La 中有序合并算法的初始条件已知线性表 La 和 Lb 中的数据元素按值非递减排列操作结果归并 La 和 Lb 得到新的线性表 LcLc 的数据元素也按值非递减排列四扩展实验内容链表1 问题描述求前驱结点是根据给定结点的值在单链表中搜索其当前结点的后继结点值为给定的值将当前结点返回求后继结点是根据给定结点的值在单链表中搜索其当前结点的值为给定的值将后继结点返回两个有序链表的合并是分别将两个单链表的结点依次插入到第 3 个单链表中继续保持结点有序2 实现要求求前驱算法初始条件线性表 L 已存在操作结果若 cur_e 是 L 的数据元素且不是第一个则用 pre_e 返回它的前驱求后继算法初始条件线性表 L 已存在操作结果若 cur_e 是 L 的数据元素且不是最后一个则用 next_e 返回它的后继两个有序链表的合并算法初始条件线性表单链线性表 La 和 Lb 的元素按值非递减排列操作结果归并 La 和 Lb 得到新的单链表三实验环境和实验步骤实验环境利用CodeBlocks1005集成开发环境进行本实验的操作实验步骤――顺序表的定义与操作1启动CodeBlocks1052按Create a new project 通过file 按CC source选择c然后GO储存文件D\c语言\顺序表c3进行编代码4编好之后搞ctrlshiftF9进行编译然后按ctrlF105如果编译出问题然后进行调试实验步骤――链表的定义与操作1启动CodeBlocks1052按Create a new project 通过file 按CC source选择c然后GO储存文件D\c语言\单链表c3进行编代码4编好之后搞ctrlshiftF9进行编译然后按ctrlF105如果编译出问题然后进行调试四 includeinclude "stdlibh"includedefine LIST_INIT_SIZE 100define ok 1define ERROR 0define OVERFLOW -1define Num 3typedef int DataTypetypedef int Statustypedef structDataType elemint Lengthint ListsizeSeqListSeqList LStatus InitSeqList SeqList LL- elem Da。
数据结构--实验报告 线性表的基本操作
数据结构--实验报告线性表的基本操作数据结构--实验报告线性表的基本操作一、引言本实验报告旨在通过实际操作,掌握线性表的基本操作,包括初始化、插入、删除、查找等。
线性表是最基本的数据结构之一,对于理解和应用其他数据结构具有重要的作用。
二、实验目的1·了解线性表的定义和基本特性。
2·掌握线性表的初始化操作。
3·掌握线性表的插入和删除操作。
4·掌握线性表的查找操作。
5·通过实验巩固和加深对线性表的理解。
三、线性表的基本操作1·初始化线性表线性表的初始化是将一个线性表变量设置为空表的过程。
具体步骤如下:(1)创建一个线性表的数据结构,包括表头指针和数据元素的存储空间。
(2)将表头指针指向一个空的数据元素。
2·插入元素插入元素是向线性表中指定位置插入一个元素的操作。
具体步骤如下:(1)判断线性表是否已满,如果已满则无法插入元素。
(2)判断插入位置是否合法,如果不合法则无法插入元素。
(3)将插入位置及其后面的元素都向后移动一个位置。
(4)将待插入的元素放入插入位置。
3·删除元素删除元素是从线性表中删除指定位置的元素的操作。
具体步骤如下:(1)判断线性表是否为空,如果为空则无法删除元素。
(2)判断删除位置是否合法,如果不合法则无法删除元素。
(3)将删除位置后面的元素都向前移动一个位置。
(4)删除最后一个元素。
4·查找元素查找元素是在线性表中查找指定元素值的操作。
具体步骤如下:(1)从线性表的第一个元素开始,逐个比较每个元素的值,直到找到目标元素或遍历完整个线性表。
(2)如果找到目标元素,则返回该元素的位置。
(3)如果未找到目标元素,则返回找不到的信息。
四、实验步骤1·初始化线性表(1)定义线性表的数据结构,包括表头指针和数据元素的存储空间。
(2)将表头指针指向一个空的数据元素。
2·插入元素(1)判断线性表是否已满。
数据结构实验报告线性表
数据结构实验报告线性表数据结构实验报告:线性表引言:数据结构是计算机科学中的重要概念,它涉及到如何组织和存储数据,以及如何有效地操作和管理这些数据。
线性表是数据结构中最基本的一种,它是一种有序的数据元素集合,其中的元素之间存在着一对一的关系。
一、线性表的定义和特点线性表是由n个数据元素组成的有限序列,其中n为表的长度。
这些数据元素可以是相同类型的,也可以是不同类型的。
线性表中的数据元素按照一定的顺序排列,并且每个数据元素都有唯一的前驱和后继。
线性表的特点有以下几个方面:1. 数据元素之间是一对一的关系,即每个数据元素只有一个直接前驱和一个直接后继。
2. 线性表中的元素是有序的,每个元素都有一个确定的位置。
3. 线性表的长度是有限的,它的长度可以是0,也可以是任意正整数。
二、线性表的实现方式线性表可以使用不同的数据结构来实现,常见的实现方式有数组和链表。
1. 数组实现线性表:数组是一种连续存储的数据结构,它可以用来存储线性表中的元素。
数组的优点是可以快速访问任意位置的元素,但是插入和删除操作需要移动其他元素,效率较低。
2. 链表实现线性表:链表是一种非连续存储的数据结构,它通过指针将线性表中的元素链接起来。
链表的优点是插入和删除操作简单高效,但是访问任意位置的元素需要遍历链表,效率较低。
三、线性表的基本操作线性表的基本操作包括插入、删除、查找和修改等。
1. 插入操作:插入操作用于向线性表中插入一个新元素。
具体步骤是先将插入位置后面的元素依次后移,然后将新元素插入到指定位置。
2. 删除操作:删除操作用于从线性表中删除一个元素。
具体步骤是先将删除位置后面的元素依次前移,然后将最后一个元素删除。
3. 查找操作:查找操作用于在线性表中查找指定元素。
具体步骤是从线性表的第一个元素开始逐个比较,直到找到匹配的元素或者到达线性表的末尾。
4. 修改操作:修改操作用于修改线性表中的某个元素的值。
具体步骤是先查找到要修改的元素,然后将其值更新为新值。
线性表的基本操作
实验一线性表的基本操作一、实验目的学习掌握线性表的顺序存储结构、链式存储结构。
设计顺序表的创建、插入、删除等基本操作,设计单链表的建立、插入、删除等基本操作。
二、实验内容1.顺序表的实践(1)顺序表的创建:基于顺序表的动态分配存储结构,创建一个顺序表S,初始状态S=(1,2,3,4,5)。
(2)顺序表的遍历:依次输出顺序表的每个数据元素。
(3)顺序表的插入:在顺序表S=(1,2,3,4,5)的数据元素4和5之间插入一个值为9的数据元素。
(4)顺序表的删除:顺序表S=(1,2,3,4,9,5)中删除指定位置(i=3)的数据元素3。
(5)顺序表的按值查找:查找顺序表S中第1个值等于4的数据元素位序。
(6)顺序表的清空:释放顺序表的存储空间。
2.单链表的实践(1)单链表的创建:创建一个包括头结点和4个元素结点的单链表L=(5,4,2,1)。
(2)单链表的遍历:依次输出顺序表的每个数据元素。
(3)单链表的取值:输出单链表中第i个(i=2)数据元素的值。
(4)单链表的插入:在已建好的单链表的指定位置(i=3)插入一个结点3。
(5)单链表的删除:在一个包括头结点和5个结点的单链表L=(5,4,3,2,1)中,删除指定位置(i=2)的结点,实现的基本操作。
(6)求单链表的表长:输出单链表的所有元素和表长。
(7)单链表的判空:判断单链表是否为空表。
(8)单链表的清空:释放单链表的存储空间。
三、程序源代码1.线性表的基本操作#include <iostream>#include<stdlib.h>using namespace std;#define OK 1#define OVERFLOW -2#define ERROR 0#define LIST_INIT_SIZE 100#define LISTINCEREMENT 10typedef int Status;typedef int Elemtype;typedef Elemtype *Triplet;typedef struct { //定义结构体类型:顺序表Elemtype *elem;int length;int listsize;} Sqlist;Status Initlist( Sqlist &L ) { //int n,i;L.elem = (Elemtype*) malloc (LIST_INIT_SIZE*sizeof(Elemtype));if(!L.elem) {return(OVERFLOW);}cout << "输入元素个数和各元素的值:";cin >> n;for(int i=0; i<n; i++) {cin >> L.elem[i];}L.length = n;L.listsize = LIST_INIT_SIZE;return OK;}Status TraverList(Sqlist L) {for(int i=0; i<L.length; i++) {cout << L.elem[i]<<" ";}cout << endl;}Status ListInsert (Sqlist &L,int i,Elemtype e) { //插入Elemtype *newbase,*p,*q;if(i<1||i>L.length+1) return ERROR;//i不合法if(L.length >= L.listsize) { //需要重新分配存储空间newbase = (Elemtype *) realloc(L.elem,(L.listsize + LISTINCEREMENT)*sizeof (Elemtype));if(!newbase) exit(OVERFLOW);//分配失败L.elem = newbase;L.listsize += LISTINCEREMENT;}q = &(L.elem[i-1]);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]);e=*p;q=L.elem+L.length-1;for(++p; p<=q; ++p)*(p-1)=*p;--L.length;return OK;}Status LocateElem(Sqlist L,Elemtype &e) { //查找int i;Elemtype *p;i=1;p=L.elem;while(i<=L.length&&*(p++)!=e) ++i;if(i<=L.length) return i;else return 0;}Status ClearList(Sqlist &L) {free(L.elem);cout << "该表已被清空!";return OK;}int main() {Sqlist L;int i,z;Elemtype e;if(Initlist(L)==OVERFLOW) {cout << endl << "OVERFLOW";return 0;}TraverList(L);while(1) {cout << "-------------------" << endl;cout << "选择要执行的基本操作:" << endl << "1:插入元素" << endl << "2.删除元素" << endl << "3.查找元素" << endl<< "4.退出" << endl;cin >> z;switch(z) {case 1:cout << "输入要插入元素的位置和值:" << endl;cin >> i >> e;if(ListInsert(L,i,e)==OK)TraverList(L);elsecout << "插入的位置不合法。
实验一线性表操作实验报告
实验一_线性表操作_实验报告实验一:线性表操作一、实验目的1.理解线性表的基本概念和特点。
2.掌握线性表的基本操作,包括插入、删除、查找等。
3.通过实验,提高动手能力和解决问题的能力。
二、实验原理线性表是一种较为常见的数据结构,它包含零个或多个数据元素,相邻元素之间有前后关系。
线性表具有以下特点:1.元素之间一对一的顺序关系。
2.除第一个元素外,每个元素都有一个直接前驱。
3.除最后一个元素外,每个元素都有一个直接后继。
常见的线性表有数组、链表等。
本实验主要针对链表进行操作。
三、实验步骤1.创建链表:首先创建一个链表,并给链表添加若干个节点。
节点包括数据域和指针域,数据域存储数据,指针域指向下一个节点。
2.插入节点:在链表中插入一个新的节点,可以选择在链表的头部、尾部或中间插入。
3.删除节点:删除链表中的一个指定节点。
4.查找节点:在链表中查找一个指定数据的节点,并返回该节点的位置。
5.遍历链表:从头节点开始,依次访问每个节点的数据。
四、实验结果与分析1.创建链表结果:我们成功地创建了一个链表,每个节点都有数据域和指针域,数据域存储数据,指针域指向下一个节点。
2.插入节点结果:我们成功地在链表的头部、尾部和中间插入了新的节点。
插入操作的时间复杂度为O(1),因为我们只需要修改指针域即可。
3.删除节点结果:我们成功地删除了链表中的一个指定节点。
删除操作的时间复杂度为O(n),因为我们可能需要遍历整个链表才能找到要删除的节点。
4.查找节点结果:我们成功地在链表中查找了一个指定数据的节点,并返回了该节点的位置。
查找操作的时间复杂度为O(n),因为我们可能需要遍历整个链表才能找到要查找的节点。
5.遍历链表结果:我们成功地遍历了整个链表,并访问了每个节点的数据。
遍历操作的时间复杂度为O(n),因为我们可能需要遍历整个链表。
通过本次实验,我们更加深入地理解了线性表的基本概念和特点,掌握了线性表的基本操作,包括插入、删除、查找等。
【数据结构】线性表的基本操作
【数据结构】线性表的基本操作线性表的基本操作⒈创建线性表⑴静态创建静态创建是指在编译或运行前确定线性表的大小并分配相应的内存空间。
可以使用数组来实现静态创建。
⑵动态创建动态创建是指在运行时根据需要动态分配内存空间。
可以使用链表来实现动态创建。
⒉插入元素⑴头部插入在线性表的头部插入一个元素,即将现有的元素全部后移一位。
⑵中间插入在线性表的指定位置插入一个元素,需要将指定位置之后的元素全部后移一位。
⑶尾部插入在线性表的尾部插入一个元素,即在现有元素的后面新增一个元素。
⒊删除元素⑴头部删除删除线性表的头部元素,即将头部元素后面的元素全部前移一位。
⑵中间删除删除线性表的指定位置元素,需要将指定位置之后的元素全部前移一位。
⑶尾部删除删除线性表的尾部元素。
⒋查找元素⑴按值查找按给定的值,在线性表中查找相应的元素,并返回其位置。
⑵按索引查找按给定的索引,直接在线性表中查找相应的元素。
⒌修改元素⑴按索引修改按给定的索引,直接修改线性表中相应位置的元素。
⑵按值修改按给定的值,在线性表中查找相应的元素,并修改其值。
⒍获取元素个数获取线性表中元素的个数。
⒎判断线性表是否为空判断线性表中是否没有任何元素。
⒏清空线性表将线性表中的元素全部删除,使线性表为空。
⒐销毁线性表释放线性表所占用的内存空间,销毁线性表。
附件:●暂无附件法律名词及注释:暂无相关法律名词及注释。
线性表的插入和删除数据结构
线性表的插入和删除(数据结构) 线性表是一种基本的数据结构,它由一组有序的元素构成,每个元素最多只有一个前驱和一个后继。
在数据结构中,线性表可以通过链式存储和顺序存储两种方式来实现。
其中,链式存储使用节点来存储数据和地址,顺序存储则使用数组来存储数据。
下面就以链式存储为例,介绍一下线性表的插入和删除操作。
一、线性表的插入在线性表中插入一个元素,需要遵循以下步骤:1.申请一个新节点,并将要插入的元素存储在新节点中。
2.如果该元素要插入到链表的头部,直接将该节点插入到头节点的位置,并更新头节点指针;否则,遍历链表直到找到要插入的位置。
3.将新节点插入到要插入的位置,并修改该节点的前驱和后继节点的指针,使其指向新节点。
4.更新头节点指针,使其指向新的头节点。
struct Node {int data;struct Node *next;};void insert(struct Node **head_ref, int new_data){struct Node *temp, *new_node;new_node = (struct Node *)malloc(sizeof(struct Node));new_node->data = new_data;new_node->next = (*head_ref);(*head_ref) = new_node;}在以上示例代码中,insert函数使用了传引用技术的指针来操作头节点指针head_ref。
通过传递头节点的地址,该函数可以修改头节点指针。
函数先将头节点指针所指向的头节点保存到temp节点中,然后将新节点的data域设置为new_data,将新节点的next域设置为头节点原先指向的节点,最后将头节点指针指向新节点。
这样就完成了在链表头部插入一个节点的操作。
二、线性表的删除在线性表中删除一个元素,需要遵循以下步骤:1.遍历链表,找到要删除的元素所在的节点。
实验1 线性表的基本操作
实验一线性表的基本操作一、实验目的(1)掌握线性表顺序存储和链式存储的方法及基本运算的实现。
(2)掌握将算法在VC++6.0语言环境下实现的过程。
二、实验准备(1)复习线性表的定义,掌握顺序存储、链式存储的方法及操作。
(2)复习C语言中指针与结构体的概念、定义方式。
(3)掌握链表的C语言的实现。
(4)实验的计算机中安装了Microsoft VC++ 6.0。
三、实验内容顺序表1)首先创建一个顺序表:从键盘读入一组整数(长度小于等于20),按输入顺序放入顺序表,输入以-1结束(注意-1不放到顺序表内);将创建好的顺序表元素依次输出到屏幕上。
2)在已创建好的顺序表中插入一个元素:从键盘读入需插入的元素值和插入位置,调用插入函数完成插入操作;然后将顺序表元素依次输出到屏幕上。
3)在已创建好的顺序表中删除一个元素:从键盘读入欲删除的元素位置(序号),调用删除函数完成删除操作;然后将顺序表元素依次输出到屏幕上。
算法提示:➢需求分析:1.功能(1)建立一顺序表(2)显示顺序表中每个元素(3)在上述的顺序表中的指定位置插入指定的元素,并输出顺序表中所有数据。
(4)在上述的顺序表中的指定位置删除指定的元素,并输出顺序表中所有数据。
2.输入要求从键盘输入顺序表中所有数据,输入以-1结束(注意-1不放到顺序表内);需插入的数据元素的位置、值;要删除的数据元素的位置(序号)。
3. 测试数据顺序表中所有数据:15,26,58,27,9插入的数据元素的位置、值:1,28;6,28;0,28要删除的数据元素的位置:3➢概要设计:1.数据结构:提示:相关常量和顺序表数据类型定义#define MAXNUM 20#define true 1#define false 0typedef struct{int data[MAXNUM];int length;}list_type;2.模块划分:a)建立顺序表的createlist函数;b)显示输出顺序中每个结点的数据的showlist函数;c)insertlist函数:插入函数。
【数据结构】线性表的基本操作
【数据结构】线性表的基本操作在计算机科学中,数据结构是组织和存储数据的方式,以便能够高效地对数据进行操作和处理。
线性表作为一种常见的数据结构,具有重要的地位和广泛的应用。
接下来,让我们深入了解一下线性表的基本操作。
线性表,简单来说,就是数据元素排成的线性序列。
就像一排整齐的士兵,每个士兵都是一个数据元素。
它可以分为顺序表和链表两种实现方式。
先来说说顺序表。
顺序表是把线性表中的元素依次存放在一组地址连续的存储单元中。
想象一下,这就像是在一个连续的柜子里,一格一格地存放着物品。
在顺序表中,访问元素非常方便,只要知道元素的位置,就能迅速找到它。
比如要找第 5 个元素,直接去第 5 个存储单元就行。
顺序表的基本操作之一是插入元素。
假设我们要在顺序表的第 3 个位置插入一个新元素,那可就有点麻烦了。
首先,要从最后一个元素开始,依次向后移动一位,给新元素腾出位置。
然后,把新元素放到第 3 个位置。
这就像是在一排已经坐好的人中间插入一个新的人,后面的人都得往后挪一挪。
删除元素的操作也类似。
如果要删除第 3 个元素,先把第 3 个元素取出来,然后从第 4 个元素开始,依次向前移动一位。
这就像是把一排人中的某个人请出去,后面的人都要往前坐。
再说说链表。
链表中的元素可以存放在内存中的任意位置,通过指针把它们串起来。
这就像是用绳子把分散的珠子串起来一样。
链表的插入操作相对简单一些。
比如要在链表的第 3 个位置插入一个新元素,只需要找到第 2 个元素,然后让它的指针指向新元素,新元素的指针再指向原来第 3 个元素就行了。
删除操作也不复杂。
要删除第 3 个元素,找到第 2 个元素,让它的指针直接指向第 4 个元素,这样第 3 个元素就从链表中脱离了。
接下来看看查找操作。
在顺序表中查找元素,可以直接通过位置快速访问。
但在链表中,就需要从链表的头开始,沿着指针一个一个地找,直到找到目标元素或者找遍整个链表都没找到为止。
还有创建线性表的操作。
线性表的基本操作实验报告
线性表的基本操作实验报告线性表的基本操作1、需求分析:构建一个顺序表并实现顺序表的一些基本操作,例如创建列表,插入、删除元素,求元素的前驱等功能。
(1) 顺序表中数据元素为整形数字,范围属于int型。
(2) 输出部分操作提示以及功能操作所得到的数据(int型)。
(3) 顺序表建立、删除、插入、查询、判空、判满、查询前后驱等功能。
(4) 测试数据:a)b)2、概要设计:用一个结构定义了一个数组,和数组内容的长度。
主程序使用switch语句对将要进行的操作进行选择,调用各个功能函数。
3、实验源代码如下:#include<iostream>using namespace std;typedef struct{int date[100];int length;}SeqList;SeqList L;SeqList SeqListInit()//初始化顺序表 {cout<<"你定义的顺序表的长度(长度小于)"<<endl;cin>>L.length;cout<<"顺序表里面储存数据为"<<endl;for(int i=0;i<L.length;i++){int a;cin>>a;L.date[i]=a;}return L;}void ListClear()/* 清空顺序表*/{L.length=0;}int ListLength()/* 求顺序表长度*/{cout<<L.length<<endl;return 0;}int ListEmpty()/* 检查顺序表是否为空*/ { if(L.length==0)cout<<"为空"<<endl;elsecout<<"不为空"<<endl;return 0;}int ListFull()/*检查顺序表是否为满*/ { if(L.length==100)cout<<"为满"<<endl;elsecout<<"未满"<<endl;return 0;}void ListTraverse()/* 遍历顺序表*/{for(int i=0;i<L.length;i++)cout<<L.date[i]<<" ";cout<<endl;}int ListGet(int i)/* 从顺序表中查找元素*/ { if(i>=0&&i<L.length)cout<<L.date[i-1]<<endl;return 0;}int ListLocate(int x){for(int i=0;i<L.length;i++)if(L.date[i]==x)cout<<L.date[i];return 0;}void ListInsert(int i, int x){if(i>=0&&i<L.length){for(int m=0;i<=L.length-i;m++)L.date[L.length]=L.date[L.length-1];L.date[i-1]=x;L.length++;}}void ListDelete(int i){if(i>=0&&i<L.length){for(i;i<L.length;i++)L.date[i-1]=L.date[i];L.length--;}}int ListPrior(int e){if(e-2>=0&&e-2<L.length)cout<<L.date[e-2]<<endl;return 0;}int ListNext(int e){if(e>=0&&e<L.length)cout<<L.date[e]<<endl; return 0; }int main(){while(1){int i;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;cin>>i;switch (i){case 1:SeqListInit();break;case 2:ListClear();break;case 3:ListLength();break;case 4:ListEmpty();break;case 5:ListFull();break;case 6:ListTraverse();break;case 7:{int m;cout<<"请输入查找元素的位置"<<endl; cin>>m;ListGet(m);break;}case 8:{int m;cout<<"请输入查找元素"<<endl; cin>>m;ListLocate(m);break;}case 9:{int x;cout<<"请输入插入的元素"<<endl; cin>>x;ListInsert(i,x);break;}case 10:{int m;cout<<"请输入删除的元素"<<endl; cin>>m;ListDelete(m);break;}case 11:{int m;cout<<"请输入元素的位置"<<endl; cin>>m;ListPrior(m);break;}case 12:{int m;cout<<"请输入元素的位置"<<endl; cin>>m;ListNext(m);break;}default:break;}}}4、a) 遇见形参与实参搞混问题,改形参里面的内容并不影响其原本数据。
实验1 线性表的基本操作
ElemType *p=L.elem+1;
while(i<=L.length&&*p!=cur_e)
{
p++;
i++;
}
if(i>L.length)
return*--p;
return 1;
}
}
int NextElem(SqList L,ElemType cur_e,ElemType &next_e)
int i;
p=L.elem;
for(i=1;i<=L.length;i++)
vi(*p++);
cout<<endl;
return 1;
} void print(ElemType &c) {
printf("%d ",c); } // 线性表的单链表存储结构 struct LNode { ElemType data; LNode *next; }; typedef LNode *LinkList; // 另一种定义LinkList的方法 // 操作结果:构造一个空的线性表L Status InitList(LinkList &L) { L=(LinkList)malloc(sizeof(LNode)); // 产生头结点,并使L指向此头结点 if(!L) // 存储分配失败
// 操作结果:用e返回L中第i个数据元素的值 if(i<1||i>L.length)
exit(1); e=*(L.elem+i-1); return 1; } int equal(ElemType c1,ElemType c2) { // 判断是否相等的函数,Union()用到 if(c1==c2)
【数据结构】线性表的基本操作
【数据结构】线性表的基本操作【数据结构】线性表的基本操作【一、概述】线性表是一种常见的数据结构,它是由一组具有相同特性的数据元素组成的有序序列。
线性表的基本操作包括插入、删除、查找和修改等操作,本文将对这些操作进行详细介绍。
【二、插入操作】插入操作是向线性表中某个位置插入一个新元素的操作。
插入操作包括头部插入、尾部插入和中间插入三种情况。
首先需要确定插入的位置,然后将插入位置后的元素依次向后移动一位,最后在插入位置处放入新元素。
1.头部插入:将新元素插入线性表的头部位置。
2.尾部插入:将新元素插入线性表的尾部位置。
3.中间插入:将新元素插入线性表的任意中间位置。
【三、删除操作】删除操作是从线性表中删除某个元素的操作。
删除操作包括删除头部元素、删除尾部元素和删除中间元素三种情况。
首先需要确定删除的位置,然后将删除位置后的元素依次向前移动一位,最后删除最后一个元素位置上的元素。
1.删除头部元素:删除线性表的头部元素。
2.删除尾部元素:删除线性表的尾部元素。
3.删除中间元素:删除线性表的任意中间位置的元素。
【四、查找操作】查找操作是在线性表中搜索某个元素的操作。
查找操作包括按值查找和按位置查找两种情况。
1.按值查找:根据给定的元素值,在线性表中搜索并返回该元素的位置。
2.按位置查找:根据给定的位置,返回该位置上的元素值。
【五、修改操作】修改操作是修改线性表中某个元素的值的操作。
需要先找到要修改的元素位置,然后将其值修改为新的值。
【附件】本文档涉及附件略。
【法律名词及注释】本文档所涉及的法律名词及注释略。
数据结构课件线性表
目录
CONTENTS
• 线性表的基本概念 • 线性表的实现方式 • 线性表的基本操作 • 线性表操作的效率分析 • 线性表的应用案例
01 线性表的基本概念
线性表的定义
线性表:线性表是一种具有线性 关系的抽象数据类型,其元素之
间存在一对一的顺序关系。
线性表由n个元素组成,每个元 素都有一个唯一的标识符,称为
04 线性表操作的效率分析
顺序存储结构的效率分析
访问元素
顺序存储结构中,访问任意一个元素 的时间复杂度为O(1),因为可以通过 索引直接访问。
插入和删除操作
顺序存储结构中,插入和删除操作的时 间复杂度为O(n),因为需要移动元素来 保持线性表的连续性。
链式存储结构的效率分析
访问元素
链式存储结构中,访问任意一个元素的时间复杂度为O(n),因为需要从头节点 开始遍历链表直到找到目标节点。
VS
详细描述
二维数组是一种二维的数据结构,可以看 作是线性表的扩展。在二维数组中,每个 元素的位置由其行列索引确定,这使得二 维数组在表示矩阵等数学运算中非常方便 。同时,二维数组也可以通过行优先或列 优先的方式进行线性化处理,转化为线性 表的形式进行操作。
哈希表的设计与实现
总结词
哈希表是一种特殊的线性表,通过哈希函数将键映射到数组的索引上,实现快速的查找 操作。
线性表的分类
静态线性表
静态线性表是使用数组实现的线 性表,其大小在创建时确定,且 不可改变。
动态线性表
动态线性表是使用链表或动态数 组实现的线性表,其大小可以动 态地增加或减少储结构是指将线性表中 的元素按照一定的顺序存储在 一片连续的存储空间中。
顺序存储结构的特点是访问速 度快,可以通过索引直接访问 任意元素。
归纳总结线性表的基本操作
归纳总结线性表的基本操作线性表是计算机科学中常用的数据结构,它是由一组具有相同特性的数据元素组成的有序序列。
线性表的基本操作包括插入、删除、查找和修改等操作。
在本文中,我将对线性表的基本操作进行归纳总结,以帮助读者更好地理解和使用线性表。
一、插入操作插入操作是指向线性表中插入一个新的元素。
常见的插入方式包括在指定位置插入元素和在表尾插入元素。
1. 在指定位置插入元素要在线性表的指定位置插入一个元素,需要将插入位置之后的元素依次向后移动一位,然后将欲插入的元素放入空出来的位置。
具体的步骤如下:(1)判断插入位置的合法性,如果位置无效则报错;(2)将插入位置之后的元素依次向后移动一位;(3)将欲插入的元素放入插入位置。
2. 在表尾插入元素要在线性表的表尾插入一个元素,只需要将元素直接放入表尾即可。
二、删除操作删除操作是指从线性表中删除一个元素。
常见的删除方式包括删除指定位置的元素和删除指定元素的操作。
1. 删除指定位置的元素要删除线性表中的某一个元素,需要将该元素之后的元素依次向前移动,然后将最后一个位置置空。
具体步骤如下:(1)判断删除位置的合法性,如果位置无效则报错;(2)将删除位置之后的元素依次向前移动一位;(3)将最后一个位置置空。
2. 删除指定元素要删除线性表中某一个指定的元素,需要遍历整个线性表,找到该元素的位置,然后按照删除指定位置的元素的操作进行删除。
三、查找操作查找操作是指在线性表中寻找某一个元素。
常见的查找方式包括按位置查找和按值查找。
1. 按位置查找要按位置查找线性表中的某一个元素,只需要通过给定的位置,直接访问该位置上的元素即可。
2. 按值查找要按值查找线性表中的某一个元素,需要遍历整个线性表,逐个比较每个元素的值,直到找到目标元素或者遍历结束。
四、修改操作修改操作是指修改线性表中某一个元素的值。
常见的修改方式是通过给定的位置,直接修改该位置上的元素的值。
综上所述,线性表的基本操作包括插入、删除、查找和修改等操作。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
if (i<0 || i>*p_n) return(1);
if (*p_n==MAXSIZE) return(2);
for (j=*p_n+1; j>i; j--)
list[j]=list[j-1];
list[i]=x;
(*p_n)++;
return(0);
}
/*delete in a seq list*/
/*This function inserts a node whose value is b*/
/*before the node whose value is a, if the node is not exist,*/
/*then insert it at the end of the list*/
实验二线性表的基本操作
一、实验目的
1.掌握用C++/C语言调试程序的基本方法。
2.掌握线性表的顺序存储和链式存储的基本运算,如插入、删除等。
二、实验要求
1.C++/C完成算法设计和程序设计并上机调试通过。
2.撰写实验报告,提供实验结果和数据。
3.分析算法,要求给出具体的算法分析结果,包括时间复杂度和空间复杂度,并简要给出算法设计小结和心得。
struct node{
char data;
struct node *next;
};
typedef struct node NODE;
/*This function creates a link_list with N nodes.*/
NODE *create_link_list(int n)
{int i;
for (i=0; i<=n; i++) printf("%d ",list[i]);
printf("\n");
printf("please input the position where you want to insert a value\nposition=");
scanf("%d",&i);
/*deleting*/
printf("The list before deleting is\n");
for (i=0; i<=n; i++) printf("%d ",list[i]);
printf("\n");
printf("please input the position where you want to delete a value\nposition=");
int sq_delete(int list[], int *p_n, int i)
{int j;
if (i<0 || i>=*p_n) return(1);
for (j = i+1; j<=*p_n; j++)
list[j-1] = list[j];
(*p_n)--;
return(0);
}
void main()
三、实验内容:
1.分析并运行以下各子程序的主要功能。
程序1:顺序存储的线性表和运算
#include<stdio.h>
#define MAXSIZE 100
int list[MAXSIZE];
int n;
/*insert in a seqlist*/
int sq_insert(int list[], int *p_n, int i, int x)
scanf("%d",&i);
temp=sq_delete(list,&n,i);
switch(temp)
{case 0:printf("The deleting is successful!\n");
printf("The list is after deleting is\n");
for(i=0; i<=n; i++) printf("%d ",list[i]);
printf("\n");
printf("%d",n);
break;
case 1:printf("The deleting is not successful!");break;}
}
2.分析并运行以下各子程序的主要功能。
程序2链式存储的线性表和运算
#include<stdio.h>
#include<malloc.h>
printf("The list is after insertion is\n");
for(i=0; i<=n; i++) printf("%d ",list[i]);
printf("\n");
printf("%d\n",n);
break;
case 1:
case 2:printf("The insertion is not successful!\n");break;}
printf("please input the value you want to insert.\nx=");
scanf("%d",&x);
temp=sq_insert(list,&n,i,x);
switch(temp)
{case 0:printf("The insertion is successful!\n");
{int i,x,temp;
printf("please input the number for n\n");
printf("n=");
scanf("%d",&n);
for (i=0; i<=n; i++)
{printf("list[%d]=",i);
scanf("%d",&list[i]);}
printf("The list before insertion is\n");
{scanf("%c ", &(p->data));
q=(NODE *)malloc(sizeof(NODE));
printf("test3\n");
p->next=q;
p=q;}
scanf("%c ",&(p->data));
getchar();
p->next=;
return (head);}
NODE *head, *p, *q;
if (n==0) return NULL;
head = (NODE *) malloc(sizeof(NODE));
p = head;
printf("Please input %d chars for the link list\n",n);
for (i=0; i<n; i++)