设计一算法,逆置带头结点的动态单链表L

设计一算法,逆置带头结点的动态单链表L
设计一算法,逆置带头结点的动态单链表L

#include

#include

#include

typedef int datatype;

typedef struct node

{

datatype data;

struct node *next;

}linklist;

linklist *creatlistr()

{

// datatype elem;

int n;

linklist *head,*s,*r;

head=(linklist *)malloc(sizeof(linklist));

r=head;

printf("请输入要插入的结点的个数:");

scanf("%d",&n);

printf("请输入%d个结点:",n);

while(n--)

{

s=(linklist *)malloc(sizeof(linklist));

scanf("%d",&s->data);

r->next=s;

r=s;

}

r->next=NULL;

return head;

}

void reverseLinklist(linklist *head)

{

linklist *y,*r,*t;

t=NULL;

r=NULL;

y=head->next;

head->next=NULL; //断开头指针

while(y!=NULL) //从第一个结点起,将后边的结点依次放到最前边,实现逆置{

t=y->next;

y->next=r;

r=y;

y=t;

}

head->next=r; //重新链接上头结点,保证最初链的完整

void show(linklist *head)

{

linklist *p;

p=head->next;

while(p!=NULL)

{

printf("%4d",p->data);

p=p->next;

}

}

int main()

{

linklist *head;

head=creatlistr();

reverseLinklist(head);

show(head);

printf("\n");

system("pause");

return 0;

}

经过codeblocks验证,完美运行。

适用于数据结构2.6 习题

更多数据结构————adam

动态规划算法原理与的应用

动态规划算法原理及其应用研究 系别:x x x 姓名:x x x 指导教员: x x x 2012年5月20日

摘要:动态规划是解决最优化问题的基本方法,本文介绍了动态规划的基本思想和基本步骤,并通过几个实例的分析,研究了利用动态规划设计算法的具体途径。关键词:动态规划多阶段决策 1.引言 规划问题的最终目的就是确定各决策变量的取值,以使目标函数达到极大或极小。在线性规划和非线性规划中,决策变量都是以集合的形式被一次性处理的;然而,有时我们也会面对决策变量需分期、分批处理的多阶段决策问题。所谓多阶段决策问题是指这样一类活动过程:它可以分解为若干个互相联系的阶段,在每一阶段分别对应着一组可供选取的决策集合;即构成过程的每个阶段都需要进行一次决策的决策问题。将各个阶段的决策综合起来构成一个决策序列,称为一个策略。显然,由于各个阶段选取的决策不同,对应整个过程可以有一系列不同的策略。当过程采取某个具体策略时,相应可以得到一个确定的效果,采取不同的策略,就会得到不同的效果。多阶段的决策问题,就是要在所有可能采取的策略中选取一个最优的策略,以便得到最佳的效果。动态规划是一种求解多阶段决策问题的系统技术,可以说它横跨整个规划领域(线性规划和非线性规划)。在多阶段决策问题中,有些问题对阶段的划分具有明显的时序性,动态规划的“动态”二字也由此而得名。动态规划的主要创始人是美国数学家贝尔曼(Bellman)。20世纪40年代末50年代初,当时在兰德公司(Rand Corporation)从事研究工作的贝尔曼首先提出了动态规划的概念。1957年贝尔曼发表了数篇研究论文,并出版了他的第一部著作《动态规划》。该著作成为了当时唯一的进一步研究和应用动态规划的理论源泉。在贝尔曼及其助手们致力于发展和推广这一技术的同时,其他一些学者也对动态规划的发展做出了重大的贡献,其中最值得一提的是爱尔思(Aris)和梅特顿(Mitten)。爱尔思先后于1961年和1964年出版了两部关于动态规划的著作,并于1964年同尼母霍思尔(Nemhauser)、威尔德(Wild)一道创建了处理分枝、循环性多阶段决策系统的一般性理论。梅特顿提出了许多对动态规划后来发展有着重要意义的基础性观点,并且对明晰动态规划路径的数

北京邮电大学 数据结构 实验一 带头结点的单链表构造

