单练表插入排序

合集下载

基于单链表实现集合的交集、并集、差集的运算

基于单链表实现集合的交集、并集、差集的运算

基于单链表实现集合的交集、并集、差集的运算解题思路(单链表求交集、并集、差集的思想和顺序表求交集、并集、差集的思想基本相同)1.先通过CreateListR 函数将集合 a 和 b 中的元素添加到顺序表 ha 和 hb 中,添加过程使⽤的是顺序表原有的Initlist 函数(初始化表)和ListInsert 函数(向表中插⼊元素)。

2.因为原集合是⽆序的,所以我通过 sort 函数(选择排序),使得集合变得有序。

3.得到有序集合 ha 和 hb 后,便可以使⽤ Union 函数(类似归并的思想写出来的求并集的函数),求出 ha 和 hb 的并集。

4.⽽求交集的⽅法则是,通过将集合 a 中的元素⼀个⼀个取出,并通过函数LocateElem ,查看集合 hb 中是否存在该元素,如果存在则将元素放⼊ hc ,如果不存在,则舍去。

以此求得两集合的交集。

5.求两集合的差则可以反过来,同样通过将集合 a 中的元素⼀个⼀个取出,并通过函数LocateElem ,查看集合 hb 中是否存在该元素,如果不存在则将元素放⼊ hc ,如果存在,则舍去。

以此求得两集合的差集。

#include <iostream>#include <cstdio>#include <malloc.h>using namespace std;/* 定义单链表数据 */typedef char ElemType;typedef struct LNode{ElemType data;struct LNode *next;}LinkList;/* 单链表的初始化 */void InitList(LinkList *&L){L = (LinkList *)malloc(sizeof(LinkList));L->next=NULL;}/* 向单链表中插⼊数据元素 */bool ListInsert(LinkList *&L,int x,char e){int j = 0;LinkList *p = L, *s;while(p!=NULL && j<x-1){p = p->next;j++;}if(p==NULL){return false;}else{s = (LinkList *)malloc(sizeof(LinkList));s->data = e;s->next = p->next;p->next = s;return true;}}/* 输出单链表 */void DispList(LinkList *L){LinkList *p = L->next;while(p!=NULL){printf("%c ",p->data);p = p->next;}printf("\n");}/* 求单链表的长度 */int ListLength(LinkList *L){LinkList *p = L->next;int i = 0;while(p!=NULL){p = p->next;}return i;}/* 查看单链表是否为空 */bool ListEmpty(LinkList *L){return L->next==NULL;}/* 求单链表中某个数据元素值 */bool GetElem(LinkList *L,int i, ElemType &e) {LinkList *p = L;int j = 0;while(p!=NULL && j < i){p=p->next;j++;}if(p==NULL){return false;}else{e = p->data;return true;}}/* 在单链表中查找元素 */int LocateElem(LinkList *L,ElemType e){LinkList *p = L;int i = 0;while(p!=NULL && p->data!=e){p = p->next;i++;}if(p==NULL){return0;}else{return i;}}/* 删除单链表中第 i 个元素*/bool ListDelete(LinkList *&L,int i,ElemType &e) {int j = 0;LinkList *p = L, *q;while(p!=NULL && j < i - 1){p = p->next;j++;}if(p==NULL)return false;else{q = p->next;if(q==NULL)return false;e = q->data;p->next = q->next;free(q);return true;}}/* 删除单链表 */void DestroyList(LinkList *&L){LinkList *p = L;LinkList *q = p->next;while(q!=NULL){p = q;q = p->next;}free(p);}void CreateListR(LinkList *&L,ElemType e[],int n) {InitList(L);int i;for(i = 0;i < n; ++i){if(!LocateElem(L,e[i]))ListInsert(L,i+1,e[i]);}}void InsterSect(LinkList *a,LinkList *b,LinkList *&c) {DestroyList(c);InitList(c);LinkList *p = a->next;int i = 0;while(p!=NULL){if(LocateElem(b,p->data))ListInsert(c,++i,p->data);p = p->next;}}void Subs(LinkList *a,LinkList *b,LinkList *&c){DestroyList(c);InitList(c);LinkList *p = a->next;int i = 0;while(p!=NULL){if(!LocateElem(b,p->data))ListInsert(c,++i,p->data);p = p->next;}}void Union(LinkList *a,LinkList *b,LinkList *&c){InitList(c);LinkList *p = a->next;LinkList *q = b->next;int k = 0;while(p!=NULL && q!=NULL){if(p->data < q->data){ListInsert(c,k+1,p->data);p = p->next;k++;}else if(p->data == q->data){ListInsert(c,k+1,p->data);p = p->next;q = q->next;k++;}else{ListInsert(c,k+1,q->data);q = q->next;k++;}}while(p!=NULL){ListInsert(c,k+1,p->data);p = p->next;k++;}while(q!=NULL){ListInsert(c,k+1,q->data);q = q->next;}///cout<<"hehe"<<endl;}void sort(LinkList *&L){LinkList *p , *pre, *q, *k;InitList(p);int i = 0;char c;while(!ListEmpty(L)){pre = L ->next;c = pre->data;while(pre!=NULL){if(c>=pre->data)c = pre->data;pre = pre->next;}ListInsert(p,++i,c);int tag = LocateElem(L,c);ListDelete(L,tag,c);}L = p;}int main( ){LinkList *ha, *hb, *hc;ElemType a[]={'c','a','e','h'};ElemType b[]={'f','h','b','g','d','a'};printf("集合的运算如下\n");CreateListR(ha,a,4);CreateListR(hb,b,6);printf("原集合 A: "); DispList(ha); printf("原集合 B: "); DispList(hb); sort(ha);sort(hb);printf("有序集合A:"); DispList(ha); printf("有序集合B:"); DispList(hb); Union(ha,hb,hc);printf("集合的并C:"); DispList(hc); InsterSect(ha,hb,hc);printf("集合的交C:"); DispList(hc); Subs(ha,hb,hc);printf("集合的差C:"); DispList(hc); DestroyList(ha);DestroyList(hb);DestroyList(hc);return0;}。

单链表上容易实现的排序方法

单链表上容易实现的排序方法

单链表上容易实现的排序方法嘿,朋友们!今天咱来聊聊单链表上那些容易实现的排序方法。

你想想啊,单链表就像是一串珠子,每个珠子都有它自己的位置和信息。

