单链表按位查找的C++程序
北京邮电大学 数据结构 实验一 带头结点的单链表构造
数据结构实验报告实验名称：实验1——单链表的构造学生姓名：XXXXNB班级：XXXX班内序号：学号：XXXX日期：XXXXX1．实验要求根据线性表的抽象数据类型的定义，完成带头结点的单链表的基本功能。
单链表的基本功能：1、构造：使用头插法、尾插法两种方法2、插入：要求建立的链表按照关键字从小到大有序3、删除4、查找5、获取链表长度6、销毁7、其他：可自行定义编写测试main()函数测试线性表的正确性。
2.程序分编程完成单链表的一般性功能如单链表的构造：使用头插法、尾插法两种方法插入：要求建立的链表按照关键字从小到大有序，删除，查找，获取链表长度，销毁用《数据结构》中的相关思想结合C++语言基本知识编写一个单链表结构。
本程序为使用方便，几乎不用特殊的命令，只需按提示输入即可，适合更多的用户使用。
2.1 存储结构单链表的存储结构：2.2 关键算法分析1.头插法自然语言描述：a.在堆中建立新结点b.将a[i]写入到新结点的数据域c.修改新结点的指针域d.修改头结点的指针域,将新结点加入链表中//在构建之初为了链表的美观性构造，进行了排序代码描述：//头插法构造函数template<class T>LinkList<T>::LinkList(T a[], int n){for (int i = n - 1; i >= 1; i--)//冒泡排序，对数组进行从小到大排序{for (int j = 0; j < i; j++){if (a[j]>a[j + 1]){T t = a[j + 1];a[j + 1] = a[j];a[j] = t;}}}front = new Node < T >;//为头指针申请堆空间front->next = NULL;//构造空单链表for (int i = n - 1; i >= 0; i--){Node<T>*s = new Node < T >;//建立新结点s->data = a[i];//将a[i]写入新结点的数据域s->next = front->next;//修改新结点的指针域front->next = s;//修改头结点的指针域，将新结点加入到链表中}}2.尾插法自然语言描述：a.在堆中建立新结点b.将a[i]写入到新结点的数据域c.将新结点加入到链表中d.修改修改尾指针代码描述://尾插法构造函数template<class T>LinkList<T>::LinkList(T a[], int n){front = new Node < T > ;Node<T>*r = front;//命名一个新变量进行转换for (int i = 0; i < n; i++){Node<T>*s = new Node < T > ;s->data = a[i];r->next = s;r = s;}r->next = NULL;}时间复杂度：O(n)3.析构函数自然语言描述：a.新建立一个指针，指向头结点b.移动a中建立的指针c.逐个释放指针代码描述:template<class T>LinkList<T>::~LinkList()//析构函数，销毁链表{Node<T> * p = front;while(p){front = p;p = p->next;delete front;}}4.按位查找函数自然语言描述: a.初始化工作指针p和计数器j，p指向第一个结点，j=1b.循环以下操作，直到p为空或者j等于1b1：p指向下一个结点b2：j加1c.若p为空，说明第i个元素不存在，抛出异常d.否则，说明p指向的元素就是所查找的元素，返回元素地址代码描述:template<class T>Node<T>* LinkList<T>::Get(int i)//按位查找{Node<T> * p = front;int j=0;while(p){if(j<i){p = p->next;j++;}else break;}if(!p) throw"查找位置非法";else return p;}时间复杂度：O(n)5.按值查找函数自然语言描述：a.初始化工作指针p和计数器j，p指向第一个结点，j=1b.循环以下操作，找到这个元素或者p指向最后一个结点b1.判断p指向的结点是不是要查找的值，如果是，返回j;b2.否则p指向下一个结点,并且j的值加一c.如果找到最后一个结点还没有找到要查找的元素，返回查找失败信息代码描述:template<class T>int LinkList<T>::Locate(T x)//按值查找{Node<T> * p = front->next;int j = 1;while(p){if(p->data == x) return j;else{p = p->next;j++;}}return -1;}时间复杂度：O(n)6.插入函数自然语言描述：a.在堆中建立新结点b.将要插入的结点的数据写入到新结点的数据域c.修改新结点的指针域d.修改前一个指针的指针域，使其指向新插入的结点的位置代码描述:template<class T>void LinkList<T>::Insert(int i,T x)//插入函数{Node<T> * p = Get(i-1);if(p){Node<T> * s = new Node<T>;s->data = x;s->next = p->next;p->next = s;}else throw"插入位置非法";}时间复杂度：O(n)7.按位删除函数自然语言描述：a.从第一个结点开始，查找要删除的位数i前一个位置i-1的结点b.设q指向第i个元素c.将q元素从链表中删除d.保存q元素的数据e.释放q元素代码描述:template<class T>T LinkList<T>::Delete(int i)//删除函数{Node<T> *p = Get(i-1);Node<T> *q = p->next;T x=q->data;p->next = q->next;delete q;return x;}8.遍历打印函数自然语言描述: a.判断该链表是否为空链表，如果是，报错b.如果不是空链表，新建立一个temp指针c.将temp指针指向头结点d.打印temp指针的data域e.逐个往后移动temp指针，直到temp指针的指向的指针的next域为空代码描述:template<class T>void LinkList<T>::PrintList()//打印链表{Node<T> * p = front->next;while(p){cout<<p->data<<' ';p = p->next;}cout<<endl;}9.获取链表长度函数自然语言描述：a.判断该链表是否为空链表，如果是，输出长度0b.如果不是空链表，新建立一个temp指针，初始化整形数n为0c.将temp指针指向头结点d.判断temp指针指向的结点的next域是否为空，如果不是，n加一，否则return ne.使temp指针逐个后移，重复d操作，直到temp指针指向的结点的next 域为0，返回n代码描述:template<class T>int LinkList<T>::GetLength()//分析链表长度{Node<T> * p = front;int i=0;while(p){p = p->next;i++;}return i-1;}2.3 其他异常处理采用try catch 函数处理异常如在插入时的异常处理：template<class T>void LinkList<T>::Insert(int i, T x){Node<T>*p = front;if (i != 1) p = Get(i - 1);try{if (p){Node<T>*s = new Node < T > ;s->data = x;s->next = p->next;p->next = s;}else throw i;}catch (int i){cout << "插入到位置 " << i << " 处" << "为错误位置"<<endl;}}3. 程序运行结果主函数流程图：测试截图：初始化链表，菜单创建执行功能：4. 总结.调试时出现了一些问题如：异常抛出的处理，书中并未很好的提及异常处理，通过查阅资料，选择用try catch 函数对解决。
计算机软件技术复习资料
《计算机软件技术》 复习资料（课程代码：11049）习题汇总：（一）1.线性表的链式存储结构与顺序存储结构相比优点是 CD 。
A. 所有的操作算法实现简单 B. 便于随机存取 C. 便于插入和删除 D. 便于利用零散的存储器空间2.线性表是具有n 个 C 的有限序列。
A. 表元素B. 字符C. 数据元素D. 数据项E. 信息项3.若长度为n 的线性表采用顺序存储结构，在其第I 个位置插入一个新元素的算法的时间复杂度为 C 。
（1≤I ≤n+1）A. O(0)B. O(1)C. O(n)D. O(n 2)4.设A 是一个线性表(a 1,a 2,…,a n )，采用顺序存储结构，则在等概率的前提下，平均每插入一个元素需要移动的元素个数为 B ，平均每删除一个元素需要移动的元素个数为A ；若元素插在a i 与a i+1之间(0≤I ≤n-1)的概率为)1()(2+-n n i n ，则平均每插入一个元素所要移动的元素个数为 C ； A. 21-n B.2n C. 312+n D. 413+n 5.下列函数中，按它们在∞→n 时的无穷大阶数，最大的是 D 。
A. log nB. nlog nC. 2n/2D. n!6.所指的结点之后，其语句应为： D 。
A. s->next=p+1; p->next=s;B. (*p).next=s; (*s).next=(*p).next;spnextnext nextC. s->next=p->next; p->next=s->next;D. s->next=p->next; p->next=s;7.将两个各有n个元素的有序表归并为一个有序表时，其最少的比较次数是 A 。
A. nB. 2n-1C. n-1D. 2n8.用单链表表示的链式队列的队头在链表的 A 位置。
A. 链头B. 链尾C. 链中9.若用单链表表示队列，则应该选用 B 。
2022年北京大学计算机科学与技术专业《数据结构与算法》科目期末试卷A(有答案)
2022年北京大学计算机科学与技术专业《数据结构与算法》科目期末试卷A（有答案）一、选择题1、从未排序序列中依次取出一个元素与已排序序列中的元素依次进行比较，然后将其放在已排序序列的合适位置，该排序方法称为（）排序法。
A.插入B.选择C.希尔D.二路归并2、下列排序算法中，占用辅助空间最多的是（）。
A.归并排序B.快速排序C.希尔排序D.堆排序3、计算机算法指的是解决问题的步骤序列，它必须具备（）三个特性。
A.可执行性、可移植性、可扩充性B.可执行性、确定性、有穷性C.确定性、有穷性、稳定性D.易读性、稳定性、安全性4、用不带头结点的单链表存储队列，其队头指针指向队头结点，队尾指针指向队尾结点，则在进行出队操作时（）。
A.仅修改队头指针B.仅修改队尾指针C.队头、队尾指针都可能要修改D.队头、队尾指针都要修改5、下列关于AOE网的叙述中，不正确的是（）。
A.关键活动不按期完成就会影响整个工程的完成时间B.任何一个关键活动提前完成，那么整个工程将会提前完成C.所有的关键活动提前完成，那么整个工程将会提前完成D.某些关键活动若提前完成，那么整个工程将会提前完成6、下列叙述中，不符合m阶B树定义要求的是（）。
A．根结点最多有m棵子树 B．所有叶结点都在同一层上C．各结点内关键字均升序或降序排列 D．叶结点之间通过指针链接7、排序过程中，对尚未确定最终位置的所有元素进行一遍处理称为一趟排序。
下列排序方法中，每一趟排序结束时都至少能够确定一个元素最终位置的方法是（）。
Ⅰ．简单选择排序Ⅱ．希尔排序Ⅲ．快速排序Ⅳ．堆排Ⅴ．二路归并排序A．仅Ⅰ、Ⅲ、Ⅳ B．仅Ⅰ、Ⅱ、Ⅲ C．仅Ⅱ、Ⅲ、Ⅳ D．仅Ⅲ、Ⅳ、Ⅴ8、一个具有1025个结点的二叉树的高h为（）。
A.11B.10C.11至1025之间D.10至1024之间9、有n（n>0）个分支结点的满二叉树的深度是（）。
A.n2-1B.log2（n+1）+1C.log2（n+1）D.log2（n-l）10、在平衡二叉树中插入一个结点后造成了不平衡，设最低的不平衡结点为A，并已知A 的左孩子的平衡因子为0，右孩子的平衡因子为l，则应作（）型调整以使其平衡A.LLB.LRC.RLD.RR二、填空题11、N个顶点的连通图用邻接矩阵表示时，该矩阵至少有______个非零元素。
算法与数据结构实验报告
2015-2016学年第二学期《算法与数据结构》课程实验报告专业软件工程学生姓名成晓伟班级软件141学号1410075094实验学时16实验教师徐秀芳信息工程学院实验一单链表的基本操作一、实验目的1.熟悉C语言上机环境，进一步掌握C语言的基本结构及特点。
2.掌握线性表的各种物理存储表示和C语言实现。
3.掌握单链表的各种主要操作的C语言实现。
4.通过实验理解线性表中的单链表存储表示与实现。
二、主要仪器及耗材普通计算机三、实验内容与要求1、用C语言编写一个单链表基本操作测试程序。
（1）初始化单链表（2）创建单链表（3）求单链表长度（4）输出单链表中每一个结点元素（5）指定位置插入某个元素（6）查找第i个结点元素的值（7）查找值为e 的结点，并返回该结点指针（8）删除第i个结点（9）销毁单链表2、实验要求（1）程序中用户可以选择上述基本操作。
程序启动后，在屏幕上可以菜单形式显示不同功能，当按下不同数字后完成指定的功能，按其他键，则显示错误后重新选择。
（2）要求用线性表的顺序存储结构，带头结点的单链表存储结构分别实现。
（3）主函数实现对基本操作功能的调用。
3、主要代码（1）初始化单链表LinkList *InitList(){ //创建一个空链表,初始化线性表LinkList *L;L=(LinkList *)malloc(sizeof(LinkList));L->next=NULL;return L;}（2）创建单链表//头插法void CreateListF(LinkList *L){LinkList *s;int i=1,a=0;while(1){printf("输入第%d个元素(0表示终止)",i++);scanf("%d",&a);if(a==0)break;s=(LinkList *)malloc(sizeof(LinkList));s->data=a;s->next=L->next;L->next=s;}}（3）求链表长度int ListLength(LinkList *L){ //求链表长度int n=0;LinkList *p=L;while(p->next!=NULL){p=p->next;n++;}return(n);}（4）在指定位置插入元素int InsertList(LinkList *L,int i,ElemType e){LinkList *p=L,*s;int j=0;while(p!=NULL&&j<i-1){p=p->next;j++;} //找出要插入的位置的前一个位置if(p==NULL){return 0;}else{s=(LinkList *)malloc(sizeof(LinkList));s->data=e;s->next=p->next;p->next=s;return 1;}}（5）输出链表void DispList(LinkList *L){ //输出链表LinkList *p=L->next;while(p!=NULL){printf("%d",p->data);p=p->next;}printf("\n");}（6）查找链表中指定元素int GetElem(LinkList *L,int i){ //查找链表中指定元素LinkList *p=L;int j=0;while(j<i&&p!=NULL){j++;p=p->next;}if(p==NULL){return 0;}else{return p->data;}}（7）查找值是e的结点并返回该指针LinkList *LocateElem(LinkList *L,ElemType e){ //查找值是e的结点并返回该指针int i=1;LinkList *p=L;while(p!=NULL)if(p->data==e) return p;}if(p==NULL){return NULL;}}（8）删除元素int ListDelete(LinkList *L,int i,ElemType *e){ //删除元素LinkList *p=L,*q;int j=0;while(p!=NULL&&j<i-1){p=p->next;j++;} //找到要删除元素地址的前一个地址if(p==NULL){ return 0;} //不能删除else{q=p->next;*e=q->data;p->next=q->next;free(q); //删除成功return 1;}}（9）销毁链表void DestroyList(LinkList *L){//销毁链表LinkList *pre=L,*p=L->next;while(p!=NULL){free(pre);pre=p;p=pre->next;}free(pre);}main函数：int main(){LinkList *L;ElemType e;int i;L=InitList();CreateListF(L);DispList(L);printf("输入要查找的元素位置:\n");scanf("%d",&i);e=GetElem(L,i);printf("%d\n",e);printf("单链表长度为:%d\n",ListLength(L));printf("输入要删除元素的位置:");scanf("%d",&i);if (i>ListLength(L)){printf("超出范围重新输入");scanf("%d",&i);}if(ListDelete(L,i,&e)==0){printf("未找到元素\n");}else DispList(L);printf("输入插入元素的位置和值:");scanf("%d%d",&i,&e);InsertList(L,i,e);DispList(L);return 0;}4、测试数据及测试结果输入：23 56 12 28 45输出：四、注意事项1、存储结构定义和基本操作尽可能用头文件实现。
线性表操作实验报告
忻州师范学院计算机科学与技术系实验报告（第六组）组长：梁启超组员：晋丹丹张艳华马军刘雪梅孙钰林刘涛分块调试：把算法分拆成几个功能模块，按C程序结构标准分模块调试；3)错误跟踪有两种方法：错误信息排查法、执行路线跟踪法。
错误信息排查法：根据错误信息进行分类排查，要求分析者对C的错误代码要有足够的了解和认识，有经验的程序员多用此法。
执行路线跟踪法：变量分析法（跟踪变量的值）、插入标签法（插入输出标签），这种方法适合初学者。
4）调试分析不宜面面俱到，具体写出关键问题就行。
分析如下：主函数main()首先调用显示操作菜单函数scan()，再根据用户输入的数字选项分别调用以下函数：（1）createlist_l头插法构造单链表；（2）createlist_l2尾插法构造单链表；两种二选一；（2）listinsert_l向单链表中插入元素;（3）listdelete_l删除单链表中的元素;（4）printlist_l遍历单链表;（5）getelem_l按位序查找单链表;（6）locateElem_l按值查找单链表;由上述结构可知，采用分功能模块调试的方法较合理，即主要功能按以下顺序实现：添加——查找——删除——遍历。
5．使用说明与测试结果程序名为TXL.exe，运行环境为DOS。
程序执行后显示（下图为参考截图例子。
）第一次操作需选择1或者2，并且只能选择一种。
程序执行显示我们选择的的是头插法构造单链表，输入1后显示要输入几个数1我们写5个请输入要插入的数据：我们插入15 25 35 45 55遍历单链表删除表中第2个元素在第3个元素中插入68按位序查找单链表;查找第4个元素五、实验总结（调试和运行程序过程中产生的问题及采取的措施；对算法的程序的讨论、分析，改进设想以及其它经验教训；对实验方式、组织、设备、题目的意见和建议等）附源程序清单：#include<stdio.h>#include<stdlib.h>typedef struct lnode{int data;struct lnode *next;}lnode,*linklist;linklist createlist_l(int n){int i;linklist l,p;l=(linklist)malloc(sizeof(lnode));l->next=NULL;printf("please input the data of :");for(i=n;i>0;--i){p=(linklist)malloc(sizeof(lnode));scanf("%d",&p->data);p->next=l->next;l->next=p;}return l;}linklist createlist_l2(int n){int i;linklist l,p,r;l=(linklist)malloc(sizeof(lnode));l->next=NULL;r=l;printf("please input the data of:");for(i=1;i<=n;i++)。
(完整word版)数据结构C语言版期末考试试题(有答案)
“数据结构”期末考试试题一、单选题(每小题2分，共12分)1．在一个单链表HL中，若要向表头插入一个由指针p指向的结点，则执行( )。
A． HL＝ps p一>next＝HLB． p一>next＝HL；HL＝p3C． p一>next＝Hl；p＝HL；D． p一>next＝HL一>next;HL一>next＝p；2．n个顶点的强连通图中至少含有( )。
A.n—l条有向边B.n条有向边C.n(n—1)／2条有向边D.n(n一1)条有向边3.从一棵二叉搜索树中查找一个元素时，其时间复杂度大致为( )。
A.O(1)B.O(n)C.O(1Ogzn)D.O(n2)4．由权值分别为3，8，6，2，5的叶子结点生成一棵哈夫曼树，它的带权路径长度为( )。
A．24 B．48C． 72 D． 535．当一个作为实际传递的对象占用的存储空间较大并可能需要修改时，应最好把它说明为( )参数，以节省参数值的传输时间和存储参数的空间。
A.整形B.引用型C.指针型D.常值引用型·6．向一个长度为n的顺序表中插人一个新元素的平均时间复杂度为( )。
A．O(n) B．O(1)C．O(n2) D．O(10g2n)二、填空题(每空1分，共28分)1．数据的存储结构被分为——、——、——和——四种。
2．在广义表的存储结构中，单元素结点与表元素结点有一个域对应不同，各自分别为——域和——域。
3．——中缀表达式 3十x*(2.4／5—6)所对应的后缀表达式为————。
4．在一棵高度为h的3叉树中，最多含有——结点。
5．假定一棵二叉树的结点数为18，则它的最小深度为——，最大深度为——· 6．在一棵二叉搜索树中，每个分支结点的左子树上所有结点的值一定——该结点的值，右子树上所有结点的值一定——该结点的值。
7．当向一个小根堆插入一个具有最小值的元素时，该元素需要逐层——调整，直到被调整到——位置为止。
线性表知识点总结
线性表知识点总结一、概述线性表是数据结构中的一种基本结构，它是一种线性的、有序的、可重复的数据结构。
线性表的存储结构有两种：顺序存储和链式存储。
二、顺序存储顺序存储的方式是把线性表的元素按照顺序存储在一个一维数组中，它的优点是随机访问时间复杂度为O(1)，缺点是插入和删除操作时间复杂度为O(n)。
1. 初始化线性表的初始化需要先定义一个结构体，包含数据元素和线性表的长度两个成员。
```c#define MaxSize 100typedef struct{ElemType data[MaxSize];int length;}SqList;```2. 插入线性表的插入操作需要先判断是否有足够的空间进行插入操作，然后将插入位置后面的元素后移，最后将待插入的元素插入到插入位置。
```cStatus ListInsert(SqList &L, int i, ElemType e){int j;if(i<1 || i>L.length+1){return ERROR;}if(L.length>=MaxSize){return ERROR;}for(j=L.length;j>=i;j--){L.data[j]=L.data[j-1];}L.data[i-1]=e;L.length++;return OK;}```3. 删除线性表的删除操作需要先判断要删除的位置是否合法，然后将删除位置后面的元素前移，最后将最后一个元素赋值为空。
```cStatus ListDelete(SqList &L, int i, ElemType &e){int j;if(i<1 || i>L.length){return ERROR;}e=L.data[i-1];for(j=i;j<L.length;j++){L.data[j-1]=L.data[j];}L.length--;return OK;}```4. 查找线性表的按值查找操作需要遍历整个数组进行查找，时间复杂度为O(n)，按位查找可以通过数组下标直接访问。
数据结构-C语言描述(耿国华主编)教案
西安文理学院精品课《数据结构》教案计算机科学系韩利凯《数据结构》第一章绪论[教学目标]掌握数据结构的定义、内容、方法、描述、评价。
[重点、难点]数据结构的研究范围，研究采用的方法，算法规则描述的工具，对算法作性能评价。
[教学方法]用多媒体课件（ ppt ）以及与生活实例相结合等方法讲授，这样便于描述相关概念及学生记笔记，加深他们的印象，使基础知识掌握地比较牢固。
[学习要点]1. 熟悉各名词、术语的含义，掌握基本概念，特别是数据的逻辑结构和存储结构之间的关系。
分清哪些是逻辑结构的性质，哪些是存储结构的性质。
2. 了解抽象数据类型的定义、表示和实现方法。
3．理解算法五个要素的确切含义：①动态有穷性（能执行结束）；②确定性（对于相同的输入执行相同的路径）；③有输入；④有输出；⑤可行性（用以描述算法的操作都是足够基本的）。
4．掌握计算语句频度和估算算法时间复杂度的方法。
1.1 什么是数据结构（定义）首先介绍数据结构的相关名词。
1.数据（Data）数据是描述客观事物的数值、字符以及能输入机器且能被处理的各种符号集合。
2.数据元素（Data Element）数据元素是组成数据的基本单位 ,是数据集合的个体，在计算机中通常作为一个整体进行考虑和处理。
例如：学生登记表是数据，每一个学生的记录就是一个数据元素。
3.数据对象（Data Object）数据对象是性质相同的数据元素的集合，是数据的一个子集。
4.数据结构（DA TA Structure）数据结构是指相互之间存在一种或多种特定关系的数据元素集合，是带有结构的数据元素的集合，它指的是数据元素之间的相互关系，即数据的组织形式。
5.数据类型(Data Type)数据类型是一组性质相同的值集合以及定义在这个值集合上的一组操作的总称。
6.数据抽象与抽象数据类型１）数据的抽象高级语言中提供整型、实型、字符、记录、文件、指针等多种数据类型，可以利用这些类型构造出象栈、队列、树、图等复杂的抽象数据类型。
单链表的操作实现实验报告
题目来源：□√教材页题□√教师补充□自选题目
主要功能描述：链表的初始化、链表的创建（头部插入法、尾部插入法）、求表长、查找（按值查找、按序号查找）、插入、删除、输出、两个有序单链表的合并等。
设计分析：
初始化：为单链表申请头结点空间，将单链表设置为空；创建：（1）头部插入法：（a）初始化空表；（b）申请新结点并赋值；（c）插入新结点；（d）插入第i个元素。
break;
case'1':
puts("\n");
puts("*********************************************************");
puts("* 0---般创建1---头部插入法2---尾部插入法*");
puts("*********************************************************");
r->next=p;
r=p;
}
r->next=NULL;
return h;
}
/*头部插入*/
int CreatfromH(LinkList head)
{
LinkList p;
ElemType x;
puts("输入数据，输入-1000结束输入!");
while(1)
{
scanf("%d",&x);
if(x!=-1000)
while(p!=NULL)
{
printf("\n%d",p->data);
p=p->next;
单链表的基本运算
建表结束*/ { c=getchar(); if(c!=’$’) { s=(Node*)malloc(sizeof(Node)); /*建立新结点 s*/ s->data=c; s->next=L->next; /*将 s 结点插入表头*/ L->next=s; } else flag=0;
3. 结果判断 如找到第 i 个结点，则返回结点 p；
如表查完未找到，则返回空。
【算法描述】
Node * Get (LinkList L, int i) / * 在带头结点的单链表 L 中查找第 i 个结点，若找到(1≤i≤n)，则返回 该结点的存储位置; 否则返回 NULL * / { int j；
【算法描述】
int ListLength(LinkList L)
/*求带头结点的单链表 L 的长度*/
{ Node *p;
p=L->next;
j=0; /*用来存放单链表的长度*/
while(p!=NULL)
{
p=p->next;
j ++;
}
return j; /*j 为求得的单链表长度*/
} /* ListLength */
H
∧
s r
(a)初始化的空表
C1 ∧
(b)申请新结点并赋值
s 指向新申请的结点空间;
s->data:=C1
H
c1 ∧
r
(c)插入第一个结点
s
① r->next=s;
c1 H
实验二：单链表基本运算实现
{
int data; //存放表结点值
struct node *next; //存放表结点的直接后驱元素的地址
} ListNode,*LinkList;
//头插法创建初始链表
LinkList create_h(int size)
{
;//将工作指针p指向后一个结点
;//计数器累加
}
return i;
}
//打印链表中的现有元素
printList(LinkList head)
{
LinkList p;
;//将工作指针p指向第1个结点
{
p=(LinkList)malloc(sizeof(ListNode));//申请新结点的存储空间
scanf("%d",&p->data);//读入新结点的值到data域中
;//将新增结点插到头结点的后面
;//将新增结点插到头结点的后面
printf("————头插法建立链表(1)\n");
printf("————尾插法建立链表(2)\n");
printf("————按位查找元素(3)\n");
printf("————按值查找元素(4)\n");
printf("————插入元素(5)\n");
printf("————删除元素(6)\n");
printList(h);
break;
case 5:
printf("插入元素,请输入要插入元素的值:\n");
计算机二级考试题c语言程序题
二、程序修改题1.给定程序MODI1.C中函数fun的功能是：计算n!。
2.给定程序MODI1.C中函数fun的功能是：依次取出字符串中所有数字字符，形成新的字符串，并取代原字符串。
3.给定程序MODI1.C中的函数Creatlink的功能是创建带头结点的单向链表，并为各结点数据域赋0到m-1的值。
4.给定程序MODI1.C中函数fun的功能是：在字符串的最前端加入n个*号，形成新串，并且覆盖原串。
5.给定程序MODI1.C中函数fun的功能是：对N名学生的学习成绩，按从高到低的顺序找出前m（m<=10）名学生来，并将这些学生数据放在一个动态分配的连续存储区中，此存储区的首地址作为函数值返回。
6.给定程序MODI1.C中函数fun的功能是：比较两个字符串，将长的那个字符串的首地址作为函数值返回。
#include <stdio.h>7.给定程序MODI1.C中函数fun的功能是：求出数组中最大数和次最大数，并把最大数和a[0]中的数对调，次最大数和a[1]中的数对调。
8.给定程序MODI1.C中函数fun的功能是：求k!（k<13），所求阶乘的值作为函数值返回。
例如：若k=10，则应输出：3628800。
9.给定程序MODI1.C中函数fun的功能是：将s所指字符串中的字母转换为按字母序列的后续字母（但Z转换为A，z转换为a），其它字符不变。
10.给定程序MODI1.C中函数fun的功能是：根据整型形参m，计算如下公式的值：11.给定程序MODI1.C中函数fun的功能是：计算s所指字符串中含有t所指字符串的数目，并作为函数值返回。
12.给定程序MODI1.C中函数fun的功能是：将s所指字符串中位于奇数位置的字符或ASCII 码为偶数的字符放入t所指数组中（规定第一个字符放在第0位中）。
13.给定程序MODI1.C是建立一个带头结点的单向链表，并用随机函数为各结点数据域赋值。
2022年长沙学院计算机科学与技术专业《数据结构与算法》科目期末试卷A(有答案)
2022年长沙学院计算机科学与技术专业《数据结构与算法》科目期末试卷A（有答案）一、选择题1、下列说法不正确的是（）。
A.图的遍历是从给定的源点出发每个顶点仅被访问一次B.遍历的基本方法有两种：深度遍历和广度遍历C.图的深度遍历不适用于有向图D.图的深度遍历是一个递归过程2、无向图G=(V，E)，其中：V={a，b，c，d，e，f}，E={(a，b)，(a， e)，(a，c)，(b，e)，(c，f)，(f，d)，(e，d)}，对该图进行深度优先遍历，得到的顶点序列正确的是（）。
A.a，b，e，c，d，fB.a，c，f,e，b，dC.a，e，b，c，f, dD.a，e，d，f，c，b3、算法的计算量的大小称为计算的（）。
A.效率B.复杂性C.现实性D.难度4、已知有向图G=(V，E)，其中V={V1，V2，V3，V4，V5，V6，V7}， E=｛<V1，V2>，<V1，V3>，<V1，V4>，<V2，V5>，<V3，V5>， <V3，V6>，<V4，V6>，<V5，V7>，<V6，V7>｝，G的拓扑序列是（）。
A.V1，V3，V4，V6，V2，V5，V7B.V1，V3，V2，V6，V4，V5，V7C.V1，V3，V5，V2，V6，V7D.V1，V2，V5，V3，V4，V6，V75、循环队列A[0..m-1]存放其元素值，用front和rear分别表示队头和队尾，则当前队列中的元素数是（）。
A.（rear-front+m）%mB.rear-front+1C.rear-front-1D.rear-front6、已知字符串S为“abaabaabacacaabaabcc”，模式串t为“abaabc”，采用KMP算法进行匹配，第一次出现“失配”（s!＝t）时，i＝j＝5，则下次开始匹配时，i和j的值分别（）。
第9章自测卷答案
第8章 查找 自测卷答案一、填空题（每空1分，共10分）1. 在数据的存放无规律而言的线性表中进行检索的最佳方法是 顺序查找（线性查找） 。
2. 线性有序表（a 1，a 2，a 3，…，a 256)是从小到大排列的，对一个给定的值k ，用二分法检索表中与k 相等的元素，在查找不成功的情况下，最多需要检索 8 次。
设有100个结点，用二分法查找时，最大比较次数是 7 。
3. 假设在有序线性表a[20]上进行折半查找，则比较一次查找成功的结点数为1；比较两次查找成功的结点数为 2 ；比较四次查找成功的结点数为 8 ；平均查找长度为 3.7 。
解：显然，平均查找长度＝O （log 2n ）<5次（25）。
但具体是多少次，则不应当按照公式)1(log 12++=n nn ASL 来计算（即（21×log 221）/20＝4.6次并不正确！）。
因为这是在假设n ＝2m -1的情况下推导出来的公式。
应当用穷举法罗列：全部元素的查找次数为＝（1＋2×2＋4×3＋8×4＋5×5）＝74； ASL ＝74/20=3.7 ！！！4．折半查找有序表（4，6，12，20，28，38，50，70，88，100），若查找表中元素20，它将依次与表中元素 28，6，12，20 比较大小。
5. 在各种查找方法中，平均查找长度与结点个数n 无关的查找方法是 散列查找 。
6. 散列法存储的基本思想是由 关键字的值 决定数据的存储地址。
7. 有一个表长为m 的散列表，初始状态为空，现将n （n<m ）个不同的关键码插入到散列表中，解决冲突的方法是用线性探测法。
如果这n 个关键码的散列地址都相同，则探测的总次数是 n(n-1)/2=（ 1＋2＋…＋n-1） 。
(而任一元素查找次数 ≤n-1)二、单项选择题（每小题1分，共27分）（ B ）1．在表长为ｎ的链表中进行线性查找，它的平均查找长度为Ａ. ＡＳＬ＝ｎ; Ｂ. ＡＳＬ＝（ｎ＋１）／２;Ｃ. ＡＳＬ＝n ＋１; Ｄ. ＡＳＬ≈ｌｏｇ２（ｎ＋１）－１（ A ）2．折半查找有序表（4，6，10，12，20，30，50，70，88，100）。
数据结构选择题
1. 〖单选〗从一个长度为n的向量中删除第i个元素（1≤i≤n）时，需向前移动_B___个元素。
A: iB: n-iC: n-i-1D: n-i+12. 〖单选〗在一个单链表中，已知q所指结点是p所指结点的前驱结点，若在q 和p之间插入s结点，则执行__C__。
A: s->next=p->next; p->next=s;B: p->next=s->next; s->next=p;C: q->next=s; s->next=p;D: p->next=s; s->next=q;3. 〖单选〗某个顺序表第一个元素的存储地址是100，每个元素的长度为2，则第6个元素的地址是__A__。
A: 110B: 108C: 100D: 1204. 〖单选〗顺序表中逻辑上相邻的节点其物理位置也__A__。
A: 一定相邻B: 不必相邻C: 按某种规律排列D: 无要求5. 〖单选〗向一个长度为n的顺序表的第i个元素（1≤i≤n+1）之前插入一个元素时，需向后移动___D_个元素。
A: iB: n-iC: n-i-1D: n-i+16. 〖单选〗一维数组的元素起始地址loc[6]=1000，元素长度为4，则loc[8]为__C__。
A: 1000B: 1004C: 1008D: 87. 〖单选〗线性表的顺序存储结构是一种顺序存取的存储结构，线性表的链式存储结构是一种_A___的存储结构。
A: 随机存取B: 顺序存取C: 索引存取D: 散列存取8. 〖单选〗顺序存储结构__C__。
A: 仅适合于静态查找表的存储B: 仅适合于动态查找表的存储C: 既适合静态又适合动态查找表的存储D: 既不适合静态又不适合动态查找表的存储9. 〖单选〗在单链表的一个节点中有__A__。
A: 1个指针B: 2个指针C: 0个指针D: 3个指针10. 〖单选〗使用双向链表存储数据，其优点是可以___A_。
数据结构之线性表详细解答
二章线性表线性表是最简单、最基本、也是最常用的一种线性结构。
它有两种存储方法：顺序存储和链式存储，它的主要基本操作是插入、删除和检索等。
2.1 线性表的逻辑结构2.1.1 线性表的定义线性表是一种线性结构。
线性结构的特点是数据元素之间是一种线性关系，数据元素“一个接一个的排列”。
在一个线性表中数据元素的类型是相同的，或者说线性表是由同一类型的数据元素构成的线性结构。
在实际问题中线性表的例子是很多的，如学生情况信息表是一个线性表：表中数据元素的类型为学生类型; 一个字符串也是一个线性表：表中数据元素的类型为字符型，等等。
综上所述，线性表定义如下：线性表是具有相同数据类型的n(n>=0)个数据元素的有限序列，通常记为：(a1，a2，… a i-1，a i，a i+1，…a n)其中n为表长，n＝0 时称为空表。
表中相邻元素之间存在着顺序关系。
将a i-1 称为a i 的直接前趋，a i+1 称为a i 的直接后继。
就是说：对于a i，当i=2，...，n 时，有且仅有一个直接前趋a i-1.，当i=1，2，...，n-1 时，有且仅有一个直接后继a i+1，而a1 是表中第一个元素，它没有前趋，a n 是最后一个元素无后继。
需要说明的是：a i为序号为i 的数据元素（i=1,2,…,n），通常我们将它的数据类型抽象为datatype，datatype根据具体问题而定，如在学生情况信息表中，它是用户自定义的学生类型; 在字符串中，它是字符型; 等等。
2.1.2 线性表的基本操作在第一章中提到，数据结构的运算是定义在逻辑结构层次上的，而运算的具体实现是建立在存储结构上的，因此下面定义的线性表的基本运算作为逻辑结构的一部分，每一个操作的具体实现只有在确定了线性表的存储结构之后才能完成。
线性表上的基本操作有：⑴线性表初始化：Init_List(L)初始条件：表L不存在操作结果：构造一个空的线性表⑵求线性表的长度：Length_List(L)初始条件：表L存在操作结果：返回线性表中的所含元素的个数⑶取表元：Get_List(L,i)初始条件：表L存在且1<=i<=Length_List(L)操作结果：返回线性表L中的第ｉ个元素的值或地址⑷按值查找：Locate_List(L,x)，ｘ是给定的一个数据元素。
数据结构（c语言版）课后习题答案完整版
第1章 绪论5．选择题：CCBDCA6．试分析下面各程序段的时间复杂度。
．试分析下面各程序段的时间复杂度。
（1）O （1） （2）O （m*n ） （3）O （n 2） （4）O （log 3n ）（5）因为x++共执行了n-1+n-2+……＋1= n(n-1)/2，所以执行时间为O （n 2） （6）O(n )第2章 线性表1．选择题．选择题babadbcabdcddac 2．算法设计题．算法设计题（6）设计一个算法，通过一趟遍历在单链表中确定值最大的结点。
）设计一个算法，通过一趟遍历在单链表中确定值最大的结点。
ElemType Max (LinkList L ){if(L->next==NULL) return NULL; pmax=L->next; //假定第一个结点中数据具有最大值假定第一个结点中数据具有最大值 p=L->next->next;while(p != NULL ){//如果下一个结点存在if(p->data > pmax->data) pmax=p; p=p->next; }return pmax->data;（7）设计一个算法，通过遍历一趟，将链表中所有结点的链接方向逆转，仍利用原表的存储空间。
的存储空间。
void inverse(LinkList &L) { // 逆置带头结点的单链表 Lp=L->next; L->next=NULL; while ( p) {q=p->next; // q 指向*p 的后继 p->next=L->next;L->next=p; // *p 插入在头结点之后 p = q; }}、空间(n)、空间（10）已知长度为n的线性表A采用顺序存储结构，请写一时间复杂度为O(n)的数据元素。
复杂度为O(1)的算法，该算法删除线性表中所有值为item的数据元素。
C语言-链表
NWPU—CC—ZhangYanChun
13
┇
void main( )
{┇
for(i=1; i<=N; i++)
/*建立链表*/
{┇
}
for(i=1; i<=N; i++)
/*输出链表*/
{ if(i==1) p1=head;
/*p1指向首节点*/
else p1=p1->next; /*p1指向下一节点*/
第第9十页，一共2章8页。 结构体与共用体
NWPU—CC—ZhangYanChun
10
3) 重复第2步，建立并链接多个节点直至所需长
度，将末尾节点的next成员赋值0。
head
1048 p1 1370 p1
2101
2304
1012
2918
89.5
90
85
操作：
1370
1012
NULL
pp22
p2
p1=(struct student *)malloc(len);
成功，返回存储块起始指针，该指针类型为
void *；否则返回空指针(NULL)。
内存释放函数原形：void free(void *p); 功能：释放p所指向的内存块。
包含文件：malloc.h、stdlib.h中均有其原型声明。
C 程序设计
第第4十页，一共2章8页。 结构体与共用体
NWPU—CC—ZhangYanChun
第第5十页，一共2章8页。 结构体与共用体
NWPU—CC—ZhangYanChun
6
6) 链表的类型
单链表：每个节点只有一个指向后继节点的指针 双向链表：每个节点有两个用于指向其它节点的指针；
C语言程序设计实验报告(实验大纲+过程)
《C法式设计》实验教学年夜纲之欧侯瑞魂创作一、适用范围年夜纲适用信息管理专业本科教学使用.二、课程名称C法式设计三、学时数与学分总学时：90 总学分： 4实验学时：28 实验学分：1四、教学目的和基本要求目的：通过C法式设计实验,培养学生对学习法式设计的兴趣,加深对讲授内容的理解,尤其是通过上机来掌握语法规则,使学生全面了解 C 语言的特点,熟练掌握C 语言法式设计的基本方法和编程技巧.基本要求：了解和熟悉C语言法式开发的环境；学会上机调试法式,善于发现法式中的毛病,而且能很快地排除这些毛病,使法式能正确运行,到达实验知识和理论知识的融会贯通.上机实验前,学生必需事先根据题目的内容编好法式,然后在实验时输入法式、调试法式、直至运行结果正确为止,上机结束后,应整理出实验陈说.五、实验项目与学时分配注：带*的实验项目为选做实验项目六、教材、讲义及参考书《C法式设计题解与上机指导》谭浩强主编清华年夜学出书社七、实验成果评定法子实验成果=平时实验暗示+实验陈说.实验成果占总成果的20%.实验成果以品级形式给出,评定品级分优、良、中、及格、不及格五类.1、平时考核：上机实验前,学生必需事先根据题目的内容编好法式,然后在实验时输入法式、调试法式、直至运行结果正确为止.在实验中,教师可根据学生编程把持能力、观察和分析及运用知识能力、法式编制正确性以及学生的课堂纪律、实验态度、坚持实验室卫生等方面的暗示进行综合考核.2、实验陈说：学生实验后应按时完成实验陈说.八、实验教学年夜纲说明本年夜纲共安插28学时的实验,其中带*号实验项目为选做实验项目,实际课时为18学时.实验项目多为设计性实验项目,每个设计性实验项目中都包括数个小的设计性题目,其中带*号的题目为选做题目,有时间和有能力的同学可以选做.九、实验项目实验一 C法式的运行环境和运行一个C法式的方法一、实验目的1.了解Visual C++6.0编译系统的基本把持方法,学会自力使用该系统.2.了解在该系统上如何编纂、编译、连接和运行一个C法式.3.通过运行简单的C法式,初步了解C源法式的特点.二、实验内容1.用编纂法式,输入教材第一章例法式,并进行编译和运行.应了解所用的系统是用什么命令进行编译和连接运行的.编译和连接后所获得的目标法式的后缀是什么形式的？2.编写一个C法式,输出以下信息：****************************very good!****************************,了解如何在运行时向法式变量输入数据.实验二数据类型、运算符和表达式一、实验目的1.掌握C语言数据类型,熟悉如何界说一个整型、字符型、实型变量,以及对它们赋值的方法,了解以上类型数据输出时所用格式转换符.2.学会使用C的有关算术运算符,以及包括这些运算符的表达式,特别是自加(++)和自减(--)运算符的使用.二、实验内容1.输入并运行以下法式：main( ){ char c1,c2;c1=97;c2=98;printf(“%c %c\n”,c1,c2);printf(“%d %d\n”,c1,c2);}在此基础上①将第三行、第四行改为:c1=321;c2=353;再使之运行,分析其运行结果.②将第二行改为：int c1,c2;再使之运行,分析其运行结果..2.输入并运行以下法式：main( ){int i=8,j=10,m,n;m=++i;n=j++;printf(“%d,%d,%d,%d\n”,i,j,m,n);}分别作以下改动并运行：①法式改为:main( ){int i=8,j=10;printf(“%d,%d\n”,i++,j++);}②在②的基础上,将printf语句改为：printf(“%d,%d\n”,++i,++j);③再将printf语句改为：printf(“%d,%d,%d,%d\n”,i,j, i++,j++);④法式改为：main( ){int i=8,j=10,m=0,n=0;;m+=i++;n-=--j;printf(“i=%d,j=%d,m=%d,n=%d\n”,i,j,m,n);}3. 请将下列给出的两个法式段分别输入计算机后,分析其运行结果：①main(){ int num;num=32767;printf(“num=%d\n”,++num);}② main(){ int a=-2;printf(“%d, %d\n”,a, a--);}实验三最简单的C法式设计一、实验目的1.掌握C语言中使用最多的一种语句——赋值语句的使用.2.掌握数据的输入输出的方法,能正确使用各种格式转换符.二、实验内容1.上机输入以下法式：main( ){int a,b;float c;scanf(“%d%d%f”,&a,&b,&c);printf(“a=%-4d,b=%4d,c=%f,c=%.2f\n”,a,b,c,c);}要使a=3,b=4,c=12.3456,在键盘上应如何输入？有几种方式？2.若将输入函数改为scanf(“%d, %d ,%f”,&a,&b,&c);应该如何输入数据？3.上机输入以下法式：main( ){int a; float b; char c;scanf(“%4d%5f%3c”,&a,&b,&c);printf(“a=%d,a=%o,a=%x,b=%8.3f,b=%4.0f,c=%c\n”,a,a,a,b, b,c);}要使a=77,b=4.56,c= ‘A’,在键盘上应如何输入？4.输入两面整型变量a、b的值,输出下列算式以及运算结果.a+b、a-b、a*b、a/b、(float)a/b、a%b每个算式占一行.如a即是10,b即是6,a+b应输入为：10+6=165.编写法式,用getchar函数读入两个字符c1、c2,然后分别用putchar函数和printf函数输出这两个字符.上机运行法式,比力用printf和putchar函数输出字符的特点.实验四选择结构法式设计一、实验目的1.了解C语言暗示逻辑量的方法(以0代表“假”,以1代表“真”)；2.学会正确使用逻辑运算符和逻辑表达式；3.熟练掌握if语句和switch语句.二、实验内容先编法式,解以下问题,然后上机调试运行法式.1.有一个函数用scanf函数输入x的值(分别为x<1、1～10、≥10三种情况),求y值.2.给出一个百分制成果,要求输出成果品级‘A’,‘B’,‘C’,‘D’,‘E’.90分以上为‘A’,80～89分为‘B’,70～79分为‘C’,60～69分为‘D’,60分以下为‘E’.要求分别用if语句和switch语句实现3.输入一个三位数,若此数是水仙花数输出“Y”,否则输出“N”, 若输入值不是三位数输出“data error”.提示：水仙花数是一个三位数,组成这个三位数的三个数字的立方和与这个三位数相等.如：153=13+53+33.判断是否是水仙花数需把构成三位数的三个数字分离出来并存入变量.实验五循环控制一、实验目的1.熟悉用while语句,do-while语句和for语句实现循环的方法.2.掌握在法式设计中用循环的方法实现各种算法(如穷举、迭代、递推等).二、实验内容编法式并上机调试运行.1.输入两个正整数,求其中最年夜公约数和最小公倍数.2.输入一行字符,分别统计出其中的英文字母、空格、数字和其它字符的个数.3.打印出以下图案：*************************4.编程求1!+2!+3!+……+20!.实验六数组一、实验目的1.掌握一维数组和二维数组的界说、赋值和输入输出的方法；2.掌握字符数组和字符串函数的使用.3.掌握与数组有关的算法(特别是排序算法).二、实验内容编法式并上机调试运行.1. 编写法式,用scanf函数输入10个整数的数列,先将整数依照从年夜到小的顺序进行排序,然后输入一个整数拔出到数列中,使数列坚持从年夜到小的顺序.2.有15个数寄存在一个数组中,输入一个数,要求用折半查找法找出该数是数组中第几个元素的值,如果该数不在数组中,则输出“无此数” ,而且可以实现连续查找.15个数用赋初值的方法在法式中给出,要找的数用scanf函数输入.3.将以下二维数组中数按列的顺序寄存到一个一维数组中.二维数组的内容是11 22 33 4411 22 33 4411 22 33 44则一维数组中的内容是11 11 11 22 22 22 33 33 33 44 44 444.将两个字符串联接起来,不要用strcat函数.5.从键盘输入5个字符串,找出最长的字符串和最年夜的字符串.实验七函数一、实验目的1.掌握界说函数的方法；2.掌握函数实介入形参的对应关系,以及“值传递”的方式；3.掌握函数的嵌套调用和递归调用的方法；4.掌握全局变量和局部变量,静态变量和静态变量的概念和使用方法.二、实验内容编法式并上机调试运行之.1.写一个判断素数的函数,在主函数输入一个整数,输出是否是素数的信息.2.两个函数,分别求两个整数的最年夜公约数和最小公倍数,用主函数调用这两个函数,并输出结果.两个整数在主函数中输入,并传送给函数1,求出的最年夜公约数返回主函数,然后再与两个整数一起作为实参传递给函数2,以求出最小公倍数,返回到主函数输出最年夜公约数和最小公倍数.3.已知二阶Fibonacci数列：0 若n=0Fib(n)= 1 若n=1Fib(n-1)+Fib(n-2) 其他情况界说递归函数求Fib(n).4. 编写函数,求 10 1!n实验八指针一、实验目的1.掌握指针的概念,会界说和使用指针变量；2.学会使用数组的指针和指向数组的指针变量；3.学会使用字符串的指针和指向字符串的指针变量；4.学会使用指向函数的指针变量；5.了解指向指针的指针的概念及其使用方法.二、实验内容编法式并上机调试运行法式（都要求用指针处置）.1.界说函数void fun(int x[ ],int *max,int *min),找出数组x中的最年夜值和最小值,最年夜值和最小值通过形参指针max和min传回.2.编写一个函数comp(s1,s2)实现两个字符串的比力.如果s1=s2,则函数返回值为0；如果s1≠s2,返回它们二者第一个分歧字符的ASCII码差值(如“BOY”与“BAD”,第二个字母分歧,“O”与“A”之差为79-65=14)；如果s1>s2,则输出正值；如s1<s2则输出负值.两个字符串s1,s2由main函数输入,strcmp函数的返回值也在main函数输出.3.从键盘输入一个字符串与一个指定字符,调用函数,将字符串中呈现的指定字符全部删除.4．将一个３×３的矩阵转置,用一函数实现.在一主函数中用scanf函数输入以下矩阵元素：１３５７９１１１３１５１７将数组名作为函数参数,在执行函数的过程中实现矩阵转置,函数调用结束后在主函数中输出转置后的矩阵.实验九结构体和共用体一、实验目的1.掌握结构体类型变量的界说和使用；2.掌握结构体类型数组的概念和应用；3.掌握链表的概念,初步学会对链表进行把持；4.掌握共用体的概念与使用.二、实验内容编法式,然后上机调试运行.1.有3个学生,每个学生的数据包括学号、三门课的成果,要求用input函数实现从键盘输入学生数据,用average函数求每个人的平均分,用output函数打印学生数据及平均成果.2.建立一个带有头结点的单链表,每个结点包括：学号、年龄,并输出链表中所有结点的数据.在链表中查找年龄最年夜的结点,并将链表中即是此年龄的结点删除（年龄最年夜的结点可能不止一个）.*3.将一个链表按逆序排列,即将链头当链尾,链尾当链头.4.上机输入如下法式：main( ){union bt{int k; char c[2];}a;a.k= -7;printf(“%o,%o\n”,a.c[0],a.c[1]);}分析其运行结果.实验十位运算一、实验目的1.掌握按位运算的概念和方法,学会使用位运算符；2.学会通过位运算实现对某些位的把持.二、实验内容编写法式,上机调试并运行.1.编一个函数getbits,从一个16位的单位中取出某几位(即该几位保管原值,其余位为0).函数调用形式为：getbits(value,n1,n2)value为该16位数的值,n1为欲取出的起始位,n2为欲取出的的结束位.如：getbits(0101675,5,8)暗示对八进制数101675,取出其从左面起的第5位到第8位.要求把这几位数用八进制数打印出来.注意,应当将这几位数右移到最右端,然后用八进制形式输出.2.利用位运算把持,实现交换两个变量的值.3.将一个十六进制整数的各位循环左移4位,然后用十六进制形式输出.实验十一文件一、实验目的1.掌握文件以及缓冲文件系统、文件指针的概念；2.学会使用文件翻开、关闭、读、写等文件把持函数.3.学会用缓冲文件系统对文件进行简单的把持.二、实验内容编写法式并上机调试运行.1.编法式求100以内的素数,分别将它输出到显示器屏幕和x.txt文件中,要求每行5个数.2.从键盘输入几本书的数据,每本书的数据包括条形码、书名和价格,将每项数据分别写入文本文件s.txt和二进制文件s.dat.*3.从上题的文本文件s.txt或二进制文件s.dat中读入每本书的数据,计算所有书的平均价格.要求用input函数读入,average函数求平均价格.统计与信息学院实验过程与步骤实验①1、运行2、输入#include<stdio.h>main(){char c1,c2;c1=321;c2=353;printf("%c %c\n",c1,c2);printf("%d %d\n",c1,c2);}3、编译,无毛病、无警告后运行,结果如下：4、在步伐2的基础上将第三行、第四行改为：c1=321;c2=353;5、编译,无毛病、无警告后运行,结果提示：aa.obj - 0 error(s), 2 warning(s)6、在步伐2的基础上将第二行改为：int c1,c2;7、编译,无毛病、无警告后运行,结果如下：实验②1、输入#include<stdio.h>main(){int i=8,j=10,m,n;m=++i;n=j++;printf("%d,%d,%d,%d\n",i,j,m,n);}实验③1、输入#include<stdio.h>main(){int num;num=32767;printf("num=%d\n",++num);}2、编译,无毛病、无警告后运行,结果如下：2、编译,无毛病、无警告后运行,结果如下：3、将步伐2法式改为：#include<stdio.h>main(){int i=8,j=10;printf("%d,%d\n",i++,j++);}4、编译,无毛病、无警告后运行,结果如下：5、在步伐3的基础上,将printf语句改为：printf(“%d,%d\n”,++i,++j);6、编译,无毛病、无警告后运行,结果如下：7、在步伐3的基础上,将printf语句改为：printf(“%d,%d,%d,%d\n”,i,j, i++,j++);8、编译,无毛病、无警告后运行,结果如下：9、将步伐2法式改为：#include<stdio.h>main(){int i=8,j=10,m=0,n=0;m+=i++,n-=--j;printf("i=%d,j=%d,m=%d,n=%d\n",i,j,m,n);}10、编译、运行,结果如下：3、输入#include<stdio.h>main(){int a=-2;printf("%d,%d\n",a,a--);}4、编译,无毛病、无警告后运行,结果如下：实验总结统计与信息学院《C法式设计》实验陈说（三）学号：姓名：班级：成果：实验名称：最简单的C法式设计指导教师：实验日期：实验地址：实验软件（主要仪器设备）：实验要求1.掌握C语言中使用最多的一种语句——赋值语句的使用.2.掌握数据的输入输出的方法,能正确使用各种格式转换符.实验过程与步骤实验①1、运行2、输入#include<stdio.h>main(){int a,b;float c;scanf("%d%d%f",&a,&b,&c);printf("a=%-4d,b=%4d,c=%f,c=%.2f\n",a,b,c,c);}3、编译,无毛病、无警告后运行,结果如下：有空格、tab、回车三种输入方式.4、将步伐2中的scanf("%d%d%f",&a,&b,&c);改为scanf(“%d, %d ,%f”,&a,&b,&c);5、编译,无毛病、无警告后运行,结果如下：实验②1、输入#include<stdio.h>main(){int a;float b;char c;scanf("%4d%5f%3c",&a,&b,&c);printf("a=%d,a=%o,a=%x,b=%8.3f,b=%4.0f,c=%c\n",a,a,a,b,b,c);}2、编译,无毛病、无警告后运行,结果如下：实验③（1）a+b1、输入#include<stdio.h>main(){int a,b,c;scanf("%d,%d",&a,&b);c=a+b;printf("%d+%d=%d\n",a,b,c);}2、编译,无毛病、无警告后运行,结果如下：（2）a-b1、输入#include<stdio.h>main(){int a,b,c;scanf("%d,%d",&a,&b);c=a-b;printf("%d-%d=%d\n",a,b,c);}2、编译,无毛病、无警告后运行,结果如下：（3）a*b1、输入#include<stdio.h>main(){int a,b,c;scanf("%d,%d",&a,&b);c=a*b;printf("%d*%d=%d\n",a,b,c);}2、编译,无毛病、无警告后运行,结果如下：实验④（1）getchar输出1、输入#include<stdio.h>int main(){char c1,c2;c1=getchar();c2=getchar();putchar(c1);putchar(c2);return 0;} （4）a/b1、输入#include<stdio.h>main(){int a,b,c;scanf("%d,%d",&a,&b);c=a/b;printf("%d/%d=%d\n",a,b,c);}2、编译,无毛病、无警告后运行,结果如下：（5）(float)a/b1、输入#include<stdio.h>main(){int a,b,c;scanf("%d,%d",&a,&b);c=(float)a/b;printf("%d/%d=%d\n",a,b,c);}2、编译,无毛病、无警告后运行,结果如下：（6）a%b1、输入#include<stdio.h>main(){int a,b,c;scanf("%d,%d",&a,&b);c=a%b;printf("%d%%%d=%d\n",a,b,c);}2、编译,无毛病、无警告后运行,结果如下：（2）printf输出1、输入#include<stdio.h>int main(){char c1,c2;c1=getchar();c2=getchar();printf("%c%c\n",c1,c2);return 0;}2、编译,无毛病、无警告后运行,结果如下：2、编译,无毛病、无警告后运行,结果如下：实验总结学号：姓名：班级：成果：实验名称：选择结构法式设计指导教师：张雄实验日期：实验地址：实验软件（主要仪器设备）：实验要求1.了解C语言暗示逻辑量的方法(以0代表“假”,以1代表“真”)；2.学会正确使用逻辑运算符和逻辑表达式；3.熟练掌握if语句和switch语句.实验过程与步骤实验①1、运行.2、输入#include<stdio.h>int main(){int x,y;scanf("%d",&x);if(x<1)y=x;else if(x>=10)y=3*x-11;elsey=2*x-1;printf("x=%d,y=%d\n",x,y);return 0;}3、编译,无毛病、无警告后运行,结果如下：X<1时,1=<x<10时,x>=10时,（2）switch语句1、输入#include<stdio.h>main(){float x;int y;char ch;printf("Your score:");scanf("%f",&x);y=x/10;switch(y){case 10:case 9:ch='A';break;case 8:ch='B';break;case 7:ch='C';break;case 6:ch='D';break;default:ch='E';}printf("%c\n",ch);return 0;}2、编译,无毛病、无警告后运行,结果如下：实验②（1）if语句1、输入#include<stdio.h>main(){float x;char ch;scanf("%f",&x);if(x>=90) ch="A";else if(x>=80) ch="B";else if(x>=70) ch="C";else if(x>=60) ch="D";else ch="E";printf("%c\n",ch);}2、编译,无毛病、无警告后运行,结果如下：实验③：（水仙花数）1、输入#include<stdio.h>int main(){int m,a,b,c;scanf("%d",&m);if(m/100==0){printf("data error\n");return 0;}a=m%10;b=(m/10)%10;c=m/100;if(m==a*a*a+b*b*b+c*c*c){printf("Y\n",m);return 0;}else{printf("N\n",m);return 0;}}2、编译,无毛病、无警告后运行,结果如下：实验总结学号：姓名：班级：成果：实验名称：循环控制指导教师：实验日期：实验地址：实验软件（主要仪器设备）：实验要求1.熟悉用while语句,do-while语句和for语句实现循环的方法.2.掌握在法式设计中用循环的方法实现各种算法(如穷举、迭代、递推等).实验过程与步骤实验①：输入两个正整数,求其中最年夜公约数和最小公倍数.（1）求最年夜公约数1、输入#include<stdio.h>main(){int m,n,i,t;scanf("%d%d",&m,&n);if(n<m){t=n;n=m;m=t;}i=m;while(1){if(m%i==0&&n%i==0) break;i--;}printf("它们的最年夜公约数是:%d\n",i);return 0;}2、编译,无毛病、无警告后执行,结果如下：（2）求最小公倍数1、输入#include<stdio.h>main(){int m,n,i,t;scanf("%d%d",&m,&n);if(n<m){t=n;n=m;m=t;}实验②：输入一行字符,分别统计出其中的英文字母、空格、数字和其它字符的个数.1、输入#include<stdio.h>main(){char c;int letter,space,number,other;letter=space=number=other=0;do{c=getchar();if(c>='a'&&c<='z'||c>='A'&&c<='Z')letter++;else if(c>='0'&&c<='9')number++;else if(c==' ')space++;elseother++;}while(c!='\n');printf("letter=%d,space=%d,number=%d,other=%d\n",letter,space,number,other);return 0;}i=m;while(1){if(i%m==0&&i%n==0) break;i++;}printf("它们的最小公倍数是:%d\n",i);return 0;}2、编译,无毛病、无警告后执行,结果如下：实验⑤：编写法式输出乘法表1、输入#include<stdio.h>main(){int i,j;for(i=1;i<=9;i++){for(j=1;j<=i;j++)printf("%d*%d=%-3d",j,i,i*j);printf("\n");}system("pause");}2、编译,无毛病、无警告后运行,结果如下：for(j=1;j<=2*i+1;j++)printf("*");printf("\n");}for(i=n-1;i>=0;i--){for(j=1;j<=n-i;j++)printf(" ");for(j=1;j<=2*i+1;j++)printf("*");printf("\n");}}2、编译,无毛病、无警告后运行,结果如下：实验④：编程求1!+2!+3!+……+20!.1、输入#include<stdio.h>2、编译,无毛病、无警告后执行,结果如下：实验③：打印出以下图案：7行7列菱形1、输入#include<stdio.h>#define n 3int main(){int i,j;for(i=0;i<=n;i++){for(j=1;j<=n-i;j++)printf(" "); int main(){int n,m=1,sum=0;for(n=1;n<=20;n++){m=n*m;sum=sum+m;}printf("1+2!+3!...+20!=%d\n",sum);}2、编译,无毛病、无警告后运行,结果如下：实验总结学号：姓名：班级：成果：实验名称：数组指导教师：实验日期：实验地址：实验软件（主要仪器设备）：实验要求1.掌握一维数组和二维数组的界说、赋值和输入输出的方法；2.掌握字符数组和字符串函数的使用.3.掌握与数组有关的算法(特别是排序算法).实验过程与步骤实验①：编写法式,用scanf函数输入10个整数的数列,先将整数依照从年夜到小的顺序进行排序,然后输入一个整数拔出到数列中,使数列坚持从年夜到小的顺序.1、输入#include<stdio.h>main (){void Rank(int N,int n[]);int i,j,k;int n[11];for(i=0;i<10;i++)scanf("%d",&n[i]);Rank(10,n);scanf("%d",&k);if(k>n[9])n[10]=k;else{for(i=0;n[i]<=k;i++);for(j=9;j>=i;j--)n[j+1]=n[j];n[i]=k;}for(i=0;i<=10;i++)printf("%-4d",n[i]);printf("\n");}void Rank(int N,int n[]){int i,k,t;for(k=1;k<=N-1;k++)for(i=N-1;i>=k;i--)if(n[i-1]>n[i])实验②：有15个数寄存在一个数组中,输入一个数,要求用折半查找法找出该数是数组中第几个元素的值,如果该数不在数组中,则输出“无此数” ,而且可以实现连续查找.15个数用赋初值的方法在法式中给出,要找的数用scanf函数输入.1、输入#include<math.h>main(){static int i,j,m,a[15]={2,10,13,24,35,59,68,78,98,102,234,526,649,758,893};scanf("%d",&m);for(j=0;j<15;j++)printf("%4d",a[j]);printf("\n");i=7;while(fabs(i-7)<8){if(m<a[7]){{t=n[i];n[i]=n[i-1];n[i-1]=t;}for(i=0;i<=N-1;i++)printf("%-4d",n[i]);printf("\n");}2、编译,无毛病、无警告后运行,运行结果如下：实验④：将两个字符串联接起来,不要用strcat函数.1、输入#define M 50#define N 20main (){char a[M],b[N];int i,j;gets(a);gets(b);for(i=0;a[i]!='\0';i++);for(j=0;b[j]!='\0';j++){a[i]=b[j];i++;}a[i]='\0';puts(a);}2、编译,无毛病、无警告后运行,运行结果如下：实验⑤：从键盘输入5个字符串,找出最长的字符串和最年夜的字符串.1、输入#include "string.h"#define N 20main(){char a[5][N],max[N],m,n,max1;int b[5];int i,j;for(i=0;i<=4;i++)gets(a[i]);for(i=0;i<=4;i++)b[i]=strlen(a[i]);max1=b[0];m=0;for(i=1;i<=4;i++)if(b[i]>=max1)if(a[i]-m==0){printf("it is at (%d)\n",i+1);break;}i--;}else if(m>a[7]){if(a[i]-m==0){printf("it is at (%d)\n",i+1);break;}i++;}elseprintf("8\n");}if(fabs(i-7)-8==0)printf("无此数\n");}2、编译,无毛病、2警告后运行,运行结果如下：实验③：将以下二维数组中数按列的顺序寄存到一个一维数组中.二维数组的内容是11 22 33 4411 22 33 4411 22 33 44则一维数组中的内容是11 11 11 22 22 22 33 33 33 44 44 441、输入#include <stdio.h>main(){inta[3][4]={{11,22,33,44},{11,22,33,44},{11,22,33,44}};int b[12],i,j,m;{max1=b[i];m=i;}strcpy(max,a[0]);n=0;for(i=1;i<=4;i++)if(strcmp(a[i],max)>=0){strcpy(max,a[i]);n=i;}printf("\n");puts(a[m]);puts(a[n]);}2、编译,无毛病、无警告后运行,运行结果如下：m=0;for(j=0;j<=3;j++)for(i=0;i<=2;i++){b[m]=a[i][j];m++;}for(m=0;m<12;m++)printf("%d ",b[m]);printf("\n");}2、编译,无毛病、无警告后运行,运行结果如下：实验总结学号：姓名：班级：成果：实验名称：函数指导教师：张雄实验日期：实验地址：实验软件（主要仪器设备）：实验要求1.掌握界说函数的方法；2.掌握函数实介入形参的对应关系,以及“值传递”的方式；3.掌握函数的嵌套调用和递归调用的方法；4.掌握全局变量和局部变量,静态变量和静态变量的概念和使用方法.实验过程与步骤实验①：写一个判断素数的函数,在主函数输入一个整数,输出是否是素数的信息.1、输入#include <stdio.h>int is_prime(int m){int i;if(m==1)return 0;for(i=2;i<m;i++){if(m%i==0){return 0;}}return 1;}void main(){int n,c;scanf("%d",&n);c=is_prime(n);if(c==1)printf("它是素数\n");elseprintf("它不是素数\n");}2、编译,无毛病、无警告后运行,结果如下：实验③：已知二阶Fibonacci数列：0 若n=0Fib(n)= 1 若n=1Fib(n-1)+Fib(n-2) 其他情况界说递归函数求Fib(n).1、输入#include<stdio.h>int fib(int n){if(n==0 )return 0;else if(n==1)return 1;else{return fib(n-1)+fib(n-2);}}实验②：1、输入#include<stdio.h>void main(){int gy(int,int);int gb(int,int);int m,n;restart:scanf("%d%d",&m,&n);printf("最年夜公约数是%d\n",gy(m,n));printf("最小公倍数是%d\n",gb(m,n));goto restart;}int gy(int x,int y){int a,b,c,d;if(x>=y) {a=x,b=y;}else {a=y,b=x;}while(d!=0){c=a/b;d=a%b;a=b;b=d;}return a;}int gb(int x,int y){return(x*y)/gy(x,y);}2、编译,无毛病、无警告后运行,结果如下：实验④：编写函数,求101!n1、输入#include <stdio.h>int func(int n){if(n==0||n==1){return 1;}else{return n*func(n-1);}}int main(void){int n;int i;void main(){int n;scanf("%d",&n);printf("fib(%d)=%d\n",n,fib(n));}2、编译,无毛病、无警告后运行,结果如下：int sum = 0;printf("请输入一个正整数:");scanf(" %d", &n);for (i=1;i<=n;i++){sum+=func(i);}printf("1!+...+%d!=%d\n",n,sum);return 0;}2、编译,无毛病、无警告后运行,结果如下：实验总结学号：姓名：班级：成果：实验名称：指针指导教师：实验日期：实验地址：实验软件（主要仪器设备）：实验要求1.掌握指针的概念,会界说和使用指针变量；2.学会使用数组的指针和指向数组的指针变量；3.学会使用字符串的指针和指向字符串的指针变量；4.学会使用指向函数的指针变量；5.了解指向指针的指针的概念及其使用方法.实验过程与步骤实验①：1.界说函数void fun(int x[ ],int*max,int *min),找出数组x中的最年夜值和最小值,最年夜值和最小值通过形参指针max和min传回.1、输入#include<stdio.h>#define N 10{ void fun(int *a,int n)int i,j,k,big;i=0;big=a[0];for(i=0;i<N;i++){if(big<a[i]){big=a[i];j=i;}}k=a[0];a[0]=a[j];a[j]=k;j=1;big=a[1];for(i=1;i<N;i++){if(big<a[i]){big=a[i];j=i;}}k=a[1];a[1]=a[j];a[j]=k;}void main(){int a[N],i;for(i=0;i<N;i++)scanf("%d",a+i);fun(a,N);for(i=0;i<N;i++)printf("%d ",a[i]);printf("\n");}}printf("-1");实验②：编写一个函数comp(s1,s2)实现两个字符串的比力.1、输入1．编写以下函数：#include <stdio.h>#include <math.h>main(){char s1[100],s2[100];int i=0,j=0;printf("s1:");do{scanf("%c",&s1[i]);s1[i]='\0';printf("s2:");do{scanf("%c",&s2[j]);}while(s2[j++]!='\n');s2[j]='\0';i=-1;j=-1;do}while(s1[i++]!='\n');break;}else if(s1[i]<s2[j]||(s1[j]!='\0'&&s1[i]=='\0')){printf("1");break;}else if(s1[i]=='\0'&&s2[j]=='\0')printf("0");}while(s1[i]!='\0'&&s2[j]!='\0');}2、编译,无毛病无警告后运行,结果如下：实验③：从键盘输入一个字符串与一个指定字符,调用函数,将字符串中呈现的指定字符全部删除.1、输入#include "stdio.h"#include "conio.h"#include "string.h"void prochar(char *str,char c){char *p;for(p=str;*p!='\0';p++)if(*p!=c)*str++=*p;*str='\0';}void main(){char str[80],char_c;gets(str);scanf("%c",&char_c);prochar(str,char_c);puts(str);getch();}2、编译,无毛病无警告后运行,结果如下：for(i=0;i<N;i++){for(j=0;j<N;j++)printf("%d\t",array[i][j]);printf("\n");}}void convert(int array[][3]){int i,j,t;for(i=0;i<N;i++)for(j=0;j<N;j++)2、编译,无毛病无警告后运行,结果如下：{i++;j++;if(s1[i]>s2[j]||(s1[i]!='\0'&&s2[j]=='\0')){2、编译,无毛病、无警告后运行,结果如下：实验④：将一个３×３的矩阵转置,用一函数实现.在一主函数中用scanf函数输入以下矩阵元素：１３５７９１１１３１５１７将数组名作为函数参数,在执行函数的过程中实现矩阵转置,函数调用结束后在主函数中输出转置后的矩阵.1、输入#include<stdio.h>#define N 3int array[N][N];void main(){void convert(int array[][3]);int i,j;printf("输入数组:\n");for(j=0;j<N;j++)for(i=0;i<N;i++)scanf("%d",&array[i][j]);printf("\n");for(j=0;j<N;j++){for(i=0;i<N;i++)printf("%d\t",array[i][j]);printf("\n");}convert(array);printf("\n");实验总结创作时间：二零二一年六月三十日。
数据结构中链表及常见操作
链表1 定义链表（Linked list）是一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是在每一个节点里存到下一个节点的指针(Pointer)。
由于不必须按顺序存储，链表在插入的时候可以达到O(1)的复杂度，比另一种线性表顺序表快得多，但是查找一个节点或者访问特定编号的节点则需要O(n)的时间，而顺序表相应的时间复杂度分别是O(logn)和O(1)。
使用链表结构可以克服数组链表需要预先知道数据大小的缺点，链表结构可以充分利用计算机内存空间，实现灵活的内存动态管理。
但是链表失去了数组随机读取的优点，同时链表由于增加了结点的指针域，空间开销比较大。
在计算机科学中，链表作为一种基础的数据结构可以用来生成其它类型的数据结构。
链表通常由一连串节点组成，每个节点包含任意的实例数据（data fields）和一或两个用来指向明上一个或下一个节点的位置的链接（"links"）。
链表最明显的好处就是，常规数组排列关联项目的方式可能不同于这些数据项目在记忆体或磁盘上顺序，数据的访问往往要在不同的排列顺序中转换。
而链表是一种自我指示数据类型，因为它包含指向另一个相同类型的数据的指针（链接）。
链表允许插入和移除表上任意位置上的节点，但是不允许随机存取。
链表有很多种不同的类型：单向链表，双向链表以及循环链表。
2 结构2.1 单向链表链表中最简单的一种是单向链表，它包含两个域，一个信息域和一个指针域。
这个链接指向列表中的下一个节点，而最后一个节点则指向一个空值。
一个单向链表的节点被分成两个部分。
第一个部分保存或者显示关于节点的信息，第二个部分存储下一个节点的地址。
单向链表只可向一个方向遍历。
链表最基本的结构是在每个节点保存数据和到下一个节点的地址，在最后一个节点保存一个特殊的结束标记，另外在一个固定的位置保存指向第一个节点的指针，有的时候也会同时储存指向最后一个节点的指针。
一般查找一个节点的时候需要从第一个节点开始每次访问下一个节点，一直访问到需要的位置。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
{
node<T> *p=new node<T>;
p->data=x;
if(!p) return 0;
p->next=head->next;
head->next=p;
return 1;
}
template<class T>
int list<T>::remove(T& x)
cout<<p->getData()<<endl;
l.remove(x);
l.print();
return 0;
class list
{
private:
node<T> *head;
public:
list(){head=new node<T>;}
~list();
int insert(T&);
int remove(T&);
node<T>* find(T&);
void print();
void sort();
};
template <class T>
while(q!=NULL)
{
cout<<q->data;
q=q->next;
}
cout<<endl;
}
template<class T>
list<T>::~list()
{
node<T>*p=head->next;
while(p!=NULL)
{
head->next=p->next;
delete p;
for(q=p->next;q!=NULL;q=q->next)
if(p->data>q->data)
{
T temp=q->data;
q->data=p->data;
p->data=temp;
}
}
template<class T>
void list<T>::print()
{
node<T> *q=head->next;
{
node<T>* p=find(x);
if(!p) return 0;
node<T> *q=p->next;
p->next=q->next;
delete q;
return 1;
}
template<class T>
node<T> *list<T>::find(T& x)
{
node<T>*q=head;
private:
T data;
node<T>* next;
public:
node<T>():data(0),next(NULL){};
~node<T>(){}
T getData(){return data;}
node<T>* getNext(){return next;}
};
template <class T>
while(q->next!=NULL)
{
if(q->next->data==x)
return q;
q=q->next;
}
return NULL;
}
template<class T>
void list<T>::sort()
{
node<T>* p=head->next,*q;
for(;p!=NULL;p=p->next)
C++课程实训建立线性单链表要有初始化、插入、删除、查找、排序等常用功能的C++程序，必须要有封装性！
#include<iostream>
using namespace std;
template <class T>
class list;
template <class T>
class node
{
friend list<T>;
p=head->next;
}
delete head;
}
int main()
{
list<int> l;
int x;
do
{
cin>>x;//input 0 exit
if(x==0) break;
l.insert(x);
} while (1);
l.sort();
l.print();
cin>>x;
node<();