数据结构实验报告 实验名称:实验1——单链表的构造 学生姓名:XXXXNB 班级:XXXX 班内序号: 学号:XXXX 日期:XXXXX 1.实验要求 根据线性表的抽象数据类型的定义,完成带头结点的单链表的基本功能。 单链表的基本功能: 1、构造:使用头插法、尾插法两种方法 2、插入:要求建立的链表按照关键字从小到大有序 3、删除 4、查找 5、获取链表长度 6、销毁 7、其他:可自行定义 编写测试main()函数测试线性表的正确性。 2.程序分 编程完成单链表的一般性功能如单链表的构造:使用头插法、尾插法两种方法插入:要求建立的链表按照关键字从小到大有序,删除,查找,获取链表长度,销毁用《数据结构》中的相关思想结合C++语言基本知识编写一个单链表结构。本程序为使用方便,几乎不用特殊的命令,只需按提示输入即可,适合更多的用户使用。 2.1 存储结构 单链表的存储结构:

2.2 关键算法分析 1.头插法 自然语言描述:a.在堆中建立新结点 b.将a[i]写入到新结点的数据域 c.修改新结点的指针域 d.修改头结点的指针域,将新结点加入链表中 //在构建之初为了链表的美观性构造,进行了排序 代码描述: //头插法构造函数 template LinkList::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; } }

c语言 不带头结点的循环链表joseph问题

Joseph问题 题目描述: 原始的Joseph问题的描述如下:有n个人围坐在一个圆桌周围,把这n个人依次编号为1,…,n。从编号是start的人开始报数,数到第num个人出列,然后从出列的下一个人重新开始报数,数到第num个人又出列,…,如此反复直到所有的人全部出列为止。比如当n=6,start=1,num=5的时候,出列的顺序依次是5,4,6,2,3,1。 以下是不带头结点的循环链表算法 */ #include #include typedef int data_t; typedef struct node { data_t data; struct node *next; }listnode, *linklist; /*创建一个不带头节点的循环链表*/ listnode* CreatCycleList(int num) { int i = 2; listnode *head = NULL, *q = NULL, *p = NULL; head = (listnode*)malloc(sizeof(listnode)); head->data = 1; head->next = NULL; p = head; while(i <= num) { q = (listnode*)malloc(sizeof(listnode)); q->data = i; q->next = NULL; p->next = q; p = q; i++; } p->next = head;