那怎么把这些珠子排得整整齐齐呢?咱先说冒泡排序吧!这就好像是在一群小朋友里,让矮个子一个一个地慢慢往前站,把高个子往后挤。

每次都把最大的那个“珠子”给浮到最上面去。

虽然它比较简单直接,但有时候可能会有点慢悠悠的哦!就像你着急出门,却发现钥匙找半天,是不是有点让人着急呀?再来看看插入排序。

这就像是玩扑克牌的时候整理手牌,拿到一张牌,就看看该把它插到哪里合适。

嘿,这多形象呀!它可以一点点地把链表变得有序,虽然可能步骤多了点,但效果还是不错的哟!还有选择排序呢!这就好像是在一群选手中挑出最厉害的那个,然后把其他的依次排好。

是不是挺有意思的?它也能完成排序的任务呢!那咱为啥要用这些排序方法呀?这还用问吗?就像你收拾房间,总不能让东西乱七八糟地堆着吧!把链表排好序,才能更方便我们查找和使用其中的数据呀!不然找个数据都得费半天劲,那多麻烦呀!这些排序方法各有各的特点和用处。

就像不同的工具,有的适合干这个,有的适合干那个。

我们得根据具体情况来选择合适的排序方法,可不能瞎用哦!不然可能会事倍功半呢!比如说,如果链表的数据量不是特别大,那冒泡排序或者插入排序可能就挺合适的。

但要是数据量大得吓人,那可能就得考虑更高效的方法啦!总之呢,单链表上的排序方法就像是我们生活中的各种小技巧,学会了它们,就能让我们的编程之路更加顺畅。

所以呀,大家可得好好掌握这些方法哦!可别小瞧了它们,它们能帮我们解决大问题呢!现在,你是不是对单链表上的排序方法有了更清楚的认识啦?。

数据结构与算法面试题

数据结构与算法面试题
1.
应用场景:
1)数据比较少
2)经常做的运算是按序号访问数据元素
面试题
选择题:
1)对于长度为n的线性表,建立其对应的单链表的时间复杂度为()。
O(1)
O(log2n)
O(n)
O(n^2)
2)下列哪些不是线性表?
队列

关联数组
链表
3)稀疏矩阵一般的压缩存储方法有两种,即()
二维数组和三维数组
三元组和散列
Node dummyHead = new Node(0);
Node p = head;
dummyHead.next = head;
//p的值不小于下一节点元素考察下一节点
while (p.next != null) {
if (p.value <= p.next.value) {
p = p.next;
面试题
选择题:
1)在一个单链表中,q的前一个节点为p,删除q所指向节点,则执行()。
delete q
q->next=p->next;delete p
p->next=q->next;delete p
p->next=q->next;delete q
delete p
q->next=p->next;delete q
q = q.next;
temp.next = q.next;
//重新连接链表注意else的过程并没有改变p指针的位置
q.next = temp;
}
}
return dummyHead.next;
}
3.
应用场景:
1)数制转换
2)括号匹配检验

数据结构练习题

数据结构练习题

第1章绪论一、选择题1. 算法的计算量的大小称为计算的()。

A.效率 B. 复杂性 C. 现实性 D. 难度2. 算法的时间复杂度取决于()A.问题的规模 B. 待处理数据的初态 C. A和B3. 下面说法错误的是()(1)算法原地工作的含义是指不需要任何额外的辅助空间(2)在相同的规模n下,复杂度O(n)的算法在时间上总是优于复杂度O(2n)的算法(3)所谓时间复杂度是指最坏情况下,估算算法执行时间的一个上界(4)同一个算法,实现语言的级别越高,执行效率就越低A.(1) B.(1),(2) C.(1),(4) D.(3)4. 以下数据结构中,哪一个是线性结构()A.广义表 B. 二叉树 C. 稀疏矩阵 D. 串5. 在下面的程序段中,对x的赋值语句的频度为()for (int i=1; i<=n; i++)for (int j=1; i<=n;j++)x+=1;A.2n B.n C.n2D.log2n二、判断题1. 数据元素是数据的最小单位。

( )2. 算法的优劣与算法描述语言无关,但与所用计算机有关。

( )3. 数据的物理结构是指数据在计算机内的实际存储形式。

( )4. 顺序存储方式的优点是存储密度大,且插入、删除运算效率高。

( )5. 数据结构的抽象操作的定义与具体实现有关。

( )三、填空1.数据的物理结构包括的表示和的表示2. 数据结构中的逻辑结构有(1),(2),(3),__(4)_四种。

3. 一个数据结构在计算机中称为存储结构4. 数据结构中评价算法的两个重要指标是5. 一个算法具有5个特性: (1)、(2)、(3),有零个或多个输入、有一个或多个输出。

