单链c语言
‘壹’ c语言创建单链表问题
你的代码很有问题啊。在VS2013上面跑都不能跑。
你的意思是如果不读取到May就一直往下读取建立链表吧。
帮你修改了一下。应该可以了。
测试环境：DevC++
测试程序
#include<stdio.h>
#include<string.h>
#include"malloc.h"
#definelensizeof(link)
typedefstructlinklist
{chara[4];
structlinklist*next;
}link;
main()
{
link*head=(link*)malloc(len);
link*p,*q;
memset(head->a,' ',sizeof(char)*4);
head->next=NULL;
scanf("%s",head->a);
q=head;
while(strcmp(q->a,"May")!=0){
p=(link*)malloc(len);
q->next=p;
q=p;
scanf("%s",p->a);
}
p->next=NULL;
}
‘贰’ 单链表问题用C语言编写
用一组地址任意的存储单元存放线性表中的数据元素。
以元素(数据元素的映象)
+ 指针(指示后继元素存储位置)
= 结点
(表示数据元素 或 数据元素的映象)
以“结点的序列”表示线性表
�8�7�8�7 称作线性链表（单链表）
单链表是一种顺序存取的结构，为找第 i 个数据元素，必须先找到第 i-1 个数据元素。
因此，查找第 i 个数据元素的基本操作为：移动指针，比较 j 和 i
单链表
1、链接存储方法
链接方式存储的线性表简称为链表（Linked List）。
链表的具体存储表示为：
① 用一组任意的存储单元来存放线性表的结点（这组存储单元既可以是连续的，也可以是不连续的）
② 链表中结点的逻辑次序和物理次序不一定相同。为了能正确表示结点间的逻辑关系，在存储每个结点值的同时，还必须存储指示其后继结点的地址（或位置）信息（称为指针（pointer）或链(link)）
注意：
链式存储是最常用的存储方式之一，它不仅可用来表示线性表，而且可用来表示各种非线性的数据结构。
2、链表的结点结构
┌──┬──┐
│data│next│
└──┴──┘
data域--存放结点值的数据域
next域--存放结点的直接后继的地址（位置）的指针域（链域）
注意：
①链表通过每个结点的链域将线性表的n个结点按其逻辑顺序链接在一起的。
②每个结点只有一个链域的链表称为单链表（Single Linked List）。
【例】线性表（bat，cat，eat，fat，hat，jat，lat，mat）的单链表示如示意图
3、头指针head和终端结点指针域的表示
单链表中每个结点的存储地址是存放在其前趋结点next域中，而开始结点无前趋，故应设头指针head指向开始结点。
注意：
链表由头指针唯一确定，单链表可以用头指针的名字来命名。
【例】头指针名是head的链表可称为表head。
终端结点无后继，故终端结点的指针域为空，即NULL。
4、单链表的一般图示法
由于我们常常只注重结点间的逻辑顺序，不关心每个结点的实际位置，可以用箭头来表示链域中的指针，线性表（bat，cat，fat，hat，jat，lat，mat）的单链表就可以表示为下图形式。
5、单链表类型描述
typedef char DataType; //假设结点的数据域类型为字符
typedef struct node{ //结点类型定义
DataType data; //结点的数据域
struct node *next;//结点的指针域
}ListNode;
typedef ListNode *LinkList;
ListNode *p;
LinkList head;
注意：
①LinkList和ListNode *是不同名字的同一个指针类型（命名的不同是为了概念上更明确）
②LinkList类型的指针变量head表示它是单链表的头指针
③ListNode *类型的指针变量p表示它是指向某一结点的指针
6、指针变量和结点变量
┌────┬────────────┬─────────────┐
││指针变量│结点变量 │
├────┼────────────┼─────────────┤
│ 定义 │在变量说明部分显式定义 │在程序执行时，通过标准 │
│ │ │函数malloc生成 │
├────┼────────────┼─────────────┤
│ 取值 │ 非空时，存放某类型结点 │实际存放结点各域内容 │
│ │的地址 │ │
├────┼────────────┼─────────────┤
│操作方式│ 通过指针变量名访问 │ 通过指针生成、访问和释放 │
└────┴────────────┴─────────────┘
①生成结点变量的标准函数
p=( ListNode *)malloc(sizeof(ListNode))；
//函数malloc分配一个类型为ListNode的结点变量的空间,并将其首地址放入指针变量p中
②释放结点变量空间的标准函数
free(p)；//释放p所指的结点变量空间
③结点分量的访问
利用结点变量的名字*p访问结点分量
方法一：(*p).data和(*p).next
方法二：p-﹥data和p-﹥next
④指针变量p和结点变量*p的关系
指针变量p的值——结点地址
结点变量*p的值——结点内容
(*p).data的值——p指针所指结点的data域的值
(*p).next的值——*p后继结点的地址
*((*p).next)——*p后继结点
注意：
① 若指针变量p的值为空（NULL），则它不指向任何结点。此时，若通过*p来访问结点就意味着访问一个不存在的变量，从而引起程序的错误。
② 有关指针类型的意义和说明方式的详细解释
可见，在链表中插入结点只需要修改指针。但同时，若要在第 i 个结点之前插入元素，修改的是第 i-1 个结点的指针。
因此，在单链表中第 i 个结点之前进行插入的基本操作为:
找到线性表中第i-1个结点，然后修改其指向后继的指针。
#include<stdio.h>#include<stdlib.h>#define OK 1#define ERROR 0#define Status inttypedef int ElemType;/*此处利用#define或typedef 将ElemType先作定义*//*此处需补充定义链表的结构类型声明*/LinkList InitList(){LinkList head;</p><p>head=(LinkList)malloc(sizeof(LNode));</p><p>head->next=NULL;</p><p>return head;}void printlist(LinkList L) //这是一个输出表元的函数{LinkList p;</p><p>p=L->next;</p><p>while(p!=NULL)</p><p>{补充一条语句；</p><p>补充一条语句；}}void CreateListF(LinkList &L , int n ) // 单号的同学用头插法建表{ /* 补充N条语句，实现用值来建表 */ } void CreateListR(LinkList &L , int n ) // 双号的同学用尾插法建表{ /* 补充N条语句，实现用值来建表 */ } /*补充一个算法函数，查找表中值为X元素 */void main(){LinkList y;</p><p>int n;</p><p>printf("请输入N的值，它代表y中元素个数：");</p><p>scanf("%d",&n);</p><p>printf("\n");</p><p>/*此处调用上面的建表函数*/</p><p>printf("\n");</p><p>printf("这是链表y中的元素：");</p><p>/*此处调用上面的函数输出y表中的元素 */</p><p>printf("\n\n\n");</p><p></p><p>/*此处要补充语句，调用上面的查找表元素的函数*/</p><p></p><p>printf("\n\n\n");</p><p></p><p></p><p>}
‘叁’ 数据结构(C语言) 单链表的合并(100分)
#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
struct LNode
{
int data;
struct LNode *next;
};
typedef LNode* LinkList;
Linklist *unio(Linklist *p,Linklist *q) //合并
{
linklist *R,*pa,*qa,*ra;
pa=p;
qa=q;
R=ra=p;
while(pa->next!=NULL&&qa->next!=NULL)
{
if(pa->data>qa->data)
{
ra->next=qa;
qa=qa->next;
}
else
{
ra->next=pa;
pa=pa->next;
}
}
if(pa->next!=NULL)
ra->next=pa;
if(qa->next!=NULL)
ra->next==qa;
return R;
}
void CreateList_L(LinkList &L, int n)
{ // 算法2.11
// 逆位序输入（随机产生）n个元素的值，建立带表头结点的单链线性表L
LinkList p;
int i;
L = (LinkList)malloc(sizeof(LNode));
L->next = NULL; // 先建立一个带头结点的单链表
for (i=n; i>0; --i)
{
p = (LinkList)malloc(sizeof(LNode)); // 生成新结点
p->data = rand() % 200; // 改为一个随机生成的数字(200以内)
p->next = L->next;
L->next = p; // 插入到表头
}
} // CreateList_L
void main()
{
LinkList pHead; //定义两个链表
LinkList qHead;
int num;
printf("输入要创建的链表长度num\n");
scanf("d%",&num);
CreateList_L(pHead,num);
CreateList_L(qHead,num);
LinkList p=pHead->next;
LinkList q=qHead->next;
while(p!=NULL) //下面是输出两个链表
{
printf("%d\n",p->data);
p=p->next;
}
while(q!=NULL)
{
printf("%d\n",q->data);
q=q->next;
}
//上面创建完后，下面合并并输出
LinkList unioHead;
unioHead unio(&pHead,&qHead); //合并
LinkList myunio = unioHead ->next;
while(myunio!=NULL) //输出
{
printf("%d\n",myunio->data);
myunio=myunio->next;
}
}
‘肆’ 数据结构单链表实验(c语言版)
#include "stdio.h"
#include "string.h"
#include "ctype.h"
#include "stdlib.h"
#include "io.h"
#include "math.h"
#include "time.h"
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define MAXSIZE 20 /* 存储空间初始分配量 */
typedef int Status;/* Status是函数的类型,其值是函数结果状态代码，如OK等 */
typedef int ElemType;/* ElemType类型根据实际情况而定，这里假设为int */
Status visit(ElemType c)
{
printf("%d ",c);
return OK;
}
typedef struct Node
{
ElemType data;
struct Node *next;
}Node;
typedef struct Node *LinkList; /* 定义LinkList */
/* 初始化顺序线性表 */
Status InitList(LinkList *L)
{
*L=(LinkList)malloc(sizeof(Node)); /* 产生头结点,并使L指向此头结点 */
if(!(*L)) /* 存储分配失败 */
return ERROR;
(*L)->next=NULL; /* 指针域为空 */
return OK;
}
/* 初始条件：顺序线性表L已存在。操作结果：若L为空表，则返回TRUE，否则返回FALSE */
Status ListEmpty(LinkList L)
{
if(L->next)
return FALSE;
else
return TRUE;
}
/* 初始条件：顺序线性表L已存在。操作结果：将L重置为空表 */
Status ClearList(LinkList *L)
{
LinkList p,q;
p=(*L)->next; /* p指向第一个结点 */
while(p) /* 没到表尾 */
{
q=p->next;
free(p);
p=q;
}
(*L)->next=NULL; /* 头结点指针域为空 */
return OK;
}
/* 初始条件：顺序线性表L已存在。操作结果：返回L中数据元素个数 */
int ListLength(LinkList L)
{
int i=0;
LinkList p=L->next; /* p指向第一个结点 */
while(p)
{
i++;
p=p->next;
}
return i;
}
/* 初始条件：顺序线性表L已存在，1≤i≤ListLength(L) */
/* 操作结果：用e返回L中第i个数据元素的值 */
Status GetElem(LinkList L,int i,ElemType *e)
{
int j;
LinkList p; /* 声明一结点p */
p = L->next; /* 让p指向链表L的第一个结点 */
j = 1; /* j为计数器 */
while (p && j<i) /* p不为空或者计数器j还没有等于i时，循环继续 */
{
p = p->next; /* 让p指向下一个结点 */
++j;
}
if ( !p || j>i )
return ERROR; /* 第i个元素不存在 */
*e = p->data; /* 取第i个元素的数据 */
return OK;
}
/* 初始条件：顺序线性表L已存在 */
/* 操作结果：返回L中第1个与e满足关系的数据元素的位序。 */
/* 若这样的数据元素不存在，则返回值为0 */
int LocateElem(LinkList L,ElemType e)
{
int i=0;
LinkList p=L->next;
while(p)
{
i++;
if(p->data==e) /* 找到这样的数据元素 */
return i;
p=p->next;
}
return 0;
}
/* 初始条件：顺序线性表L已存在,1≤i≤ListLength(L)， */
/* 操作结果：在L中第i个位置之前插入新的数据元素e，L的长度加1 */
Status ListInsert(LinkList *L,int i,ElemType e)
{
int j;
LinkList p,s;
p = *L;
j = 1;
while (p && j < i) /* 寻找第i个结点 */
{
p = p->next;
++j;
}
if (!p || j > i)
return ERROR; /* 第i个元素不存在 */
s = (LinkList)malloc(sizeof(Node)); /* 生成新结点(C语言标准函数) */
s->data = e;
s->next = p->next; /* 将p的后继结点赋值给s的后继 */
p->next = s; /* 将s赋值给p的后继 */
return OK;
}
/* 初始条件：顺序线性表L已存在，1≤i≤ListLength(L) */
/* 操作结果：删除L的第i个数据元素，并用e返回其值，L的长度减1 */
Status ListDelete(LinkList *L,int i,ElemType *e)
{
int j;
LinkList p,q;
p = *L;
j = 1;
while (p->next && j < i) /* 遍历寻找第i个元素 */
{
p = p->next;
++j;
}
if (!(p->next) || j > i)
return ERROR; /* 第i个元素不存在 */
q = p->next;
p->next = q->next; /* 将q的后继赋值给p的后继 */
*e = q->data; /* 将q结点中的数据给e */
free(q); /* 让系统回收此结点，释放内存 */
return OK;
}
/* 初始条件：顺序线性表L已存在 */
/* 操作结果：依次对L的每个数据元素输出 */
Status ListTraverse(LinkList L)
{
LinkList p=L->next;
while(p)
{
visit(p->data);
p=p->next;
}
printf("\n");
return OK;
}
/* 随机产生n个元素的值，建立带表头结点的单链线性表L（头插法） */
void CreateListHead(LinkList *L, int n)
{
LinkList p;
int i;
srand(time(0)); /* 初始化随机数种子 */
*L = (LinkList)malloc(sizeof(Node));
(*L)->next = NULL; /* 先建立一个带头结点的单链表 */
for (i=0; i<n; i++)
{
p = (LinkList)malloc(sizeof(Node)); /* 生成新结点 */
p->data = rand()%100+1; /* 随机生成100以内的数字 */
p->next = (*L)->next;
(*L)->next = p; /* 插入到表头 */
}
}
/* 随机产生n个元素的值，建立带表头结点的单链线性表L（尾插法） */
void CreateListTail(LinkList *L, int n)
{
LinkList p,r;
int i;
srand(time(0)); /* 初始化随机数种子 */
*L = (LinkList)malloc(sizeof(Node)); /* L为整个线性表 */
r=*L; /* r为指向尾部的结点 */
for (i=0; i<n; i++)
{
p = (Node *)malloc(sizeof(Node)); /* 生成新结点 */
p->data = rand()%100+1; /* 随机生成100以内的数字 */
r->next=p; /* 将表尾终端结点的指针指向新结点 */
r = p; /* 将当前的新结点定义为表尾终端结点 */
}
r->next = NULL; /* 表示当前链表结束 */
}
int main()
{
LinkList L;
ElemType e;
Status i;
int j,k;
i=InitList(&L);
printf("初始化L后：ListLength(L)=%d\n",ListLength(L));
for(j=1;j<=5;j++)
i=ListInsert(&L,1,j);
printf("在L的表头依次插入1～5后：L.data=");
ListTraverse(L);
printf("ListLength(L)=%d \n",ListLength(L));
i=ListEmpty(L);
printf("L是否空：i=%d(1:是 0:否)\n",i);
i=ClearList(&L);
printf("清空L后：ListLength(L)=%d\n",ListLength(L));
i=ListEmpty(L);
printf("L是否空：i=%d(1:是 0:否)\n",i);
for(j=1;j<=10;j++)
ListInsert(&L,j,j);
printf("在L的表尾依次插入1～10后：L.data=");
ListTraverse(L);
printf("ListLength(L)=%d \n",ListLength(L));
ListInsert(&L,1,0);
printf("在L的表头插入0后：L.data=");
ListTraverse(L);
printf("ListLength(L)=%d \n",ListLength(L));
GetElem(L,5,&e);
printf("第5个元素的值为：%d\n",e);
for(j=3;j<=4;j++)
{
k=LocateElem(L,j);
if(k)
printf("第%d个元素的值为%d\n",k,j);
else
printf("没有值为%d的元素\n",j);
}
k=ListLength(L); /* k为表长 */
for(j=k+1;j>=k;j--)
{
i=ListDelete(&L,j,&e); /* 删除第j个数据 */
if(i==ERROR)
printf("删除第%d个数据失败\n",j);
else
printf("删除第%d个的元素值为：%d\n",j,e);
}
printf("依次输出L的元素：");
ListTraverse(L);
j=5;
ListDelete(&L,j,&e); /* 删除第5个数据 */
printf("删除第%d个的元素值为：%d\n",j,e);
printf("依次输出L的元素：");
ListTraverse(L);
i=ClearList(&L);
printf("\n清空L后：ListLength(L)=%d\n",ListLength(L));
CreateListHead(&L,20);
printf("整体创建L的元素(头插法)：");
ListTraverse(L);
i=ClearList(&L);
printf("\n删除L后：ListLength(L)=%d\n",ListLength(L));
CreateListTail(&L,20);
printf("整体创建L的元素(尾插法)：");
ListTraverse(L);
return 0;
}
‘伍’ 求大神帮忙。c语言，求单链表的长度。
typedef
struct
LNode
{
int
date;
struct
LNode
*next;
}
LNode,
*LinkList;
/*线性链表类型
*/
typedef
int
Status;
int
CreatLinkList_L(LinkList
&L)/*逆位序输入n个元素的值，建立带头节点的单链线性表L
*/
{
int
i,n;
printf("输入n的值");
scanf("%d",&n);
LinkList
p,
p2;
L=(LinkList)malloc(sizeof(LNode));
L->next=NULL;/*先建立一个带头节点的单链表*/
p2
=
L;
for(i=n;i>0;--i)
{
p
=
(LinkList)malloc(sizeof(LNode));
scanf("%d",&(p->date));
p->next
=
p2->next;
p2->next
=
p;
}
return
OK;
}
Status
ListLength_L(LinkList
L)
{
int
i=0;
LinkList
p
=
L;
p
=
p->next;
while(p!=NULL)
{
printf("%d\n",
p->date);
p
=
p->next;
i++;
}
return
i;
}
void
DeleteLinkList_L(LinkList
L)
{
LinkList
p
=
L->next;
while(p)
{
free(L);
L
=
p;
p
=
L->next;
}
}
void
main()
{
LinkList
L
=
NULL;
CreatLinkList_L(L);
printf("%d\n",
ListLength_L(L));
DeleteLinkList_L(L);//动态分配的内存应主动释放
}
‘陆’ 数据结构（C语言）用单链表存储一元多项式，并实现两个多项式的相加运算，怎么做
#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
typedef int ElemType;
/*单项链表的声明*/
typedef struct PolynNode{
int coef; // 系数
int expn; // 指数
struct PolynNode *next; }PolynNode,*PolynList;
/*正位序(插在表尾)输入n个元素的值,建立带表头结构的单链线性表*/
/*指数系数一对一对输入*/ void CreatePolyn(PolynList &L,int n)
{
int i;
下载
原文档已转码为如下格式，以便移动设备查看
数据结构(c语言)用单链表存储一元多项式,并实现两个多项式的相加运算【最新】
阅读：1037次 页数：36页 2016-03-21 举报
#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
typedef int ElemType;
/*单项链表的声明*/
typedef struct PolynNode{
int coef; // 系数
int expn; // 指数
struct PolynNode *next; }PolynNode,*PolynList;
/*正位序(插在表尾)输入n个元素的值,建立带表头结构的单链线性表*/
/*指数系数一对一对输入*/ void CreatePolyn(PolynList &L,int n)
{
int i;
PolynList p,q;
L=(PolynList)malloc(sizeof(PolynNode)); // 生成头结点
L->next=NULL;
q=L;
printf("成对输入%d个数据 ",n);
for(i=1;i<=n;i++)
{
p=(PolynList)malloc(sizeof(PolynNode));
scanf("%d%d",&p->coef,&p->expn); //指数和系数成对输入
q->next=p;
q=q->next;
}
p->next=NULL;
}
// 初始条件:单链表L已存在
// 操作结果: 依次对L的每个数据元素调用函数vi()。一旦vi()失败,则操作失败
void PolynTraverse(PolynList L,void(*vi)(ElemType, ElemType)) {
PolynList p=L->next;
while(p)
{
vi(p->coef, p->expn);
if(p->next)
{
printf(" + "); //“+”号的输出,最后一项后面没有“+”
}
p=p->next;
}
printf(" ");
}
/*ListTraverse()调用的函数(类型要一致)*/ void visit(ElemType c, ElemType e) {
if(c != 0)
{
printf("%dX^%d",c,e); //格式化输出多项式每一项
}
}
/* 多项式相加,原理:归并 */ /* 参数:两个已经存在的多项式 */ /* 返回值:归并后新的多项式的头结点 */
PolynList MergeList(PolynList La, PolynList Lb) {
PolynList pa, pb, pc, Lc;
pa = La->next;
pb = Lb->next;
Lc = pc = La; // 用La的头结点作为Lc的头结点
while(pa&&pb)
{
if(pa->expn < pb->expn)
{
pc->next = pa; //如果指数不相等,pc指针连上指数小的结
点,
pc = pa;
pa = pa->next; //指向该结点的指针后移
}
else if (pa ->expn > pb->expn )
{
pc->next = pb; //pc指针连上指数小的结点,
pc = pb;
pb = pb->next; //指向该结点的指针后移
}
else //(pa ->expn = pb->expn )
{
pa->coef = pa->coef + pb->coef; //指数相等时,系数相加
pc->next = pa;
pc = pa;
pa = pa->next; //两指针都往后移
pb = pb->next;
}
}
pc->next = pa ? pa:pb; // 插入剩余段
return Lc;
}
void main()
{
PolynList ha,hb,hc;
printf("非递减输入多项式ha, ");
CreatePolyn(ha,5); // 正位序输入n个元素的值
printf("非递减输入多项式hb, ");
CreatePolyn(hb,5); // 正位序输入n个元素的值
‘柒’ C语言的单链表问题，谢谢解答
单链表简介
链表中的数据是以结点来表示的，每个结点的构成:元素(数据元素的映象) + 指针(指示后继元素存储位置)，元素就是存储数据的存储单元，指针就是连接每个结点的地址数据。
单链表
以"结点的序列"表示线性表称作线性链表(单链表)
单链表是链式存取的结构，为找第 i 个数据元素，必须先找到第 i-1 个数据元素。
因此，查找第 i 个数据元素的基本操作为:移动指针，比较 j 和 i
单链表
1、链接存储方法
链接方式存储的线性表简称为链表(Linked List)。
链表的具体存储表示为:
① 用一组任意的存储单元来存放线性表的结点(这组存储单元既可以是连续的，也可以是不连续的)
② 链表中结点的逻辑次序和物理次序不一定相同。为了能正确表示结点间的逻辑关系，在存储每个结点值的同时，还必须存储指示其后继结点的地址(或位置)信息(称为指针(pointer)或链(link))
注意:
链式存储是最常用的存储方式之一，它不仅可用来表示线性表，而且可用来表示各种非线性的数据结构。
2、链表的结点结构
┌───┬───┐
│data │next │
└───┴───┘
data域--存放结点值的数据域
next域--存放结点的直接后继的地址(位置)的指针域(链域)
注意:
①链表通过每个结点的链域将线性表的n个结点按其逻辑顺序链接在一起的。
②每个结点只有一个链域的链表称为单链表(Single Linked List)。
【例】线性表(bat，cat，eat，fat，hat，jat，lat，mat)的单链表示如示意图
3、头指针head和终端结点指针域的表示
单链表中每个结点的存储地址是存放在其前趋结点next域中，而开始结点无前趋，故应设头指针head指向开始结点。
注意:
链表由头指针唯一确定，单链表可以用头指针的名字来命名。
终端结点无后继，故终端结点的指针域为空，即NULL。
4、单链表的一般图示法
由于我们常常只注重结点间的逻辑顺序，不关心每个结点的实际位置，可以用箭头来表示链域中的指针，线性表(bat，cat，fat，hat，jat，lat，mat)的单链表就可以表示为下图形式。
5、单链表类型描述
typedef char DataType; //假设结点的数据域类型为字符
typedef struct node{ //结点类型定义
DataType data; //结点的数据域
struct node *next;//结点的指针域
}ListNode;
typedef ListNode *LinkList;
ListNode *p;
LinkList head;
注意:
①LinkList和ListNode是不同名字的同一个指针类型(命名的不同是为了概念上更明确)
②*LinkList类型的指针变量head表示它是单链表的头指针
③ListNode类型的指针变量p表示它是指向某一结点的指针
6、指针变量和结点变量
指针变量
结点变量
定义
在变量说明部分显式定义
在程序执行时，通过标准函数malloc生成
取值
非空时，存放某类型结点
实际存放结点各域内容的地址
①生成结点变量的标准函数
p=( ListNode *)malloc(sizeof(ListNode));
//函数malloc分配一个类型为ListNode的结点变量的空间,并将其首地址放入指针变量p中
②释放结点变量空间的标准函数
free(p);//释放p所指的结点变量空间
③结点分量的访问
利用结点变量的名字*p访问结点分量
方法一:(*p).data和(*p).next
方法二:p->data和p->next
④指针变量p和结点变量*p的关系
指针变量p的值--结点地址
结点变量*p的值--结点内容
(*p).data的值--p指针所指结点的data域的值
(*p).next的值--*p后继结点的地址
*((*p).next)--*p后继结点
注意:
① 若指针变量p的值为空(NULL)，则它不指向任何结点。此时，若通过*p来访问结点就意味着访问一个不存在的变量，从而引起程序的错误。
② 有关指针类型的意义和说明方式的详细解释
可见，在链表中插入结点只需要修改指针。但同时，若要在第 i 个结点之前插入元素，修改的是第 i-1 个结点的指针。
因此，在单链表中第 i 个结点之前进行插入的基本操作为:
找到线性表中第i-1个结点，然后修改其指向后继的指针。
‘捌’ 用C语言编写建立一个从表尾到表头逆向单链线性表且进行插入 删除的程序
#include<iostream>
using
namespace
std;
struct
Linklist
{
int
data;
Linklist
*next;
};
Linklist
*L,*rear;
void
create()//尾插法建立链表
{
Linklist
*p;
int
x;
cout<<"输入链表元素(按升序顺序输入)："
while(cin>>x&&x!=0)
{
if(L==NULL)
{
L=new
Linklist;
L->data=x;
rear=L;
L->next=NULL;
}
else
{
p=new
Linklist;
p->data=x;
rear->next=p;
p->next=NULL;
rear=p;
}
}
rear->next=NULL;
}
void
del(int
x)//删除data域值为x的结点
{
Linklist
*p,*k,*t;
k=p=L;
while(p!=NULL)
{
if(p->data==x)
break;
k=p;
p=p->next;
}
if(p==L)
{
p=L;
L=L->next;
delete
p;
}
else
if(p==rear)
{
k->next=NULL;
delete
p;
}
else
if(p==NULL)
{
cout<<"没有值为"<<x<<"的结点
"<<endl;
}
else
{
k->next=p->next;
delete
p;
}
}
void
insert(int
x)//插入data域值为x的结点(默认原链表为升序排列)
{
Linklist
*s,*p,*k;
s=new
Linklist;
s->data=x;
s->next=NULL;
k=p=L;
while(p!=NULL)
{
if(p->data>=x)
break;
k=p;
p=p->next;
}
if(p==L)
{
L=s;
s->next=p;
}
else
if(p==NULL)
{
k->next=s;
}
else
{
k->next=s;
s->next=p;
}
}
void
output()//将链表输出
{
Linklist
*p;
p=L;
cout<<"链表中的元素为：";
while(p!=NULL)
{
cout<<p->data<<"
";
p=p->next;
}
cout<<endl<<endl;
}
void
LinkListDemo()
{
//
L是无头结点的单链表
Linklist
*q,
*p,*t;//p指针用于指示原链表最后的结点（即an），q指针用于指示原来的头结点（即a1）
q=L;
if
(
q
&&
q->next
)
{
t=q;//将q指针指向a1
L=L->next;//将L指针指向新链表的头结点（即a2）
rear->next=q;
q->next=NULL;
t=NULL;
}
}
void
main()
{
create();
output();
int
x;
cout<<"输入需要插入的元素：";
cin>>x;
insert(x);
output();
cout<<"输入需要删除的元素：";
cin>>x;
del(x);
output();
LinkListDemo();
output();
}
‘玖’ c语言单链 之和
＃include<stdio.h>
＃include<malloc.h>
＃include<stdlib.h>
#define LEN sizeof(node)
typedef struct polynode /*用单链表存储多项式的结点结构*/
{
int coef; /*多项式的系数*/
int exp; /*指数*/
struct polynode *next; /*next是struct polynode类型中的一个成员，它又指向
struct polynode类型的数据，以此建立链表*/
}node;/*若定为"node,*list;"，意即node*与list同为结构指针类型*/
node * create(void) /*指针函数，返回指针类型；用尾插法建立一元多项式的链表的函数*/
{
node *h,*r,*s;
int c,e;
h=(node *)malloc(LEN); /*建立多项式的头结点，为头结点分配存储空间*/
r=h; /*r指针始终动态指向链表的当前表尾，以便于做尾插入，其初值指向头结点*/
printf("coef:");
scanf("%d",&c); /*输入系数*/
printf("exp: ");
scanf("%d",&e); /*输入指针*/
while(c!=0) /*输入系数为0时，表示多项式的输入结束*/
{
s=(node *)malloc(LEN); /*申请新结点*/
s->coef=c; /*申请新结点后赋值*/
s->exp=e; /*申请新结点后赋值*/
r->next=s; /*做尾插，插入新结点*/
r=s; /*r始终指向单链表的表尾*/
printf("coef:");
scanf("%d",&c);
printf("exp: ");
scanf("%d",&e);
}
r->next=NULL; /*将表的最后一个结点的next置NULL，以示表结束*/
return(h);
}
void polyadd(node *polya, node *polyb)/*一元多项式相加函数，用于将两个多项式相加，然后将和多项式存放在多项式polya中，并将多项式ployb删除*/
{
node *p,*q,*pre,*temp;
int sum;
p=polya->next;/*令p和q分别指向polya和polyb多项式链表中的第一个结点*/
q=polyb->next;
pre=polya; /*位置指针，指向和多项式polya*/
while(p!=NULL&&q!=NULL) /*当两个多项式均未扫描结束时，执行以下操作*/
{
if(p->exp<q->exp) /*若p指向的多项式指数小于q指的指数*/
{
pre->next=p; /*将p结点加入到和多项式中*/
pre=pre->next;
p=p->next;
}
else if(p->exp==q->exp) /*若指数相等，则相应的系数相加*/
{
sum=p->coef+q->coef;
if(sum!=0)
{
p->coef=sum;
pre->next=p;pre=pre->next;p=p->next;
temp=q;q=q->next;free(temp);
}
else /*如果系数和为零，则删除结点p与q，并将指针指向下一个结点*/
{
temp=p->next;free(p);p=temp;
temp=q->next;free(q);q=temp;
}
}
else /*若p指数大于q指数*/
{
pre->next=q; /*p结点不动，将q结点加入到和多项式中*/
pre=pre->next;
q=q->next;
}
}
if(p!=NULL) /*多项式A中还有剩余，则将剩余的结点加入到和多项式中*/
pre->next=p;
else /*否则将B的结点加入到和多项式中*/
pre->next=q;
}
void print(node * p) /*输出函数，打印出一元多项式*/
{
while(p->next!=NULL)
{
p=p->next;
printf(" %d*x^%d",p->coef,p->exp);
}
}
main() /*主函数*/
{
node * polya,* polyb;
printf("Welcome to use!\n");
printf("\nPlease input the ploya include coef && exp:\n");
polya=create(); /*调用建立链表函数，创建多项式A*/
print(polya);
printf("\nPlease input the ployb include coef && exp:\n");
polyb=create(); /*同理，创建B*/
print(polyb);
printf("\nSum of the poly is:\n");
polyadd(polya,polyb); /*调用一元多项式相加函数*/
print(polya); /*调用输出函数，打印结果*/
printf("\n");