return head; } listnode* Joseph(listnode *head, int start, int killNum) { int i; listnode *p, *q;//p遍历链表,q指向待宰的人 p = head; /* 找位置,p最后停在开始报数的前一个人处*/ if(start == 1) { while(p->next != head) { p = p->next; } } else { for(i = 1; i < start-1; i++) { p = p->next; } } /* 开杀*/ while(p != p->next) { for(i = 1; i < killNum; i++) { p = p->next; } q = p->next; p->next = q->next; printf("%d,",q->data); free(q); q = NULL; } return p; }

倒置单链表的算法

倒置单链表的算法 void pur_LinkList(LinkList H) { LNode *p,*q,*r; p=H->next; /*p指向第一个结点*/ if(p==NULL) return; while (p->next) { q=p; while (q->next) /* 从*p的后继开始找重复结点*/ { if (q->next->data==p->data) { r=q->next; /*找到重复结点,用r指向,删除*r */ q->next=r->next; free(r); } /*if*/ else q=q->next; } /*while(q->next)*/ p=p->next; /*p指向下一个,继续*/ } /*while(p->next)*/ } ―――――――――――――――――――――――――――――――――――――status LinkListReverse(LinkList L) /*对单链表中的元素倒置*/ { int a[N] ,i=0,count=0; LinkList Lb; Node *p,*q; p=L->next; while(p!=NULL) { a[i++]=p->data; p=p->next; count++; } ―――――――――――――――――――――――――――――――― 2.21 void reverse(SqList &A)//顺序表的就地逆置 { for(i=1,j=A.length;iA.elem[j]; }//reverse 2.22 void LinkList_reverse(Linklist &L)//链表的就地逆置;为简化算法,假设表长大于2 {

南京邮电大学算法设计实验报告——动态规划法

实验报告 (2009/2010学年第一学期) 课程名称算法分析与设计A 实验名称动态规划法 实验时间2009 年11 月20 日指导单位计算机学院软件工程系 指导教师张怡婷 学生姓名丁力琪班级学号B07030907 学院(系) 计算机学院专业软件工程

实验报告 实验名称动态规划法指导教师张怡婷实验类型验证实验学时2×2实验时间2009-11-20一、实验目的和任务 目的:加深对动态规划法的算法原理及实现过程的理解,学习用动态规划法解决实际应用中的最长公共子序列问题。 任务:用动态规划法实现求两序列的最长公共子序列,其比较结果可用于基因比较、文章比较等多个领域。 要求:掌握动态规划法的思想,及动态规划法在实际中的应用;分析最长公共子序列的问题特征,选择算法策略并设计具体算法,编程实现两输入序列的比较,并输出它们的最长公共子序列。 二、实验环境(实验设备) 硬件:计算机 软件:Visual C++

三、实验原理及内容(包括操作过程、结果分析等) 1、最长公共子序列(LCS)问题是:给定两个字符序列X={x1,x2,……,x m}和Y={y1,y2,……,y n},要求找出X和Y的一个最长公共子序列。 例如:X={a,b,c,b,d,a,b},Y={b,d,c,a,b,a}。它们的最长公共子序列LSC={b,c,d,a}。 通过“穷举法”列出所有X的所有子序列,检查其是否为Y的子序列并记录最长公共子序列并记录最长公共子序列的长度这种方法,求解时间为指数级别的,因此不可取。 2、分析LCS问题特征可知,如果Z={z1,z2,……,z k}为它们的最长公共子序列,则它们一定具有以下性质: (1)若x m=y n,则z k=x m=y n,且Z k-1是X m-1和Y n-1的最长公共子序列; (2)若x m≠y n且x m≠z k,则Z是X m-1和Y的最长公共子序列; (3)若x m≠y n且z k≠y n,则Z是X和Y的最长公共子序列。 这样就将求X和Y的最长公共子序列问题,分解为求解较小规模的问题: 若x m=y m,则进一步分解为求解两个(前缀)子字符序列X m-1和Y n-1的最长公共子序列问题; 如果x m≠y n,则原问题转化为求解两个子问题,即找出X m-1和Y的最长公共子序列与找出X 和Y n-1的最长公共子序列,取两者中较长者作为X和Y的最长公共子序列。 由此可见,两个序列的最长公共子序列包含了这两个序列的前缀的最长公共子序列,具有最优子结构性质。 3、令c[i][j]保存字符序列X i={x1,x2,……,x i}和Y j={y1,y2,……,y j}的最长公共子序列的长度,由上述分析可得如下递推式: 0 i=0或j=0 c[i][j]= c[i-1][j-1]+1 i,j>0且x i=y j max{c[i][j-1],c[i-1][j]} i,j>0且x i≠y j 由此可见,最长公共子序列的求解具有重叠子问题性质,如果采用递归算法实现,会得到一个指数时间算法,因此需要采用动态规划法自底向上求解,并保存子问题的解,这样可以避免重复计算子问题,在多项式时间内完成计算。 4、为了能由最优解值进一步得到最优解(即最长公共子序列),还需要一个二维数组s[][],数组中的元素s[i][j]记录c[i][j]的值是由三个子问题c[i-1][j-1]+1,c[i][j-1]和c[i-1][j]中的哪一个计算得到,从而可以得到最优解的当前解分量(即最长公共子序列中的当前字符),最终构造出最长公共子序列自身。

第三章 单链表 题目和答案

第2章自测卷答案 一、填空 1.顺序表中逻辑上相邻的元素的物理位置相互相邻。单链表中逻辑上相邻的元素的物理位置不 相邻。 2.在单链表中,除了首元结点外,任一结点的存储位置由其直接前驱结点值域指示。 3.在n个结点的单链表中要删除已知结点*p,需找到它的地址。 二、判断正误(在正确的说法后面打勾,反之打叉) 1. 链表的每个结点中都恰好包含一个指针。X 2. 链表的物理存储结构具有同链表一样的顺序。X 3. 链表的删除算法很简单,因为当删除链中某个结点后,计算机会自动地将后续的各个单元向前移动。X 4. 线性表的每个结点只能是一个简单类型,而链表的每个结点可以是一个复杂类型。Y 5. 顺序表结构适宜于进行顺序存取,而链表适宜于进行随机存取。Y 6. 顺序存储方式的优点是存储密度大,且插入、删除运算效率高。X 7. 线性表在物理存储空间中也一定是连续的。X 8. 线性表在顺序存储时,逻辑上相邻的元素未必在存储的物理位置次序上相邻。X 9. 顺序存储方式只能用于存储线性结构。X 10. 线性表的逻辑顺序与存储顺序总是一致的。X 三、单项选择题 (A)1. 链接存储的存储结构所占存储空间: (A)分两部分,一部分存放结点值,另一部分存放表示结点间关系的指针 (B)只有一部分,存放结点值 (C)只有一部分,存储表示结点间关系的指针 (D)分两部分,一部分存放结点值,另一部分存放结点所占单元数 (B)2. 链表是一种采用存储结构存储的线性表; (A)顺序(B)链式(C)星式(D)网状 (D)3. 线性表若采用链式存储结构时,要求内存中可用存储单元的地址: (A)必须是连续的(B)部分地址必须是连续的 (C)一定是不连续的(D)连续或不连续都可以 (B)4.线性表L在情况下适用于使用链式结构实现。 (A)需经常修改L中的结点值(B)需不断对L进行删除插入 (C)L中含有大量的结点(D)L中结点结构复杂 (C)5.单链表的存储密度 (A)大于1;(B)等于1;(C)小于1;(D)不能确定 (A)6、在单链表的一个结点中有个指针。

数据结构___头插法和尾插法建立链表(各分有无头结点)

实验一链表的建立及基本操作方法实现 一、【实验目的】 、理解和掌握单链表的类型定义方法和结点生成方法。 、掌握利用头插法和尾插法建立单链表和显示单链表元素的算法。 、掌握单链表的查找(按序号)算法。 、掌握单链表的插入、删除算法。 二、【实验内容】 、利用头插法和尾插法建立一个无头结点单链表,并从屏幕显示单链表元素列表。 、利用头插法和尾插法建立一个有头结点单链表,并从屏幕显示单链表元素列表。 、将测试数据结果用截图的方式粘贴在程序代码后面。 重点和难点: 尾插法和头插法建立单链表的区别。 建立带头结点和无头结点单链表的区别。 带头结点和无头结点单链表元素显示方法的区别 三、【算法思想】 ) 利用头插法和尾插法建立一个无头结点单链表 链表无头结点,则在创建链表时,初始化链表指针。 当用头插法插入元素时,首先要判断头指针是否为空,若为空,则直接将新结点赋给,新结点指向空,即>,若表中已经有元素了,则将新结点的指向首结点,然后将新结点赋给即(>)。当用尾插法插入元素时,首先设置一个尾指针以便随时指向最后一个结点,初始化和头指针一样即。插入元素时,首先判断链表是否为空,若为空,则直接将新结点赋给即,若不为空,将最后一个元素的指向新结点即>,然后跳出这个语句,将新结点指向空,并且将指向新结点即>。 ) 利用头插法和尾插法建立一个有头结点单链表 链表有头结点,则在创建链表时,初始化链表指针> 。与无头结点区别在于,判断链表为空是根据>是否为空。 用头插法插入元素时,要判断链表是否为空,若为空则将新结点指向空,作为表尾,若不为空,则直接插入,将新结点指向头结点的指向,再将头结点指向新结点即>>>。 用尾插法插入元素时,首先也要设置一个尾指针以便随时指向最后一个结点,初始化,与无头结点区别就只是插入第一个元素时有区别。插入元素时,不需要判断链表是否为空,直接进行插入,代码>>。 )带头结点和无头结点单链表元素显示方法的区别: 区别在于,显示时带头结点是从头结点开始即>,而无头结点链表是直接从开始即。 四、【源程序代码】 ) 利用头插法和尾插法建立一个无头结点单链表 <>