6. 已知如下程序段, 语句1执行的频度为(1);语句2执行的频度为(2);for (int i=n; i>=1; i--) {x = x+1; //语句1for (int j = n; j>=1; j--)y = y+1; //语句2}7. 下面程序段中带下划线的语句的执行次数的渐进时间复杂度为int i=1; while (i<n) i = i*2;四、应用题1. 解释和比较以下各组概念(1)抽象数据类型及数据类型(2)数据结构、逻辑结构、存储结构(3)抽象数据类型(4)算法的时间复杂性(5)算法(6)频度2. 若有100个学生,每个学生有学号,姓名,平均成绩,采用什么样的数据结构最方便,写出这些结构?3. 有实现同一功能的两个算法A1和A2,其中A1的时间复杂度为Tl=O(2n),A2的时间复杂度为T2=O(n2),仅就时间复杂度而言,请具体分析这两个算法哪一个好.4. 下列算法对一n位二进制数加1,假如无溢出,该算法的最坏时间复杂性是什么?并分析它的平均时间复杂性。

(完整版)数据结构与算法第8章答案

(完整版)数据结构与算法第8章答案

第8 章排序技术课后习题讲解1. 填空题⑴排序的主要目的是为了以后对已排序的数据元素进行()。

【解答】查找【分析】对已排序的记录序列进行查找通常能提高查找效率。

⑵对n个元素进行起泡排序,在()情况下比较的次数最少,其比较次数为()。

在()情况下比较次数最多,其比较次数为()。

【解答】正序,n-1,反序,n(n-1)/2⑶对一组记录(54, 38, 96, 23, 15, 72, 60, 45, 83)进行直接插入排序,当把第7个记录60插入到有序表时,为寻找插入位置需比较()次。

【解答】3【分析】当把第7个记录60插入到有序表时,该有序表中有2个记录大于60。

⑷对一组记录(54, 38, 96, 23, 15, 72, 60, 45, 83)进行快速排序,在递归调用中使用的栈所能达到的最大深度为()。

【解答】3⑸对n个待排序记录序列进行快速排序,所需要的最好时间是(),最坏时间是()。

【解答】O(nlog2n),O(n2)⑹利用简单选择排序对n个记录进行排序,最坏情况下,记录交换的次数为()。

【解答】n-1⑺如果要将序列(50,16,23,68,94,70,73)建成堆,只需把16与()交换。

【解答】50⑻对于键值序列(12,13,11,18,60,15,7,18,25,100),用筛选法建堆,必须从键值为()的结点开始。

【解答】60【分析】60是该键值序列对应的完全二叉树中最后一个分支结点。

2. 选择题⑴下述排序方法中,比较次数与待排序记录的初始状态无关的是()。

A插入排序和快速排序B归并排序和快速排序C选择排序和归并排序D插入排序和归并排序【解答】C【分析】选择排序在最好、最坏、平均情况下的时间性能均为O(n2),归并排序在最好、最坏、平均情况下的时间性能均为O(nlog2n)。

⑵下列序列中,()是执行第一趟快速排序的结果。

A [da,ax,eb,de,bb] ff [ha,gc]B [cd,eb,ax,da] ff [ha,gc,bb]C [gc,ax,eb,cd,bb] ff [da,ha]D [ax,bb,cd,da] ff [eb,gc,ha]【解答】A【分析】此题需要按字典序比较,前半区间中的所有元素都应小于ff,后半区间中的所有元素都应大于ff。

北京师范大学数据结构教学资料第九章排序

北京师范大学数据结构教学资料第九章排序

第九章排序(基础知识)8.1 【答案】以关键字序列(265,301,751,129,937,863,742,694,076,438)为例,分别写出执行以下排序算法的各趟排序结束时,关键字序列的状态。

(1) 直接插入排序(2)希尔排序(3)冒泡排序(4)快速排序(5) 直接选择排序(6) 堆排序(7) 归并排序(8)基数排序上述方法中,哪些是稳定的排序?哪些是非稳定的排序?对不稳定的排序试举出一个不稳定的实例。

8.2 【答案】上题的排序方法中,哪些易于在链表(包括各种单、双、循环链表)上实现?8.3 【答案】当R[low..high]中的关键字均相同时,Partion返回值是什么?此时快速排序的的运行时间是多少?能否修改Partion,使得划分结果是平衡的(即划分后左右区间的长度大致相等)?8.4 【答案】若文件初态是反序的,则直接插入,直接选择和冒泡排序哪一个更好?8.5 【答案】若文件初态是反序的,且要求输入稳定,则在直接插入、直接选择、冒泡和快速排序中就选选哪种方法为宜?6. 用快速排序算法,对下列数组排序60 56 65 99 22 16 88 100a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7]取a[0]为支点(pivot),列出第一轮升序排序后的元素顺序。

8.6 【答案】有序数组是堆吗?8.7 【答案】高度为h的堆中,最多有多少个元素?最少有多少个元素?在大根堆中,关键字最小的元素可能存放在堆的哪些地方?8.8 【答案】判别下列序列是否为堆(小根堆或大根堆),若不是,则将其调整为堆:(1) (100,86,73,35,39,42,57,66,21);(2) (12,70,33,65,24,56,48,92,86,33);(3) (103,97,56,38,66,23,42,12,30,52,06,20);(4) (05,56,20,23,40,38,29,61,35,76,28,100).8.9 【答案】将两个长度为n的有序表归并为一个长度为2n的有序表,最小需要比较n次,最多需要比较2n-1次,请说明这两种情况发生时,两个被归并的表有何特征?7. 将序列101 45 21 532 22 5 232 14 存放在一静态链表中(见下图),并对其按照链式基数排序法进行升序排序。

数据结构与算法 模拟试卷七、八及参考答案

数据结构与算法 模拟试卷七、八及参考答案

模拟试卷七一、单项选择题(在每小题的四个备选答案中,选出一个正确的答案,并将其号码填在题干后的括号内。

每小题1分,共10分)1.假设执行语句S的时间为O(1),则执行下列程序段for(i=1;i<=n;i++)for(j=i;j<=n;j++)S;的时间为( )A)O(n)B)O(n2)C)O(n*i)D)O(n+i)2.设栈最大长度为3,入栈序列为1,2,3,4,5,6,则不可能的出栈序列是()。

A)1,2,3,4,5,6 B)2,1,3,4,5,6C)3,4,2,1,5,6 D)4,3,2,1,5,63.设单链表的结点结构为(data,next),已知指针q所指结点是指针p所指结点的直接前驱,如在*q与*p之间插入结点*s,则应执行的操作为()。

A)s->next=p->next; p->next=s; B)q->next=s; s->next=p;C)p->next=s-next; s->next=p; D)p->next=s; s-next=q;4.串S='ABC DEF'的串长为()。

A)3 B)4C)7 D)85.下面二叉树按()遍历得到的序列是FEDBIHGCA。

A)先序B)中序C)后序D)层次6.用Floyd算法求每一对顶点之间的最短路径的时间复杂度为()。

A)O(n) B)O(n2)C)O(n3) D)O(nlogn)7.具有n个顶点的无向图,它可能具有的边数的最大值为()。

A)(n2+n)/2 B)n2C)(n2-n)/2 D)n8.二分查找法要求被查找的表是()。

A)顺序表B)链接表C)顺序表且是按值递增或递减次序排列D)不受上述的任何限制9.在一待散列存储的线性表(18,25,63,50,42,32,90),若选用h(k)=k % 7作为散列函数,则与元素18冲突的元素有( )个。

A)0 B)1C)2 D)310.在下列排序算法中,不稳定的是()。

第7章 排序 习题参考答案

第7章 排序 习题参考答案

习题七参考答案一、选择题1.内部排序算法的稳定性是指( D )。

A.该排序算法不允许有相同的关键字记录B.该排序算法允许有相同的关键字记录C.平均时间为0(n log n)的排序方法D.以上都不对2.下面给出的四种排序算法中,( B )是不稳定的排序。

