#include"stdlib.h"
typedef struct LNode {
intdata // 数据域
struct LNode *next // 指针域
} LNode, *LinkList
void creatlist(LinkList L)
{
LinkList s,p=Lint x //初始化，p指向表头结点
for(int i=1i<=3i++)//建立三个结点
{
cin>>x //输出数据
s=(LinkList)malloc(sizeof(LNode)) //申请结点空间，地址赋给s
s->data=x //赋值
s->next=NULL //新结点无后继结点
p->next=s //把新结点链到原表尾
p=p->next //p指向表尾
}
}
void outlist(LinkList L){//输出链表
LinkList p=L->next //p指向第一个数据结点
while(p){//当表未空时循环
cout<<p->data //输出一个数据
p=p->next //p后移一个结点
}
}
void main()
{
LinkList L //定义L的类型
L=(LinkList)malloc(sizeof(LNode)) //为L申请一个结点（表头结点）
L->next=NULL //L此时无后继
creatlist(L) //建立链表
outlist(L) //输出链表
}
1.3.1 基本数据结构与算法1．算法的基本概念及特征
算法的概念是考试的重点，是指解题方案的准确而完整的描述，它由两种基本要素组成：一是对数据对象的运算和 *** 作，二是算法的控制结构。
算法具有可行性、确定性、有穷性、拥有足够的情报等特征。其中，确定性和有穷性是考试的重点。
算法的确定性，是指算法中的每一步骤都必须有明确定义，不允许有模棱两可的解释，也不允许有多义性。
算法的有穷性，是指算法必须能在有限的时间内做完，即算法必须能在执行有限个步骤之后终止。
2．算法复杂度的概念和意义
一个算法质量的好坏可从算法的时间复杂度和空间复杂度两个方面来衡量。算法的复杂度也是每次考试的重点，要注意明确有关概念。
算法的时间复杂度是指算法所需要的计算工作量；算法的空间复杂度是指执行这个算法所需要的内存空间。
3．数据结构的定义
数据结构主要研究和讨论以下三个方面的问题：
① 数据集合中各元素之间所固有的逻辑关系，即数据的逻辑结构。
② 在对数据进行处理时，各数据元素在计算机中的存储关系，即数据的存储结构。
③ 对各种数据结构进行的运算。
要注意数据的逻辑结构与存储结构的区别与联系。
4．线性结构与非线性结构
根据数据结构中各元素之间前后件关系的复杂程度，一般数据结构分为两大类型：线性结构与非线性结构。要注意这两种结构的特征、它们之间的区别以及常见的有关结构。
（1）线性结构（或称线性表）有以下主要特征：
① 有且只有一个根结点，它无前件。
② 有且只有一个终结点，它无后件。
③ 除根结点与终端结点外，其他所有结点有且只有一个前件，也有且只有一个后件。线性表中结点的个数称为线性表的长度，当结点个数为0时，该线性表为空表。
常见的线性结构有：线性表、栈、队列等。
（2）如果一个数据结构不是线性结构，则称之为非线性结构，常见的非线性结构有：树、二叉树、图等。
5．线性表的顺序存储结构（顺序表）及其插入与删除运算
线性表既可以采用顺序存储结构，又可以采用链式存储结构进行存储。要注意掌握二者在存储数据方面的方式与特点。
（1）线性表的顺序存储结构的特点
① 线性表中所有元素所占的存储空间是连续的。
② 线性表中各数据元素在存储空间中是按逻辑顺序依次存放的。
由此可见，在线性表的顺序存储结构中，其前后件两个元素在存储空间中是紧邻的，且前件元素一定存储在后件元素的前面。
（2）线性表在顺序存储结构下的插入与删除运算
线性表在顺序存储结构下，若在第i（1in，n为线性表中元素的个数）个位置上插入一个新元素，则首先从最后一个（即第n个）元素开始，直到第i个元素之间共有n–i+1个元素依次向后移动一个位置，移动结束后，第i个位置就被空出，然后将新元素插入到第i个位置。插入结束后，线性表的长度增1。
显然，在最好的情况下，插入位置在线性表的末尾进行，即在第n个元素之后插入运算，此时，不需要移动表中的元素。而在最坏的情况下，插入位置在第1个元素上，此时需要移动表中所有的元素。在平均情况下，要在线性表中插入一个新元素，需要移动表中一半的元素。
同理，线性表在顺序存储结构下的删除运算，也需要移动表中的元素，只不过是向前移动，在最好的情况下，删除运算在线性表的末尾进行，即删除第n个元素，此时，不需要移动表中的元素。而在最坏的情况下，删除位置在第1个元素上，此时需要移动表中所有的元素。在平均情况下，要在线性表中删除一个元素，需要移动表中一半的元素。
线性表的顺序存储结构的特点，以及在顺序存储结构下插入与删除运算的效率是考试的重点。
6．栈与队列
要深刻领会二者的概念，以及对二者进行插入、删除运算的特点，这是考试的重点。
栈实际上也是线性表，只不过是一种特殊的线性表。在这种特殊的线性表中，其插入与删除运算都只在线性表的一端进行。即在这种线性表的结构中，一端是封闭的，不允许进行插入与删除元素；另一端是开口的，允许插入与删除元素。允许插入与删除运算的一端称为栈顶，而不允许插入与删除运算的一端称为栈底。栈顶元素总是最后被插入的元素，从而也是最先能被删除的元素；栈底元素总是最先被插入的元素，从而也是最后才能被删除的元素。即栈是按照“先进后出”（First In Last Out，FILO）或“后进先出”（Last In First Out，LIFO）的原则组织数据的，因此，栈也被称为“先进后出”表或“后进先出”表。由此可以看出，栈具有记忆作用。对栈常可以进行进栈、出栈、读取栈顶元素的运算。
队列是指允许在一端进行插入运算、而在另一端进行删除运算的线性表。允许插入运算的一端称为队尾，通常用一个称为队尾指针的指针指向队尾元素，即队尾指针总是指向最后被插入的元素。允许删除运算的一端称为队头，通常也用一个队头指针指向队头的元素。显然，在队列这种数据结构中，最先插入的元素将最先能够被删除，反之，最后插入的元素将最后才能被删除。因此，队列又称为“先进先出”（First In First Out，FIFO）或“后进后出”（Last In Last Out，LILO）的线性表。对队列可以进行入队、退队运算。
7．循环队列
重点注意循环队列的概念、存储方式。
循环队列是队列顺序存储结构的一种，它将m个物理上连续的存储单元，在逻辑上形成一个环状，供队列循环使用。
具体来说，在循环队列中，用队尾指针rear指向队列中的队尾元素，用队头指针front指向队头元素的前一个位置，因此，从队头指针front指向的后一个位置直到队尾指针rear指向的位置之间所有的元素均为队列中的元素。
8．线性表的链式存储结构（线性链表）
（1）线性表的链式存储结构及其有关运算
在线性表的链式存储结构中，一个元素用一个结点来存储，每个结点含有两个域，一个数据域用于存放数据元素值，一个指针域，用于存放指针，该指针用于指向该结点的前一个或后一个结点（即前件或后件）。
在链式存储结构中，存储数据结构的存储空间可以不连续，各数据结点的存储顺序（即存储空间位置）与数据元素之间的逻辑关系可以不一致，而数据元素之间的逻辑关系是由指针域来确定的。要特别注意，线性表的链式存储结构与顺序存储结构方式的不同。
线性表的链式存储结构又称为线性链表。
对线性链表的运算主要包括：查找指定元素、插入、删除运算等。不像顺序存储结构那样，对线性链表的插入与删除运算不需要移动数据元素，而只需改变有关结点的指针即可。
（2）循环链表
在对线性链表进行运算的过程中，虽然其插入与删除运算比较方便，但还存在一个问题，即对于空表和对第一个结点的处理必须单独考虑，使空表与非空表的运算不统一。为了克服线性链表的这个缺点，可以采用另一种链接方式，即循环链表的结构，使整个链成为一个环状结构。在此，需要注意线性链表与循环链表在存储方式上的不同。
循环链表的结构与线性链表相比，具有以下两个特点：
① 在循环链表中增加了一个表头结点，其数据域为任意或者根据需要来设置，指针域指向线性表的第一个元素的结点。循环链表的头指针指向表头结点。
② 循环链表中最后一个结点的指针域不是空，而是指向表头结点。即在循环链表中，所有结点的指针构成了一个环状链。
9．树与二叉树
树是一种非线性结构，在这种结构中，所有数据元素之间的关系具有明显的层次特性。而二叉树也是一种非线性结构，它与树结构相似，并且树结构的所有术语都可以用到二叉树这种数据结构上。
二叉树具有以下两个特点：
① 非空二叉树只有一个根结点。
② 每一个结点最多有两棵子树，且分别称为该结点的左子树与右子树。
因此，二叉树中每一个结点的度最大为2，即所有子树（左子树或右子树）也均为二叉树。
对于二叉树，其概念与性质是考试的重点。要特别注意二叉树的有关性质。
10．满二叉树与完全二叉树
满二叉树与完全二叉树是两种特殊形态的二叉树，对这两种二叉树的概念上的理解是考试的重点。
（1）满二叉树
满二叉树是指这样的一种二叉树：除最后一层外，每一层上的所有结点都有两个子结点，也就是说，在满二叉树中，每一层上的结点数都达到最大值，即在满二叉树的第k层有2k–1个结点，且深度为m的满二叉树有2m–1个结点。
（2）完全二叉树
完全二叉树是这样的二叉树，除最后一层外，每一层上的结点数均达到最大值。
11．二叉树的遍历
二叉树的遍历是指不重复地访问二叉树中的所有结点。二叉树的遍历可以分为三种：前序遍历、中序遍历、后序遍历。这三种遍历方式是每次考试的重点，要求对于某一棵二叉树应能写出对应的遍历序列。
12．顺序查找及其特点
需要重点掌握顺序查找的概念及查找的效率。
顺序查找又称顺序搜索。它从线性表的第一个元素开始，依次将线性表中的元素与被查元素进行比较，若相等则表示找到（即查找成功）；若线性表中所有的元素都与被查元素进行了比较但都不相等，则表示线性表中没有要找的元素（即查找失败）。
很明显，在进行顺序查找过程中，在最好的情况下，如果线性表中的第一个元素就是被查元素，则只需做一次比较就查找成功，查找效率最高；但如果被查的元素是线性表中的最后一个元素，或者被查元素根本不在线性表中，则为了查找这个元素需要与线性表中所有的元素进行比较，这是顺序查找的最坏情况。在平均情况下，利用顺序查找法在线性表中查找一个元素，大约与线性表中一半的元素进行比较。
13．二分法查找及其特点
重点掌握二分法查找的适用对象、查找的方法与查找效率。
二分法查找只适用于顺序存储的有序表。此处的有序表是指线性表中的元素按值非递减排列（即从小到大，但允许相信元素值相等）。
设有序线性表的长度为n，被查元素为x，则二分查找的方法如下所述。
将x与线性表的中间项进行比较：
若中间项的值等于x，则说明查到，查找结束；
若x小于中间项的值，则在线性表的前半部分（即中间项以前的部分）以相同的方法进行查找；
若x大于中间项的值，则在线性表的后半部分（即中间项以后的部分）以相同的方法进行查找。
这个过程一直进行到查找成功或子表长度为0（说明线性没有这个元素）为止。
显然，当有序线性表为顺序存储时才能采用二分查找，并且，二分查找的效率要比顺序查找高得多。对于长度为n的有序线性表，在最坏情况下，二分查找只需要比较log2n次。
14．排序技术
排序是指将一个无序序列整理成按值非递减顺序排列的有序序列。常见的排序方法主要有交换类排序、插入类排序和选择类排序。各种排序方法的特点以及在最坏情况下的排序效率是考试的重点。
（1）交换类排序法
交换类排序法是指借助数据元素之间的互相交换进行排序的一种方法。冒泡排序法与快速排序法都属于交换类排序方法。
冒泡排序法是一种最简单的交换类排序方法，它是通过相邻数据元素的交换逐步将线性表变成有序。假设线性表的长度为n，则在最坏情况下，冒泡排序需要经过n/2遍的从前往后的扫描和n/2遍的从后往前的扫描，需要的比较次数为n(n–1)/2。但这个工作量不是必需的，一般情况下要小于这个工作量。
快速排序法也是一种交换类的排序方法，但由于它比冒泡排序法的速度快，因此称之为快速排序法。其关键是对线性表进行分割，以及对各分割出的子表再进行分割。
（2）插入类排序法
插入类排序法主要有简单插入排序法和希尔排序法。
简单插入排序法，是指将无序序列中的各元素依次插入到已经有序的线性表中。在这种排序方法中，每一次比较后最多移掉一个逆序，因此，这种排序方法的效率与冒泡排序法相同。在最坏情况下，简单插入排序需要n(n–1)/2次比较。
希尔排序法对简单插入排序做了较大的改进。它是将整个无序序列分割成若干小的子序列分别进行插入排序。希尔排序的效率与所选取的增量序列有关。在最坏情况下，希尔排序所需要的比较次数为O(n1.5)。
（3）选择类排序
选择类排序主要有简单选择类排序法和堆排序法。
简单选择排序法的基本思想是：扫描整个线性表，从中选出最小的元素，将它交换到表的最前面（这是它应有的位置）；然后对剩下的子表采用同样的方法，直到子表空为止。对于长度为n的线性表，在最坏情况下需要比较n(n–1)/2次。
堆排序法也属于选择类排序法。具有n个元素的序列（h1, h2, …, hn），当且仅当满足条件：
或
(i=1, 2, …, n/2）时称之为堆。可见，堆顶元素（即第一个元素）必为最大项。
堆排序的方法对于规模较小的线性表并不适合，但对于较大规模的线性表来说是很有效的。在最坏情况下，堆排序需要比较的次数为O(nlog2n)。
1.3.2 程序设计基础
1．程序设计方法与风格
除了好的程序设计方法和技术外，程序设计风格也是很重要的内容。程序设计风格是指编写程序时所表现出的特点、习惯和逻辑思路。要形成良好的程序设计风格，主要应注重和考虑下述一些因素。
（1）源程序文档化
符号名的命名：符号名的命名应具有一定的实际含义，以便于对程序功能的理解。
程序注释：注释一般分为序言性注释和功能性注释。序言性注释通常位于每个程序的开头部分，它给出程序的整体说明；而功能性注释的位置一般嵌在源程序体中，主要描述其后的语句或程序做什么。
视觉组织：可以在程序中利用空格、空行、缩进等技巧使程序层次清晰。
（2）数据说明的方法
主要包括数据说明的次序规范化、说明语句中变量安排有序化和使用注释来说明复杂数据结构等。
（3）语句的结构
语句构造应该简单直接，不应该为提高效率而把语句复杂化。
（4）输入和输出
输入和输出方式和格式应尽可能方便用户的使用。
2．结构化程序设计
结构化程序设计的主要原则、设计要素应是重点掌握的内容。
由于软件危机的出现，人们开始研究程序设计方法，其中最受关注的是结构化程序设计方法。结构化程序设计方法的主要原则可以概括为自顶向下、逐步求精、模块化、限制使用goto语句。
在结构化程序设计的具体实施中，要注意把握如下要素。
（1）使用程序设计语言中的顺序、选择、循环等有限的控制结构表示程序的控制逻辑。
（2）使用的控制结构只准许有一个入口和一个出口。
（3）程序语句组成容易识别的块，每块只有一个入口和一个出口。
（4）复杂结构应该用嵌套的基本控制结构进行组合嵌套来实现。
（5）语言中所没有的控制结构，应该采用前后一致的方法来模拟。
（6）严格控制goto语句的使用。
3．面向对象的程序设计及其重要概念
面向对象的程序设计方法及其有关概念是重点掌握的内容，也是考试的重点。
面向对象的程序方法主张从客观世界固有的事物出发来构造系统，提倡用人类在现实生活中常用的思维方法来认识、理解和描述客观事物，强调最终建立的系统能够映射问题域。它具有与人类习惯的思维方法一致、稳定性好、可重用性好、易于开发大型软件产品、可维护性好等优点。
在面向对象的程序方法中，有如下重要的概念。
（1）对象
用来表示客观世界中的任何实体，即应用领域中有意义的、与所要解决的问题有关系的任何事物都可以作为对象。它既可以是具体的物理实体的抽象，也可以是人为的概念，或者是任何有明确边界和意义的东西。面向对象的程序设计方法中涉及的对象是系统中用来描述客观事物的一个实体，是构成系统的一个基本单位，它由一组表示其静态特征的属性和它可执行的一组 *** 作组成。
属性即对象所包含的信息，它在设计对象时确定，一般只能通过执行对象的 *** 作来改变。
*** 作描述了对象执行的功能，若通过消息传递，还可以为其他对象使用。
（2）类和实例
将属性、 *** 作相似的对象归为类，即是具有共同属性、共同方法的对象的集合。因此，类是对象的抽象，它描述了属于该对象类型的所有对象的性质，而一个对象则是其对应类的一个实例。
（3）消息
面向对象的世界是通过对象与对象间彼此的相互合作来推动的，对象间的这种相互合作需要一个机制协助进行，这样的机制称为“消息”。消息是一个实例与另一个实例之间传递的信息，它请示对象执行某一处理或回答某一要求的信息，它统一了数据流和控制流。一个消息由接收消息的对象的名称、消息标识符（即消息名）、零个或多个参数组成。
（4）继承
继承是面向对象的方法的一个主要特征。继承是使用已有的类定义作为基础建立新类的定义技术。已有的类可当做基类来引用，则新类相应地可当做派生类来引用。一个类的上层可以有父类，下层可以有子类。一个类直接继承其父类的描述（数据和 *** 作）或特性，子类自动地共享基类中定义的数据和方法。
（5）多态性
对象根据所接受的消息而做出动作，同样的消息被不同的对象接受时可导致完全不同的行动，该现象称为多态性。
#include "stdio.h"typedef struct node
{ int c,e //节点的数据域，c是多项式的系数，e是多项式的指数
struct node *next //节点的指针域
}PN//自定义节点结构体，类型PN
PN *createPoly() //这个函数用来建立链表，返回值是一个节点指针
{ int n, e, c
PN *head, *p //定义头结点指针head，和节点指针p
printf("请输入多项式项数:")
scanf("%d", &n) //得到n的值，既项数
head=p=new PN // * malloc(sizeof(PN))//让head,p都指向头结点（头结点不用来存放数据）
p->next=NULL //到这里为止，一个空链表建立完成
while( n-- )//循环n次
{
p->next=new PN// * malloc(sizeof(PN))//动态分配新的节点，并接在链表末尾（尾插法）
p=p->next
// printf("c e:") //给新的节点，添加数据
scanf("%d%d" , &p->c, &p->e)
}
p->next=NULL //将表尾的指针域置为空
return head //返回头结点地址
}
void printPoly( PN *head) //这个函数用来输入链表信息
{ PN *p=head->next //节点指针p用来遍历链表,p先指向表头
while(p)//当p=NULL时（已经到表尾），结束循环
{ printf(" (%d,%d) ", p->c, p->e)//显示当前节点的数据
p=p->next //将p指向移到下一个节点
}
printf("\n") //输出一个回车
}
void freePoly( PN *head) //这个函数用来销毁链表
{ PN *p //用来释放节点（动态内存块）
while( head )//当head=NULL时（已经到表尾），结束循环
{ p=head //让p指向head所指的节点
head=head->next //将head指向移到下一个节点
delete(p) //释放p所指的节点（动态内存块）
}
}
PN *polyAdd(PN *ha, PN *hb) //这个函数用来将两个多项式相加
{ int c, e //c是多项式的系数，e是多项式的指数
PN *pa=ha->next, *pb=hb->next, //pa,pb用来遍历通过参数传进来的两个链表（参数是两个链表的头结点指针），暂且称它们为链表a,b
*hc, *pc //hc是两个链表对应节点相加后的新链表的头结点，pc用来遍历新链表,此链表称它为c
hc=pc=new PN
while( pa || pb ) //当两个链表都遍历完毕，则循环停止
{
if( pa &&(pb==NULL || pa->e <pb->e)) //取指数较小的一项链入链表或者链表b已经遍历完毕时，执行该if中的内容
{ c=pa->c
e=pa->e
pa=pa->next
}
else if( pb &&(pa==NULL || pa->e >pb->e)) //取指数较小的一项链入链表或者链表a已经遍历完毕时，执行该if中的内容
{ c=pb->c
e=pb->e
pb=pb->next
}
else //指数相等的时候，执行
{ c=pa->c+pb->c
e=pa->e
pa=pa->next
pb=pb->next
}
if( c ) //将两个链表相加后的每个项 都放入新链表中
{
pc->next=new PN
pc=pc->next
pc->c=c
pc->e=e
}
}
pc->next=NULL
return hc //将新链表的头结点指针返回
}
PN *mulxmul(PN *ha, PN *hb) //这个函数将a表中每个项都掉用一次onexmul函数，最终实现多项式a与b的相乘
{ PN *t, *hc, *pa=ha->next
PN *onexmul( PN *pa , PN *hb)//函数声明，因为接下来就要用到它
PN *polyAdd(PN *ha, PN *hb) //函数声明，因为接下来就要用到它
t=new PNt->next=NULL//存放最终结果的链表，t是表头,此表暂称为t表
while( pa ) //遍历a链表
{ hc=onexmul( pa, hb )//将a表中pa所指的项与b表中所有的项相乘（即多项式a中的某一项与多项式b相乘）
t=polyAdd( t, hc ) //将每次相乘的结果相加
freePoly( hc ) //将调用onexmul函数产生的中间链表销毁，因为该链表的项，已经放到t链表中
pa=pa->next
}
return t //将t表的头结点指针返回
}
PN *onexmul ( PN *pa, PN *hb ) //这个函数用来将a表中pa所指的项与b表中所有的项相乘（即多项式a中的某一项与多项式b相乘）
{ PN *hc, *pc, *pb=hb->next//hc是新链表的头结点，pc用来遍历新链表
hc=pc=new PN //让hc,pc都指向头结点
while( pb ) //遍历b链表
{ pc->next=new PN //建立新链表的节点
pc=pc->next
pc->c=pa->c * pb->c //给新节点赋值，系数等于系数相乘
pc->e=pa->e + pb->e //指数等于指数相加
pb=pb->next
}
pc->next=NULL
return hc //将新链表的头结点指针返回
}
int main()
{ PN *ha, *hb, *hc
freopen("poly.in" , "r" , stdin)//只读模式打开poly.in
freopen("poly.txt", "w", stdout)//只写模式打开poly.txt
ha=createPoly() //建立新链表，ha为头结点指针(多项式a)
printPoly(ha) //输出ha为头结点指针的链表信息
hb=createPoly() //建立新链表，hb为头结点指针(多项式b)
printPoly(hb) //输出hb为头结点指针的链表信息
hc=polyAdd(ha, hb) //多项式a与多项式b相加，结果放在hc为头结点指针的链表中
printPoly(hc) //输出相加后的链表信息
freePoly(hc) //销毁该链表
hc=mulxmul(ha,hb) //多项式a与多项式b相乘，结果放在hc为头结点指针的链表中
printPoly(hc) //输出相乘后的链表信息
freePoly(ha) //销毁该链表
freePoly(hb) //销毁该链表
freePoly(hc) //销毁该链表
return 0
}
OK,花了不少时间帮你写了下注释，应该比较完整了吧，原理和数学模型完全一样的，应该能看懂，流程图，相信看懂了程序，画起来不难，自己尝试下吧。
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）