算法设计动态规划(编辑距离)

《算法设计与分析》课程报告 课题名称:动态规划——编辑距离问题 课题负责人名(学号): 同组成员名单(角色):无 指导教师:左劼 评阅成绩: 评阅意见: 提交报告时间:2010年 6 月 23 日

动态规划——编辑距离问题 计算机科学与技术专业 学生指导老师左劼 [摘要]动态规划的基本思想与分治法类似,也是将待求解的问题分解成若干份的子问题,先分别解决好子问题,然后从子问题中得到最终解。但动态规划中的子问题往往不是相互独立的,而是彼此之间有影响,因为有些子问题可能要重复计算多次,所以利用动态规划使这些子问题只计算一次。将字符串A变换为字符串所用的最少字符操作数称为字符串A到B的编辑距离。 关键词:动态规划矩阵字符串操作数编辑距离

一、问题描述 1、基本概念:设A和B是2个字符串。要用最少的字符操作将字符串A转换为字符串B。字符串操作包括: (1) 删除一个字符; (2) 插入一个字符; (3) 将一个字符改为另一个字符。 将字符串A变换为字符串B所用的最少字符操作数称为字符串A 到B的编辑距离,记为d(A,B)。 2、算法设计:设计一个有效算法,对于给定的任意两个字符串A 和B,计算其编辑距离d(A,B)。 3、数据输入:输入数据由文件名为input.txt的文本文件提供。文件的第1行为字符串A,第二行为字符串B。 4、结果输出:将编辑距离d(A,B)输出到文件ouput.txt的第一行。 输入文件示例输出文件示例 input.txt output.txt fxpimu 5 xwrs 二、分析 对于本问题,大体思路为:把求解编辑距离分为字符串A从0个字符逐渐增加到全部字符分别想要变为字符串B该如何变化以及变化的最短距离。 具体来说,首先选用数组a1存储字符串A(设长度为n),a2存储字符串B(设长度为m),d矩阵来进行具体的运算;这里有两个特殊情况比较简单可以单独考虑,即A的长度为0而B不为0还有A不为0B为0,这两种情况最后的编辑距离分别为m和n;讨论一般情况,d矩阵为d[n][m],假定我们从d[0][0]开始一直进行以下操作到了d[i][j]的位置,其中删除操作肯定是A比B长,同理,插入字符操作一定是A比B短,更改字符操作说明一样长,我们所要做的是对d[i][j-1]