A.插入排序B.堆排序C.二路归并排序D.冒泡排序3. 在下列排序算法中,哪一种算法的时间复杂度与初始排序序列无关(D )。

A.直接插入排序B.冒泡排序C.快速排序D.直接选择排序4.关键字序列(8,9,10,4,5,6,20,1,2)只能是下列排序算法中( C )的两趟排序后的结果。

A.选择排序 B.冒泡排序 C.插入排序 D.堆排序5.下列排序方法中,( D )所需的辅助空间最大。

A.选择排序B.希尔排序C.快速排序D.归并排序6.一组记录的关键字为(46,79,56,38,40,84),则利用快速排序的方法,以第一个记录为支点得到的一次划分结果为(C )。

A.(38,40,46,56,79,84) B.(40,38,46,79,56,84)C.(40,38,46,56,79,84) D.(40,38,46,84,56,79)7.在对一组关键字序列{70,55,100,15,33,65,50,40,95},进行直接插入排序时,把65插入,需要比较( A )次。

A. 2B. 4C. 6D. 88.从待排序的序列中选出关键字值最大的记录放到有序序列中,该排序方法称为( B )。

A. 希尔排序B. 直接选择排序C. 冒泡排序D. 快速排序9.当待排序序列基本有序时,以下排序方法中,( B )最不利于其优势的发挥。

A. 直接选择排序B. 快速排序C.冒泡排序D.直接插入排序10.在待排序序列局部有序时,效率最高的排序算法是( B )。

A. 直接选择排序B. 直接插入排序C. 快速排序D.归并排序二、填空题1.执行排序操作时,根据使用的存储器可将排序算法分为内排序和外排序。

数据结构试题库

数据结构试题库
数据结构试题库
1、 单项选择题 1. 下列程序段所代表的算法的时间复杂度为( D )。 x=n; y=0; while (x>=(y+1)*(y+1)) y++; (A)O(n) (B)O(n2) (C)O(log2n) (D)O() 2. 在一个长度为n的以顺序结构存储的线性表中,假设在线性表的 任何位置删除元素的概率相等,则删除一个元素时线性表所需移 动元素的平均次数为( B )。 (A) n2 (B)(n-1)/2 (C)(n+1)/2 (D)n/2 3. 在一个栈顶指针为HS的链栈中插入一个*s结点时,应执行执行 操作为 ( C )。 (A)HS->next=s; (B)s->next=HS->next;HS->next=s; (C)s->next=HS;HS=s; (D)s->next=HS;HS=HS>next; 4. 假设以带头结点的循环链表表示队列Q,并且队列只设一个头指 针front,不设队列尾指针。若要进队一个元素*s,则在下列程序 算法的空白处应添加的操作语句是( A )。 void AddQueue(struct linkqueue Q) { p=Q->front; while(p->next!=Q->front) p=p->next; } (A)p->next=s;s->next=Q->front; (B)Q->front->next=s;Q->front=s; (C)s->next=p;p->next=Q->front; (D)Q->front->next=s;s->next=p; 5. 设高度为h的二叉树上只有度为0和度为2的结点,则此类二叉树 中所包含的结点数至少为( B )。 (A)2h-1 (B)2h-1+1 (C)2h-1 (D)2h-1-3 6. 现有数据集{53,30,37,12,45,24,96},从空二叉树逐个插入数据形 成二叉排序树,若希望查找此二叉树中任一结点的平均查找长度 最小,则应选择下面哪个序列输入( C )。

数据结构试题

数据结构试题

一、判断题(正确在括号内填√,错误在括号内填×,每题1分,共15分)()1.线性表采用顺序存储,必须占用一片连续的存储单元。

()2.栈和队列的共同点是只允许在端点处插入和删除元。

()3.数据结构包括数据间的逻辑结构、数据的存储方式和数据的运算三个方面。

()4.一棵哈夫曼树中不存在度为1的结点。

()5.散列法是一种对关键字进行运算的查找方法和存储方法。

()6.一个队列的入队序列是1,2,3,4,则队列的出队序列是4,3,2,1。

()7.数据元素是数据的最小单位。

()8.算法的五个特性为:有穷性、输入、输出、完成性和确定性()9.线性表采用链式存储结构时,其地址必须是连续的。

()10.二叉树中任何一个结点的度都是2。

()11.直接插入排序是稳定的排序。

()12.n个顶点的无向图最多有n*(n-1)条边。

()13.一个有向图的邻接矩阵一定是一个非对称矩阵。

()14.用二分查找法对一个顺序表进行查找,这个顺序表可以是按各键值排好序的,也可以是没有按键值排好序的。

()15.设高度为h的二叉树上只有度为0和度为2的结点,则此类二叉树中所包含的结点数至少为2h-1。

二、单项选择(在备选答案中选出一个正确答案,并将正确答案的序号填在题干后的括号内。

每题1分,共15分)1. 下列算法的时间复杂度为()。

x=n;// n>1 While(x>=(y+1)*(y+1)) Y++;A.O(n1/2) B.O(n2) C. O(log2n) D.O(n)2. n个顶点的无向连通图的最小生成树包含( )条边。

A.nB.n-1C.n/2D.n+1。

3. 深度为6(根的层次为1)的二叉树最多有()个结点。

A.64 B.32 C. 63 D.31 4. 一个线性表第一个元素的存储地址是100,每个元素的长度为2,则第5个元素的地址是( ) 。

A. 110B. 120C. 100D. 1085. 在一个单链表中,若删除p所指结点的后续结点,则执行()A.p->next=p->next->next ; B.p=p->next;C.p->next=p->next; D.p =p->next->next;6 . 稀疏矩阵一般的压缩存储方法有两种,即()。

数据结构实验报告单链表

数据结构实验报告单链表

数据结构实验报告_单链表数据结构实验报告——单链表一、实验目的1.掌握单链表的基本概念和原理。

2.了解单链表在计算机科学中的应用。

3.掌握单链表的基本操作,如插入、删除、遍历等。

4.通过实验,加深对理论知识的理解,提高编程能力。

二、实验内容1.实验原理:单链表是一种线性数据结构,由一系列节点组成,每个节点包含数据域和指针域。

其中,指针域指向下一个节点,最后一个节点的指针域指向空。

单链表的主要操作包括插入、删除、遍历等。

2.实验步骤:(1)创建一个单链表。

(2)实现插入操作,即在链表的末尾插入一个新节点。