数据结构算法习题答案带头结点的循环链表表示队列,并且只设一个指针指向队尾元素结点(注意不设头指针)

数据结构算法题(假设以带头结点的循环链表表示队列,并且只设一个指针指向队尾元素结点(注意不设头指针)试编写相应的队列初始化,入队列和出队列的算法!) (提供两种答案哦!!!) 一: //既然是算法就不用源码了具体看注释 typedef int Datatype; typedef struct queuenode { Datatype data; struct queuenode *next; }QueueNode; //以上是结点类型的定义 typedef struct { queuenode rear; }LinkQueue; //只设一个指向队尾元素的指针 void InitQueue( LinkQueue &Q) { //置空队:就是使头结点成为队尾元素 =(queuenode*)malloc(sizeof(queuenode)) QueueNode* s; Q->rear = Q->rear->next;//将队尾指针指向头结点 while(Q->rear!=Q->rear->next) //当队列非空,将队中元素逐个出队 { s=Q->rear->next; Q->rear->next=s->next; free(s); } //回收结点空间 } int EmptyQueue( LinkQueue &Q) { //判队空 //当头结点的next指针指向自己时为空队 return Q->rear->next->next==Q->rear->next; }

void EnQueue( LinkQueue &Q, Datatype x) { //入队 //也就是在尾结点处插入元素 QueueNode *p=(QueueNode *) malloc (sizeof(QueueNode));//申请新结点 p->data=x; p->next=Q->rear->next;//初始化新结点并链入 Q-rear->next=p; Q->rear=p;//将尾指针移至新结点 } Datatype DeQueue( LinkQueue &Q,Datatype &x) { //出队,把头结点之后的元素摘下 Datatype t; QueueNode *p; if(EmptyQueue( Q )) Error("Queue underflow"); p=Q->rear->next->next; //p指向将要摘下的结点 x=p->data; //保存结点中数据 if (p==Q->rear) { //当队列中只有一个结点时,p结点出队后,要将队尾指针指向头结点 Q->rear = Q->rear->next; Q->rear->next=p->next; } else Q->rear->next->next=p->next;//摘下结点p free(p);//释放被删结点 return x; } 二: typedef struct Node { int data; struct Node *next; }Node,*CiLNode; typedef struct

第三章 链表 基本题

第三章链表 基本题 3.2.1单项选择题 1.不带头结点的单链表head为空的判定条件是 A.head=NULL B.head->next=NULL C.head->next=head D.head!=NULL 2.带头接待点的单链表head为空的判定条件是 A.head=NULL B.head->next=NULL C.head->next=head D.head!=NULL 3.非空的循环单链表head的尾结点(由p所指向)满足 A.p->head=NULL B.p=NULL C.p->next=head D.p=head 4.在循环双链表p的所指结点之后插入s所指结点的操作是 A.p->right=s; s->left=p; p->right->lefe=s; s->right=p->right; B.p->right=s; p->right->left=s; s->lefe=p; s->right=p->right; C.s->lefe=p; s->right=p->right; p->right=s; p->right->left=s; D.s->left=p; s->right=p->right; p->right->left=s; p->right=s; 5.在一个单链表中,已知q所指结点是所指结点p的前驱结点,若在q和p之间插入结点S,则执行 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; 6.在一个单链表中,若p所指结点不是最后结点,在p之后插入s所指结点,则执行 A.s->next=p; p->next=s; B.s->next=p->next; p->next=s; C.s->next=p->next; p=s; D.p->next=s; s->next=p; 7.在一个单链表中,若删除p所指结点的后续结点,则执行 A.p->next=p->next->next; B.p=p->next; p->next=p->next->next; C.p->next=p->next D.p=p->next->next 8.假设双链表结点的类型如下: typedef struct linknode {int data; /*数据域*/ Struct linknode *llink; /*llink是指向前驱结点的指针域*/ Struct linknode *rlink; /*rlink是指向后续结点的指针域*/ }bnode 下面给出的算法段是要把一个所指新结点作为非空双向链表中的所指结点的前驱结点插入到该双链表中,能正确完成要求的算法段是 A.q->rling=p; q->llink=p->llink; p->llink=q;

数据结构C语言版顺序表和单链表的逆置

数据结构C语言版顺序表和单链表的逆置 公司标准化编码 [QQX96QT-XQQB89Q8-NQQJ6Q8-MQM9N]

实验1-1 顺序表的逆置操作 程序原码 #include<> // 创建顺序表,确定元素个数,插入各个元素,逆置列表。#include<> #include<> #define max_list_size 100 //定义给顺序表分配空间大小 typedef struct{ int *elem; int length; }list_node; //指向顺序表首地址的结构体单元 list_node L; //这里使用了全局变量,在所有的函数里可以随意修改其值int list[max_list_size]; void init(); // 初始化操作 void inversion(); // 倒置部分

void creat(); // 建表部分 void display(); // 显示部分 //*************主函数****************** int main() { init(); creat(); printf("\n您输入的顺序表的结点数: \n"); display(); inversion(); printf("\n倒置顺序表的结点数: \n"); display(); } //*************初始化操作分配空间******************

void init() { = (int *) malloc (max_list_size * sizeof(int) ); if (! { printf("顺序表已满"); exit(-1); } = 0; } //*************以下为建表部分****************** void creat(){ int a, b, i; printf("请输入顺序表的结点数: "); scanf("%d", &a); if(a<=0){

带头结点单链表中数据就地逆置

实验3 :带头结点单链表中数据就地逆置 一、实验目的: 1. 会定义单链表的结点类型; 2. 熟悉对单链表的一些基本操作和具体的函数定义; 3. 了解和掌握单链表的调用格式。 二、实验要求: 1. 认真阅读和掌握实验内容所给的程序,并上机运行; 2. 保存程序运行结果,并结合程序进行分析; 3. 尝试自己调试修改程序并试运行。 三、实验内容: 编写算法实现带头结点单链表的就地逆置,即利用原带头结点单链表的结点空间把数据元素序列逆置。 四、实验程序: #include #include #include typedef int datatype; typedef struct snode { datatype data; struct snode*next; }slnode; sllinitiate(slnode**head); linlistsort(slnode*head); int sllinsert(slnode*head,int i,datatype x); int slldelete(slnode*head,int i,datatype x); int sllget(slnode*head,int i,datatype*x); int sllnotempty(slnode*head); linlistsurt(slnode*head); linlistinsert(slnode*head,datatype x);

converse(slnode*head); main(void) { datatype test[6]={64,6,7,89,12,24}; slnode*head,*p; int n=6,i; sllinitiate(&head); for(i=1;i<=n;i++) sllinsert(head,i,test[i-1]); linlistsort(head); linlistinsert(head,25); converse(head); p=head->next; while(p!=NULL) { printf("%d",p->data); p=p->next; } } sllinitiate(slnode**head) { if((*head=(slnode*)malloc(sizeof(slnode)))==NULL)exit(1); (*head)->next=NULL; } int sllinsert(slnode*head,int i,datatype x) { slnode*p,*q; int j;

单链表算法

1.已知非空带表头结点的线性链表由list指出,链结点的结构为(data,next), 请写一算法,将链表中数据域值最小的那个链结点移到链表的最前面。要求:不得额外申请新的链结点。 delinsert(LinkList list) { p=list->next; //工作指针 pre=list; //最小元素结点前驱 q=p; //最小元素结点 while(p->next!=NULL) { if(p->next->datadata) { q=p->next; pre=p; } p=p->next; } //查找最小元素结点 if(q!=list->next) //最小元素结点不是第一个结点 { pre->next=q->next; //从原位置删除 q->next=list->next; list->next=q; //在头结点后插入,使最小元素结点成为第一个结点} } 2.在带头结点的单链表中,设计算法dellist_maxmin,删除所有数据域大于 min,而小于max的所有元素。 dellist_maxmin(linklist*head,int min,int max) { pre=head; //工作指针前驱 p=head->next; //工作指针 while(p!=NULL) if (p->data<=min || p->data>=max) //不满足删除条件 { pre=p; p=p->next; } else //满足删除条件 { pre->next=p->next; free(p); p=pre->next; //删除 } } 3.编写一个将带头结点单链表逆置的算法。 void reverse_list(linklist head)

不带头结点的单链表head为空的条件

不带头结点的单链表head为空的判别条件是()A.head!=NULL B.head—>link= =NULL C.head—>link= =head D.head= =NULL B 因为不带头结点,所以head的下一位是第一位 即判断head->link是否为空即可 不带头结点的单链表head为空的判定条件是什么head==NULL;头指针直接指向空 若有头结点,则为head->next==NULL head==null; 带头结点的是head->null; ( )不带头结点的单链表head为空的判定条件是 head==NULL head->next==NULL

head!=NULL head->next==head A head == NULL 带头结点的单链表head为空的判定条件() 正确答案: B 你的答案: C (错误) head==NULL head->next==NULL head->next==head head!=NULL B 注意是带头结点,如果不带头结点就选A 为何头指针为head的带头结点的单链表判空条件head->next==null?其实一开始这里也是没啥问题的,只是突然产生了疑问点——head为头指针,储存了头结点的地址,按照我残余的一点指针知识,我总感觉不对,head只是个地址,咋可以直接head->next使用呢?其实哈,这里又产生了和我之前学结构体这个知识点一样的纠结点(嘿嘿,其实这里也算是结构体类型)——结构体 总之和结构体类型一样这个指向符号“->”,这里是有特殊规定的,

比如你定义个结构体类型 struct student { int age; float score; char name[100]; }*pstu,stu; 你用stu.age,pstu->age或者(*pstu).age都是一样可以取到成员变量的,这里的pstu它也是个地址,但是c语言就是这么规定了利用pstu->age可以取到其结构体内部成员变量(记住就好)所以不

数据结构单链表、双链表的逆置算法

数据结构与算法 的课程设计 课程设计题目:数据结构的逆置算法 院系名称:信息技术学院 专业(班级):计算机2班 姓名: 学号: 指导教师:

实验内容:分别用一维数组,单链表,双链表实现逆置 (一)使用一维数组实现逆置 1.需求分析:定义一个一维数组(整型),用for语句实现循环,给数组元素赋值,并将 数组元素逆序输出。 2.详细设计: main() { int a[3],i; /*定义元素个数为3的一维数组*/ for(i=0;i<3;i++) scanf("%d",&a[i]); for(i=2;i>=0;i--) printf("%d ",a[i]); getch(); } 3.运行及调试: 4.附录: #include void main() { int a[3],i; /*定义一维数组*/ for(i=0;i<3;i++) scanf("%d",&a[i]); for(i=2;i>=0;i--) printf("%d ",a[i]); getch(); } (二)单链表实现逆置 1.需求分析:创建一个单链表并实现逆序输出 2.详细设计:定义的所有数据类型,对每个操作写出伪码算法;对主程序和其他模块也都写出伪码算法。 (1)单链表的定义 typedef struct node

{ int data;/*数据域为整型*/ struct node* next; /*定义结点的指针域*/ }LinkList;/*数据结点*/ (2)头插法建立单链表 Tnode *CreatList() { Tnode *head; /*头指针*/ LinkList *p;/*工作指针/ int ip; head=(Tnode *)malloc(sizeof(Tnode)); head->next=NULL;/*链表开始为空*/ printf("please input the number:\n"); scanf("%d",&ip); /*向链表中添加元素*/ while(ip!=000) { p=(LinkList *)malloc(sizeof(LinkList));/*生成新结点*/ p->data=ip; /*将值赋给新生结点*/ p->next=head->next; head->next=p; scanf("%d",&ip); } if(ip==000) /*当输入的数值为000时结束*/ printf("\nthe ip is end!\n\n"); return head; } (3)读取链表中的数据 void ReadList(Tnode *head) { LinkList *p; p=head->next; while(p) { printf("%d ",p->data); p=p->next; } printf("\n"); } (4)链表的倒置 void ExchangeList(Tnode *head) { LinkList *r,*s; r=head->next; head->next=NULL; while(r) { s=r->next; r->next=head->next; head->next=r; r=s;

动态规划算法的应用

动态规划算法的应用 一、实验目的 1.掌握动态规划算法的基本思想,包括最优子结构性质和基于表格的最优值计算方法。 2.熟练掌握分阶段的和递推的最优子结构分析方法。 3.学会利用动态规划算法解决实际问题。 二、实验内容 题目一:数塔问题 给定一个数塔,其存储形式为如下所示的下三角矩阵。在此数塔中,从顶部出发,在每一节点可以选择向下走还是向右走,一直走到底层。请找出一条路径,使路径上的数值和最大。 输入样例(数塔): 9 15 10 6 8 2 18 9 5 19 7 10 4 16 输出样例(最大路径和): 59 三、实验步骤 (1)需求分析 通过动态规划法解决数塔问题。从顶部出发,在每一节点可以选择向下或者向右走,一直走到底层,以找出一条数值最大的路径。 (2)概要设计 本次实验程序主要用到二维数组,以及通过动态规划法进行比较每个数的大小。主要运用两个for循环语句实现动态规划。

(3)详细设计 第一步,输入给定的二维数组并打印出相应的数组: int array[5][5]={{9}, /* */{12,15}, /* */{10,6,8}, /* */{2,18,9,5}, /* */{19,7,10,4,6}}; int i,j; for(i=0;i<5;i++) { for(j=0;j<5;j++) cout<0;j--) { for(i=0;i<=4;i++) { if(array[j][i]>array[j][i+1]) array[j-1][i]=array[j][i]+array[j-1][i]; else array[j-1][i]=array[j][i+1]+array[j-1][i]; } } 第三步,输出最大路径的值。 cout<

实验2-不带头结点的单链表

上海电力学院 数据结构实验报告 (2014/2015 学年第2学期)课程编号 250504704 课程名称数据结构 院(系) 专业 班级 学号 姓名 实验名称实验2 不带头结点的单链表 任课老师卢芳芳

实验2 不带头结点的单链表 1【实验目的与要求】 1、熟练掌握动态链表结构及有关算法的设计方法。 2、理解不带表头结点的单链表的特点,掌握其基本操作。 3、熟练掌握运用不带头结点链表表示特定形式的数据的方法,并设计出有关算法。 2【实验内容和步骤】 已知不带头结点的链表结构定义及头插法建表、尾插法建表和打印链表等函数定义如下(详见slnklist.h文件),基于该文件完成实验题1-实验4. #include #include /**************************************/ /* 链表实现的头文件,文件名slnklist.h */ /**************************************/ typedef int datatype; typedef struct link_node{ datatype info; struct link_node *next; }node; typedef node *linklist; /**********************************/ /*函数名称:creatbystack() */ /*函数功能:头插法建立单链表*/ /**********************************/ linklist creatbystack() { linklist head,s; datatype x; head=NULL; printf("请输入若干整数序列:\n"); scanf("%d",&x); while (x!=0) /*以0结束输入*/ { s=(linklist)malloc(sizeof(node)); /*生成待插入结点*/ s->info=x; s->next=head; /*将新结点插入到链表最前面*/ head=s; scanf("%d",&x); } return head; /*返回建立的单链表*/ } /**********************************/ /*函数名称:creatbyqueue() */ /*函数功能:尾插法建立单链表*/ /**********************************/ linklist creatbyqueue() { linklist head,r,s; datatype x; head=r=NULL; printf("请输入若干整数序列:\n"); scanf("%d",&x); while (x!=0) /*以0结束输入*/ { s=(linklist)malloc(sizeof(node));

动态规划算法实验报告

实验标题 1、矩阵连乘 2、最长公共子序列 3、最大子段和 4、凸多边形最优三角剖分 5、流水作业调度 6、0-1背包问题 7、最优二叉搜索树 实验目的掌握动态规划法的基本思想和算法设计的基本步骤。 实验内容与源码1、矩阵连乘 #include #include using namespace std; const int size=4; //ra,ca和rb,cb分别表示矩阵A和B的行数和列数 void matriMultiply(int a[][4],int b[][4],int c[][4],int ra ,int ca,int rb ,int cb ) { if(ca!=rb) cerr<<"矩阵不可乘"; for(int i=0;i

相关文档
最新文档