(3)实现删除操作,即删除链表中的一个指定节点。

(4)实现遍历操作,即输出链表中所有节点的数据。

3.实验代码:下面是使用Python语言实现的单链表及其基本操作的示例代码。

class Node:def __init__(self, data):self.data = dataself.next = Noneclass LinkedList:def __init__(self):self.head = Nonedef insert(self, data):new_node = Node(data)if self.head is None:self.head = new_nodeelse:current = self.headwhile current.next is not None:current = current.nextcurrent.next = new_nodedef delete(self, data):if self.head is None:returnif self.head.data == data:self.head = self.head.nextreturncurrent = self.headwhile current.next is not None and current.next.data != data:current = current.nextif current.next is None:returncurrent.next = current.next.nextdef traverse(self):current = self.headwhile current is not None:print(current.data)current = current.next4.实验结果:通过运行上述代码,我们可以看到单链表的基本操作得到了实现。

中国铁道出版社数据结构(第二版)单元10练习参考答案

中国铁道出版社数据结构(第二版)单元10练习参考答案

单元测验10一.判断题(下列各题,正确的请在前面的括号内打√;错误的打╳)(ㄨ)(1)如果某种排序算法不稳定,则该排序方法就没有实用价值。

(√)(2)希尔排序是不稳定的排序。

(ㄨ)(3)冒泡排序是不稳定的排序。

(√)(4)对n个记录的进行快速排序,所需要的平均时间是O(nlog2n)。

(ㄨ)(5)堆排序所需的时间与待排序的记录个数无关。

(√)(6)当待排序的元素个数很多时,为了交换元素的位置要占用较多的时间,这是影响时间复杂度的主要因素。

(ㄨ)(7)快速排序在任何情况下都比其它排序方法速度快。

(√)(8)对快速排序来说,初始序列为正序或反序都是最坏情况。

(√)(9)采用归并排序可以实现外排序。

(√)(10)采用希尔方法排序时,若关键字的排列杂乱无序,则效率最高。

(√)(11)快速排序算法在每一趟排序中都能找到一个元素放在其最终位置上。

(√)(12)冒泡排序的时间复杂度是O(n2)。

二.填空题(1)大多数排序算法都有两个基本的操作:比较和移动。

(2)评价排序算法优劣的主要标准是时间复杂度和算法所需的附加空间。

(3)根据被处理的数据在计算机中使用不同的存储设备,排序可分为:内排序和外排序。

(4)外排序是指在排序过程中,数据的主要部分存放在计算机的外存中。

(5)对n个关键字进行冒泡排序,其可能的最小比较次数为: n-1 次。

(6)在最坏情况下,在第i趟直接插入排序中,要进行 i-1 次关键字的比较。

(7)对n个关键字进行冒泡排序,时间复杂度为 O(n2) 。

(8)快速排序在最坏情况下的时间复杂度是 O(n2) 。

(9)对于n个记录的集合进行归并排序,所需要的平均时间为: O(log2n) 。

(10)对于n个记录的集合进行归并排序,所需要的附加空间是 O(n) 。

(11)若原始数据接近无序,则选用快速排序最好。

(12)在排序前,关键字值相等的不同记录,排序后相对位置保持不变的排序方法,称为稳定排序方法。

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

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

} return 0; }
实验三 查找
实验名称: 实验3 查找 实验目的:掌握顺序表和有序表的查找方法及算法实现;掌握二叉排序 树和哈希表的构造和查找方法。通过上机操作,理解如何科学地组织信 息存储,并选择高效的查找算法。 实验内容:(2选1)内容1: 基本查找算法;内容2: 哈希表设计。 实验要求:1)在C++系统中编程实现;2)选择合适的数据结构实现查 找算法;3)写出算法设计的基本原理或画出流程图;4)算法实现代码 简洁明了;关键语句要有注释;5)给出调试和测试结果;6)完成实验 报告。 实验步骤: (1)算法设计 a.构造哈希函数的方法很多,常用的有(1)直接定址法(2)数字分析法;(3) 平方取中法;(4)折叠法;( 5)除留余数法;(6)随机数法;本实验采用的是除 留余数法:取关键字被某个不大于哈希表表长m的数p除后所得余数为哈 希地址 (2)算法实现 hash hashlist[n]; void listname(){ char *f; int s0,r,i; NameList[0].py="baojie"; NameList[1].py="chengቤተ መጻሕፍቲ ባይዱoyang"; ……………………………… NameList[29].py="wurenke"; for(i=0;i<q;i++){s0=0;f=NameList[i].py; for(r=0;*(f+r)!='\0';r++) s0+=*(f+r);NameList[i].k=s0; }} void creathash(){int i;
v[k-1]=v[k]; nn=nn-1; return ; } int main() {sq_LList<double>s1(100); cout<<"第一次输出顺序表对象s1:"<<endl; s1.prt_sq_LList(); s1.ins_sq_LList(0,1.5); s1.ins_sq_LList(1,2.5); s1.ins_sq_LList(4,3.5); cout<<"第二次输出顺序表对象s1:"<<endl; s1.prt_sq_LList(); s1.del_sq_LList(0); s1.del_sq_LList(2); cout<<"第三次输出顺序表对象s1:"<<endl; s1.prt_sq_LList(); return 0; } 运行及结果:

单链表实验总结

单链表实验总结

单链表实验总结单链表是一种常见的数据结构,用于存储有序的数据元素。

在这个实验中,我通过实现单链表的基本操作,如插入、删除和查找等,加深了对单链表的理解。

在实验中,我首先创建了一个单链表的类,并实现了构造函数。

然后,我实现了向链表中插入节点的操作。

插入节点时,我需要将新的节点的指针指向当前节点的下一个节点,然后将前一个节点的指针指向新的节点,从而完成节点的插入。

在实现删除节点的操作时,我需要找到要删除的节点的前一个节点,然后将前一个节点的指针指向要删除节点的下一个节点,从而将要删除的节点排除在链表之外。

我还实现了通过索引查找节点的操作。

在这个操作中,我需要从链表的头节点开始迭代,直到找到要查找的索引位置的节点。

通过实践,我发现单链表的插入和删除操作的时间复杂度都是O(n),其中n表示链表的长度。

在查找操作中,时间复杂度是O(n)。

总之,通过这个实验,我对单链表的原理和基本操作有了更深的理解。

我也学到了如何使用单链表来解决实际问题。

这个实验让我更加熟悉了链表的概念和操作,为我进一步深入学习数据结构和算法打下了基础。

除了实现基本的插入、删除和查找操作,我还尝试了一些其他的操作来进一步加深对单链表的理解。

首先,我实现了获取链表长度的操作。

通过遍历整个链表,我可以统计节点的数量来得到链表的长度。

这个操作的时间复杂度是O(n)。

接下来,我尝试实现了链表的反转操作。

通过调整节点的指针指向,我可以将链表的顺序颠倒过来。

这个操作的时间复杂度是O(n)。

另外,我实现了链表的判空和清空操作。

判空操作可以判断链表是否为空,即链表的头节点是否为空。

清空操作可以将链表中的所有节点都删除,使链表变为空链表。

最后,我尝试了一些高级操作,如链表的排序和链表的合并。

排序操作可以将链表中的节点按照一定的顺序重新排列,通常使用冒泡排序、选择排序或插入排序等算法实现。

合并操作可以将两个有序链表合并成一个更大的有序链表,通常使用归并排序的思想实现。

数据结构作业答案

数据结构作业答案

1:41.如果待排序序列中两个数据元素具有相同的值,在排序后它们的位置发生颠倒,则称该排序是不稳定的。

()就是不稳定的排序方法。

1.起泡排序2.归并排序3.直接插入法排序4.简单选择排序2:8 带头结点的单链表head为空的判断条件是( )。

1.head==NULL2.head->next==NULL3. head->next==head4. head!=NULL3:9 在单链表中增加头结点的目的是为了( )。

1.方便运算的实现2.用于标识单链表3.使单链表中至少有一个结点4.用于标识起始结点的位置4:46 下列四个关键字序列中,( )不是堆。

1. {05,23,16,68,94,72,71,73}2.{05,16,23,68,94,72,71,73}3. {05,23,16,73,94,72,71,68}4.{05,23,16,68,73,71,72,94}5:20.设输入序列为1,2,3,4,5,借助一个栈可以得到的输出序列是( )。

1.2,4,1,3,52.3,4,1,5,23.3,2,4,1,54.4,1,3,2,56:50 对有n个记录的表按记录键值有序建立二叉排序树,在这种情况下,其平均查找长度的量级为()。

1.O(n)2.O(nlog2n)3.O(1)4. O(log2n)7:37.用分划交换排序方法对包含有n个关键的序列进行排序,最坏情况下执行的时间杂度为( )。

1.O(n)2. O(log2n)3.O(nlog2n)4. O(n2)8:38.邻接表的存储结构下图的深度优先遍历类似于二叉树(树)的( )。

1.先序遍历2.中序遍历3.后序遍历4.按层遍历9:48 对有n个记录的有序表采用二分查找,其平均查找长度的量级为()。

1. O(log2n)2.O(nlog2n)3.O(n)4. O(n2)10:2 线性表是具有n个( )的有限序列。

1.表元素2.字符3.数据元素4.信息项11:15 在一个单链表中,若删除(*p)结点的后继结点,则执行( )。

链式二路插入排序算法研究

链式二路插入排序算法研究
电脑 编程技巧与维护
链 式二路插入排序算法研 究
高慧 ,任志国 ,岳秋菊 ,达文姣
(.西北师范大学知行学院 ,兰州 7 0 7 ;2 兰州城市学院信息工程学院 ,兰州 1 300 . 摘 要 :讨论 了在单链表上 的二路插入排序算法的实现过程 ,并分析 了时间和 空间的复杂度 。 707) 3 0 0
Ab ta t n t i a t l ic s eBi ay P t n e t n S r Alo i m e l ai n p o e d d o i ge l k l t F n l sr c :I s ri e wed s u st n r a h I sri o t g rt r ai t rc e e n sn l - i i . i al h c h o h z o n s y w n lz e c mp e i f i n p c . e a ay e t o lxt o me a d s a e h y t Ke r s B n r ah I s rin S r ; i g e l k L s A g r h y wo d : i a y P t n e t o o t Sn l-i i n t; l o t m i
关键词 :二路插入排序 ; 单链表 ; 算法
Re e r h o n r t n e to o tAl o ih n Li k S o a e s a c fBi a y Pa h I s r i n S r g r t m o n t r g S r cu e tu t r
GAO Hl R N hg o , UE Qij 2 DA We j o l , E Z iu 2 Y u u , ni i a
(. hxn ol eo r s Nom l nvri L n h u7 0 7 ; 1 Z ii C l g f t Wet r a i sy, a zo 3 0 0 g a No h U e t 2 S h o o fr a o cec n n ier g, azo i nv rt L nhu70 7 ) . co l fno t nSineadE g ei L h uCt U iesy, azo 3 0 0 I m i n n n y i

写出在单链表中某p结点后插入s结点的语句。

写出在单链表中某p结点后插入s结点的语句。

写出在单链表中某p结点后插入s结点的语句。

《在单链表中某p结点后插入s结点的语句》一、引言在单链表的操作中,插入结点是一种常见而重要的操作。

特别是在某个特定结点后插入新结点,是单链表操作中的一个具有实际应用意义的问题。

本文将从多个角度探讨在单链表中某p结点后插入s结点的语句,旨在帮助读者深入理解并掌握这一操作。

二、基本概念在深入探讨插入操作之前,首先要了解单链表的基本概念。

单链表是一种常见的数据结构,由结点组成,每个结点包含数据域和指针域。

其中,数据域存储结点的数据,指针域存储下一个结点的位置区域。

在单链表中,要在某个结点后插入新结点,就需要修改前一个结点的指针域,使其指向新结点,而新结点的指针域则指向原来前一个结点指针域所指向的结点。

三、具体语句在单链表中某p结点后插入s结点的语句如下所示:1. 先创建一个新结点s,存储要插入的数据;2. 遍历单链表,找到目标结点p;3. 将新结点s的指针域指向目标结点p的下一个结点;4. 将目标结点p的指针域指向新结点s。

以上语句是实现在单链表中某p结点后插入s结点的基本步骤,可以根据具体情况做出一定的修改和调整。

四、总结在单链表中某p结点后插入s结点的语句,涉及了对单链表基本操作的灵活运用,需要细致的思考和严谨的处理。

通过本文的学习,相信读者能够更加深入地理解单链表操作的精髓,掌握这一重要操作。

五、个人观点在实际编程中,我认为掌握单链表的基本操作是非常重要的。

特别是在工程项目中,很多场景都需要对单链表进行操作,因此对于在单链表中某p结点后插入s结点的语句,我们需要深入理解并掌握,以便能够灵活运用于实际项目中。

六、结语通过本文对在单链表中某p结点后插入s结点的语句的探讨,相信读者已经对这一操作有了更深入的理解。

希望本文能够帮助读者在单链表操作中取得进一步的提高。

参考文献:[1] 《数据结构与算法分析——C语言描述》[2] 《算法导论》以上为文章所需内容,希望对你有所帮助。

单链表应用示例

单链表应用示例

学生成绩管理以单链表作为存储结构,设计和实现某班某门课程成绩管理的完整程序。

程序要求完成如下功能:(1)创建成绩链表,学生数据包含学生的学号、姓名和成绩。

(2)可以在指定学号学生前插入学生成绩数据。

(3)可以删除指定学号的学生数据。

(4)可以计算学生的总数。

(5)可以按学号和姓名查找学生。

(6)可以显示所有学生的成绩。

(7)可以把学生成绩按从高到低的顺序排列。

此处的设计思想基本与顺序表相同,只是对保存学生成绩的线性表采用不同的存储结构实现。

本例中用到的学生数据也是程序运行时由用户从键盘输入,保存到一个单链表中。

学生结构体类型的定义与顺序表应用举例处的定义相同,用C语言描述如下:typedef struct Student /*学生类型定义*/{ int score; /*成绩*/char sno[5],sname[8]; /*学号,姓名*/}Student;当学生的学号为“#”时,也是表示数据输入的结束。

单链表中保存的数据元素均为学生Student类型,则单链表定义如下:typedef struct Node /*结点类型定义*/{ Student studentInfo; /*学生信息*/struct Node *next; /*指向后继元素的指针域*/}LinkList;对学生的成绩按从高到低排序时,使用的也是直接插入排序思想。

此外,为了排序后还能在原单链表上继续进行操作,这里是把单链表中的内容复制到一个新单链表中,对新单链表排序,原单链表不变。

下面是以单链表作为存储结构实现的学生某门课程成绩管理的完整C语言程序。

#include<string.h>#include<malloc.h>#include <stdlib.h>#include <stdio.h>typedef struct Student /*学生类型定义*/{ int score; /*成绩*/char sno[5],sname[8]; /*学号,姓名*/}Student;typedef struct Node /*结点类型定义*/{ Student studentInfo; /*学生信息*/struct Node *next; /*指向后继元素的指针域*/}LinkList;void display(LinkList *p) /*在屏幕上显示一个学生的成绩信息*/{ printf("\n\n\nno\t\tname\t\tscore: ");printf("\n%s",p->studentInfo.sno); /*打印学号*/printf("\t\t ");printf("%s",p->studentInfo.sname); /*打印姓名*/printf("\t\t ");printf("%-4d\n",p->studentInfo.score); /*打印成绩*/}void displayAll(LinkList *L) /*在屏幕上显示所有学生的成绩信息*/ { LinkList *p;p=L->next;printf("\n\n\nno\t\tname\t\tscore: ");while(p){ printf("\n%s",p->studentInfo.sno); /*打印学号*/printf("\t\t ");printf("%s",p->studentInfo.sname); /*打印姓名*/printf("\t\t ");printf("%-4d\n",p->studentInfo.score);/*打印成绩*/p=p->next;}}LinkList *inputdata( ) /*输入学生信息*/{ LinkList *s=NULL ; /*s是指向新建结点的指针*/ char sno[5]; /*存储学号的数组*/printf("\n ");printf(" no: ");scanf("%s",sno); /*输入学号*/if(sno[0]=='#') /*#结束输入*/return s;s=( LinkList *)malloc(sizeof(LinkList));strcpy(s->studentInfo.sno,sno);if(strlen(sno)>4) /*如果sno字符个数大于等于5,因为字符串没有'\0'结束标志,在读数据时将把姓名字符一起读到sno数组,因此做了如下处理*/ s->studentInfo.sno[4]='\0';printf(" name: ");scanf("%s",s->studentInfo.sname); /*输入姓名*/printf("score: ");scanf("%d",&s->studentInfo.score);/*输入成绩*/return s;}LinkList *createTailList( ) /*以尾插法建立带头结点的学生信息单链表*/{ LinkList *L,*s, *r; /*L头指针,r尾指针,s是指向新建结点的指针*/ L=( LinkList *)malloc(sizeof (LinkList)); /*建立头结点,申请结点存储空间*/r=L; /*尾指针指向头结点*/printf("\请输入学生成绩,当学号no为\"#\"时结束:\n\n ");while (1) /*逐个输入学生的成绩*/{ s=inputdata( );if(!s) break; /*s为空时结束输入*/r->next=s; /*把新结点插入到尾指针后*/r=s; /*r 指向新的尾结点*/ }r->next=NULL; /*尾指针的指针域为空*/displayAll(L); /*显示所有学生信息*/return L;}Void locateElemByno(LinkList *L, char ch[5]) /*按学号查找学生的算法*/{ LinkList *p=L->next; /*从第一个结点开始查找*/ while ( p && (strcmp(p->studentInfo.sno,ch)!=0))/*p不空且输入学号与链表中学号不等*/ p = p ->next;if (!p){ printf("\n\n\tDon't find the student!\n" );}else{ display(p); /*显示查找到的学生信息*/}}void locateElemByname(LinkList *L, char sname[8])/*按姓名查找学生的算法*/{ LinkList *p=L->next; /*从第一个结点开始查找*/ while ( p&& (strcmp(p->studentInfo.sname,sname)!=0)) /*p不空且输入姓名与链表中姓名不等*/ p = p ->next;if (!p){ printf("\n\n\tDon't find the student!\n" ); }else{display(p); /*显示查找到的学生信息*/}}int lengthList (LinkList *L) /*求学生总人数的算法*/{ LinkList * p=L->next; /* p指向第一个结点*/int j=0;while (p){ p=p->next; j++ ;} /* p所指的是第j 个结点*/return j;}void insertElem ( LinkList *L, char ch[5]) /*在带头结点的单链表L中指定学号前插入学生*/ { LinkList *p,*s;p=L; /*从头结点开始查找学号为ch的结点的前趋结点p */while ((p->next) && (strcmp(p->next->studentInfo.sno,ch)!=0))p = p ->next;s=inputdata(); /*输入欲插入学生信息*/s->next=p->next;p->next=s;}void deleteElem (LinkList *L, char ch[5]) /*删除给定学号的学生信息的算法*/{ LinkList *p,*q;p=L;while ( (p->next)&&(strcmp(p->next->studentInfo.sno,ch)!=0 )){ p=p->next; /*从头结点开始查找学号为ch的结点的前趋结点p*/}if (!p->next) /* 已经扫描到表尾也没找到*/{ printf("\n\n\tDon't find the student!\n" );}else{ q=p->next; /*q指向学号为ch的结点*/printf("\n\ndeleted student's information:");display(q);p->next=q->next; /*改变指针*/free(q); /*释放q占用空间*/printf("\n\nall student's information :");displayAll(L);}}void insertSort(LinkList *L) /*用直接插入排序思想把学生的成绩按从高到低排序,结果保存在新有序链表中,原链表不变*/{ L inkList *L1,*p; /*L1有序链表的表头,p插入位置前结点*/ LinkList *q,*s; /*q欲插入L1中的结点*/int len;len=lengthList (L) ;L1=( LinkList *)malloc(sizeof (LinkList)); /*建立头结点,申请结点存储空间*/if (L->next) /*链表L非空*/{ /*生成有序链表的第一个结点*/s=( LinkList *)malloc(sizeof (LinkList)); /*建立结点,申请结点存储空间*/strcpy(s->studentInfo .sno ,L->next->studentInfo.sno);strcpy(s->studentInfo .sname,L->next->studentInfo.sname);s->studentInfo .score =L->next->studentInfo.score;s->next =NULL;L1->next=s; /*只有原单链表的第一个结点的有序链表L1*/q=L->next->next; /*原单链表的第二个结点,q即要插入有序链表L1中的结点*/ }else{ printf("\nthe student link list is empty\n");return;}while(q) /*链表L中有结点*/{ p=L1 ; /*从链表L1的第一个结点开始比较*/while((p->next) && (p->next->studentInfo.score>=q->studentInfo.score))p=p->next ; /*查找插入位置前结点*//*生成欲插入有序链表中的结点*/s=( LinkList *)malloc(sizeof (LinkList));/*建立结点,申请结点存储空间*/strcpy(s->studentInfo .sno ,q->studentInfo.sno);strcpy(s->studentInfo .sname ,q->studentInfo.sname);s->studentInfo .score =q->studentInfo.score;if(!p->next) /*p是有序链表的最后一个结点*/{ s->next =NULL ;p->next =s;}else{ s->next =p->next ;p->next =s;}q=q->next; /*下一个欲插入有序链表的结点*/ }/*while(!q)*/displayAll(L1); /*显示生成的有序链表*/}void main(){ printf("=============================================\n\n");printf(" 带头结点的学生成绩管理程序\n\n");printf("=============================================\n\n");LinkList *L;char ch[5],sname[8];int b=1;while(b){ int a;printf("\n\n");printf(" <1>创建(带头尾插)<2>指定学号前插入<3>按学号删除\n ");printf("<4>计算学生总数<5> 按学号查找<6> 按姓名查找\n");printf(" <7>显示所有学生<8>成绩排序<9> 退出\n");printf("\n请输入功能选项:");scanf("%d",&a);switch(a){case 1:L=CreateTailList();break;case 2:printf("\n输入欲在哪个学号前插入数据:");scanf("%s",ch);insertElem(L, ch) ;break;case 3:printf("\n输入欲删除学生的学号:");scanf("%s",ch);deleteElem(L, ch) ;break;case 4:printf(" \n学生总数为:%d \n",lengthList (L) );break;case 5:printf("\n输入欲查找学生的学号:");scanf("%s",ch);locateElemByno(L, ch) ;break;case 6:printf("\n输入欲查找学生的姓名:");scanf("%s",sname);locateElemByname(L, sname );break;case 7:displayAll(L);break;case 8:insertSort(L);break;case 9:printf("\n已退出\n");b=0;break;};}}上机运行程序后,程序执行结果如图2.31(a)~(i)所示。

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

单链表使用直接插入法排序
第一步、、判断是否只有一个头节点或者只有一个数据节点?
如果是的话,那当然就不用排序了。

因为已经成有序了。

Link Sort(Link Head)
{//我创建的是带头节点的链表。

if(!Head->Next||!Head->Next->Next)//此步条件判断非常有价值。

return Head;
第二步:既然有多个数据节点,那就要排序了。

此步做初始工作:先将一个整个链表分成一个有序链表和一个无序链表。

如图形式2。

Link Sort(Link Head)
{//我创建的是带头节点的链表。

if(!Head->Next||!Head->Next->Next)//此步条件判断非常有价值。

return Head;
//-----------第二步;
ptr=Head->Next->Next;
ptr_F=Head;
Head->Next->Next=NULL;//到此,分成了两个链表。

第三步:现在正式开始!(此步骤需要注意:不要让后面的无序链表断了,找不着了。


Link Sort(Link Head)
{//我创建的是带头节点的链表。

用直接插入法。

if((Head->Next==NULL)||(Head->Next->Next==NULL))//此步条件判断非常有价值。

{
cout<<"数据节点数少于2个,不用排序!"<<endl;
return Head;
}
//-----------第二步;
Link ptr;
Link ptr_F;
Link ptr_N;
ptr=Head->Next->Next;
ptr_F=Head;
Head->Next->Next=NULL;//到此,分成了两个链表。

//第三步。

while(ptr)
{
ptr_N=ptr->Next;
ptr_F=Head;//ptr_F的归位。

while(ptr_F->Next)
{
if(ptr->m_Wage>ptr_F->Next->m_Wage)
{
ptr->Next=ptr_F->Next;
ptr_F->Next=ptr;
break; //注意这里是跳出while(ptr_F->Next)循环.
}//if
else
{
ptr_F=ptr_F->Next;
}
}//while(ptr_F->Next)
if(ptr_F->Next==NULL)
{
ptr->Next=ptr_F->Next;
ptr_F->Next=ptr;//表示插到有序链表的最后面了。

}
ptr=ptr_N;//归位,准备下一次排序。

}//while(ptr)
cout<<"从高到低,排序成功!"<<endl;
return Head;
}
/blog/static/129570334201052004650243/。

相关文档
最新文档