尾插法建立单链表

尾插法建立单链表
尾插法建立单链表

#include

#include

typedefstruct node

{

int number;

float score;

struct node *next;

}lnode,*linklist;

/*定义头结点函数*/

linklistInitlist();

/*定义尾插法函数*/

voidCreatelist(linklist,int);

/*定义打印函数*/

voidPrintlist(linklist);

/*主函数*/

int main(void)

{

int n;

linklist l;

l=Initlist();

printf("请输入数据总量:\n");

scanf("%d",&n);

Createlist(l,n);

printf("结果是:\n");

Printlist(l);

return 0;

}

linklistInitlist()

{

linklist l;

l=(linklist)malloc(sizeof(lnode));

l->next=0;

return l;

}

voidCreatelist(linklistl,int n)

{

int i;

linklistp,t;

t=l;

for(i=0;i

{

p=(linklist)malloc(sizeof(lnode));

printf("Please input data:\n");

scanf("%d%f",&p->number,&p->score);

p->next=0;

t->next=p;

t=p;

}

}

voidPrintlist(linklist l)

{

linklist p;

p=l->next;

while(p)

{

printf("%d\t%.2f\n",p->number,p->score);

p=p->next;

}

printf("\n");

}

头插法建立单链表

#include #include typedefstruct node { int data; struct node *next; }lnode,*linklist; \*定义头结点的函数*\ linklistInitlist_l(); \*定义头插法的函数*\ linklistCreatelist_f(linklistl,int n); \*定义输出链表数据的函数*\ voidPrintlist(linklist); \*主函数*\ int main(void) { inti,s,n; linklist l; l=Initlist_l(); printf("Please input number of datas:\n"); scanf("%d",&n); Createlist_f(l,n); Printlist(l); return 0; } linklistInitlist_l() { linklist l; l=(linklist)malloc(sizeof(lnode)); l->next=0; return l; } linklistCreatelist_f(linklistl,int n) { int i; linklist p; for(i=0;idata); p->next=l->next; l->next=p; }

return l; } voidPrintlist(linklist l) { linklist p; p=l->next; while(p) { printf("%d\t",p->data); p=p->next; } printf("\n"); }

C语言链表专题复习

链表专题复习 数组作为存放同类数据的集合,给我们在程序设计时带来很多的方便,增加了灵活性。但数组也同样存在一些弊病。如数组的大小在定义时要事先规定,不能在程序中进行调整,这样一来,在程序设计中针对不同问题有时需要3 0个元素大小的数组,有时需要5 0个数组元素的大小,难于统一。我们只能够根据可能的最大需求来定义数组,常常会造成一定存储空间的浪费。 我们希望构造动态的数组,随时可以调整数组的大小,以满足不同问题的需要。链表就是我们需要的动态数组。它是在程序的执行过程中根据需要有数据存储就向系统要求申请存储空间,决不构成对存储区的浪费。 链表是一种复杂的数据结构,其数据之间的相互关系使链表分成三种:单链表、循环链表、双向链表,下面只介绍单向链表。 7.4.1 单链表 图7 - 3是单链表的结构。 单链表有一个头节点h e a d,指向链表在内存的首地址。链表中的每一个节点的数据类型为结构体类型,节点有两个成员:整型成员(实际需要保存的数据)和指向下一个结构体类型节点的指针即下一个节点的地址(事实上,此单链表是用于存放整型数据的动态数组)。链表按此结构对各节点的访问需从链表的头找起,后续节点的地址由当前节点给出。无论在表中访问那一个节点,都需要从链表的头开始,顺序向后查找。链表的尾节点由于无后续节点,其指针域为空,写作为N U L L。 图7 - 3还给出这样一层含义,链表中的各节点在内存的存储地址不是连续的,其各节点的地址是在需要时向系统申请分配的,系统根据内存的当前情况,既可以连续分配地址,也可以跳跃式分配地址。 看一下链表节点的数据结构定义: struct node { int num; struct node *p; } ; 在链表节点的定义中,除一个整型的成员外,成员p是指向与节点类型完全相同的指针。 在链表节点的数据结构中,非常特殊的一点就是结构体内的指针域的数据类型使用了未定义成功的数据类型。这是在C中唯一规定可以先使用后定义的数据结构。 ?单链表的创建过程有以下几步: 1 ) 定义链表的数据结构。 2 ) 创建一个空表。 3 ) 利用m a l l o c ( )函数向系统申请分配一个节点。

数据结构--单链表的插入和删除

单链表的插入和删除实验日志 指导教师刘锐实验时间2010 年10 月11 日 学院数理专业数学与应用数学 班级学号姓名实验室S331-A 实验题目:单链表的插入和删除 实验目的:了解和掌握线性表的逻辑结构和链式存储结构,掌握单链表的基本算法及相关的时间性能分析。 实验要求:建立一个数据域定义为字符串的单链表,在链表中不允许有重复的字符串;根据输入的字符串,先找到相应的结点,后删除之。 实验主要步骤: 1、分析、理解程序(相关程序见附录) 。 2、调试程序,并设计输入字符串数据(如:aa, bb , cc , dd, ee,#),测试程序的如下功能: 不允许重复字符串的插入;根据输入的字符串,找到相应的结点并删除。 3、修改程序: (1)增加插入结点的功能。 (2)将建立链表的方法改为头插入法。 实验结果: 1、不允许重复字符串的插入功能结果如下:

3、删除和插入结点的功能如下:

心得体会: 通过这次实验我学会了单链表的建立和删除,基本了解了线性表的逻辑结构和链式存储结构,掌握了单链表的基本算法,使我受益匪浅。在调试程序的过程中,遇见了一系列的问题,后来在同学的帮助下,修改了几个语句后,终于把它给调试出来了。有时候一个标点符号的问题就可能导致程序无法运行。所以在分析调试程序的时候一定要仔细。 附加程序代码: 1、调试之后的程序如下(其中蓝色字体部分为修改过的): #include"stdio.h" #include"string.h" #include"stdlib.h" #include"ctype.h" typedef struct node //定义结点 { char data[10]; //结点的数据域为字符串 struct node *next; //结点的指针域 }ListNode; typedef ListNode * LinkList; // 自定义LinkList单链表类型 LinkList CreatListR1(); //函数,用尾插入法建立带头结点的单链表ListNode *LocateNode(); //函数,按值查找结点

单链表的基本操作

上机实验报告 学院:计算机与信息技术学院 专业:计算机科学与技术(师范)课程名称:数据结构 实验题目:单链表建立及操作 班级序号:师范1班 学号:201421012731 学生姓名:邓雪 指导教师:杨红颖 完成时间:2015年12月25号

一、实验目的: (1)动态地建立单链表; (2)掌握线性表的基本操作:求长度、插入、删除、查找在链式存储结构上的实现; (3)熟悉单链表的应用,明确单链表和顺序表的不同。 二、实验环境: Windows 8.1 Microsoft Visual c++ 6.0 三、实验内容及要求: 建立单链表,实现如下功能: 1、建立单链表并输出(头插法建立单链表); 2、求表长; 3、按位置查找 4、按值查找结点; 5、后插结点; 6、前插结点 7、删除结点; 四、概要设计: 1、通过循环,由键盘输入一串数据。创建并初始化一个单链表。 2、编写实现相关功能函数,完成子函数模块。 3、调用子函数,实现菜单调用功能,完成顺序表的相关操作。

五、代码: #include #include typedef char datatype; typedef struct node { datatype data; struct node *next; }linklist; linklist *head,*p; //头插法建立单链表 linklist *Creatlistf() { char ch; linklist *head,*s; head=NULL; ch=getchar(); printf("请输入顺序表元素(数据以$结束):\n"); while(ch!='$') { s=(linklist *)malloc(sizeof(linklist)); s->data=ch; s->next=head; head=s; ch=getchar(); } return head; } //求单链表的长度 void get_length(struct node *head) { struct node *p=head->next; int length=0;

单链表的建立及其基本操作的实现(完整程序)

#include "stdio.h"/*单链表方式的实现*/ #include "malloc.h" typedef char ElemType ; typedef struct LNode/*定义链表结点类型*/ { ElemType data ; struct LNode *next; }LNode,*LinkList;/*注意与前面定义方式的异同*/ /*建立链表,输入元素,头插法建立带头结点的单链表(逆序),输入0结束*/ LinkList CreateList_L(LinkList head) { ElemType temp; LinkList p; printf("请输入结点值(输入0结束)"); fflush(stdin); scanf("%c",&temp); while(temp!='0') { if(('A'<=temp&&temp<='Z')||('a'<=temp&&temp<='z')) { p=(LinkList)malloc(sizeof(LNode));/*生成新的结点*/ p->data=temp; p->next=head->next; head->next=p;/*在链表头部插入结点,即头插法*/ } printf("请输入结点值(输入0结束):"); fflush(stdin); scanf("%c",&temp); } return head; } /*顺序输出链表的内容*/ void ListPint_L(LinkList head) { LinkList p; int i=0; p=head->next; while(p!=NULL) { i++; printf("单链表第%d个元素是:",i);

单链表基本操作实验

实验2 链表的操作 实验容: 1)基础题:编写链表基本操作函数,链表带有头结点 (1)CreatList_h()//用头插法建立链表 (2)CreateList_t()//用尾插法建立链表 (3)InsertList()向链表的指定位置插入元素 (4)DeleteList()删除链表中指定元素值 (5)FindList()查找链表中的元素 (6)OutputList()输出链表中元素 2)提高题: (1)将一个头节点指针为heada的单链表A分解成两个单链表A和B,其头结点指针分别为heada和headb,使得A表中含有原单链表A中序号为奇数的元素,B表中含有原链表A中序号为偶数的元素,且保持原来的相对顺序。 (2)将一个单链表就地逆置。 即原表(a1,a2,。。。。。。 an),逆置后新表(an,an-1,。。。。。。。a1) /* 程序功能 :单链表基本功能操作 编程者 :天啸 日期 :2016-04-14 版本号 :3.0 */ #include #include typedef struct List { int data; struct List *next; }List; void CreatList_h(List *L) //头插法 { int i = 0; int n = 0; int goal; List *p; printf("请输入数据的个数:\n"); scanf("%d",&n); L -> next = NULL; for(i=0;i

{ printf("请输入第%d个数:\n",i+1); scanf("%d",&goal); p = (struct List*)malloc(sizeof(struct List)); p -> data = goal; p -> next = L->next; //将L指向的地址赋值给p; L -> next = p; } } void CreateList_t(List *L) //尾插法 { int i; int n; int goal; List *p; List *q=L; printf("请输入数据的个数:\n"); scanf("%d",&n); for (i=0;i data = goal; q -> next = p; q = p; } q -> next = NULL; } void InsList(List *L,int i,int e) //插入 { List *s; List *p = L; int j = 0; while (p&&jnext; ++j; } s = (struct List*)malloc(sizeof(struct List)); s -> data = e; //插入L中

单链表原地逆置(头插法)

原地逆置单链表(头插法) /* 原地逆置头插法伪算法 本函数使用的是带头节点的链表 1.将p指针指向有效数据的第二个节点 2.将p指针始终插入到phead后面,第一个有效节点前面,即插入到它俩中间位置,不论第一个有效节点是否被更改,这样就可以完全逆置单链表 3.p和q指针后移,直至移动到最后一个节点,完成插入操作 */ #include #include #include typedefstruct node { int data; struct node * next; }NODE,*PNODE; PNODE create_list(); //创建单链表函数声明 void traverse_list(PNODE phead); //输出单链表函数声明 PNODE reverse_list(PNODE phead); //逆置单链表函数声明 int main(void) { PNODE phead; phead = create_list(); traverse_list(phead); phead = reverse_list(phead); traverse_list(phead); return 0; }

PNODE create_list() { intval; PNODE phead,ptail,s; phead = (PNODE)malloc(sizeof(NODE)); if(phead == NULL) { printf("分配失败,程序终止\n"); exit(-1); } ptail=phead; printf("请输入每个节点的值,以-1结束\n"); scanf("%d",&val); while(val!=-1) { s=(PNODE)malloc(sizeof(NODE)); //新建一个节点 if(s == NULL) { printf("分配失败,程序终止\n"); exit(-1); } s->data = val; //s->next = NULL; ptail->next = s; //链接到节点后面 ptail = ptail->next; //使ptail永远指向最后一个节点 scanf("%d",&val); } ptail->next = NULL; printf("创建成功!\n"); returnphead; } voidtraverse_list(PNODE phead) { PNODE p; if(phead == NULL) { printf("链表为空,请创建链表!\n"); } else { p = phead->next;

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

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

单链表完整算法

// 包含头文件 #include #include #include // 为结点数据类型和结构体类型起别名 typedefint datatype; typedefstructLinkNode { datatype data; // 数据域 structLinkNode *next; // 指针域存放下一个结点的地址}LNode,*LinkList; LinkList L; // 单链表的头指针 // 1.用头插法创建单链表 LinkListCreateListHead(int n) { // 创建头结点 LNode *L = (LNode *)malloc(sizeof(LNode)); L->next = NULL; // 设置指针域为空

LinkList p; // p指向新结点 for(inti=n;i>0;i--) // 先插入最后一个结点,插入次序与逻辑次序相反 { // 生成新结点 p = (LNode *)malloc(sizeof(LNode)); // 从键盘输入新结点的值 printf("请输入要插入第%d结点的值:\n",i); scanf("%d", &p->data); p->next = L->next; // 让L原来的后继结点成为p的后继结点 L->next = p; // p成为L新的后继结点 } return L; // 返回单链表的头指针 } // 2.用尾插法创建单链表 LinkListCreateListTail(int n) {

// 生成头结点 L = (LNode *)malloc(sizeof(LNode)); L->next = NULL;// 设置指针域为空 // p指向新结点,q指向尾结点 LinkList p, q = L; // 依次在末尾插入n个结点 for(inti=1;i<=n;i++) { // 生成新结点p p = (LNode *)malloc(sizeof(LNode)); // 从键盘输入新结点的值 printf("请输入第%d个结点的值:\n", i); scanf("%d",&p->data); p ->next = NULL; // 新结点(也是尾结点)的指针域为空 // 把新结点链接到单链表的末尾 q->next = p;

创建链表并实现插入、删除、输出,查找等功能

创建链表并实现插入、删除、输出,查找等功能 一、实验目的及内容 1、目的:通过上级操作,进一步了解线性表的存储结构以及基本运算。 2、内容: (1)、题目要求 编写程序,创建一个链表,实现链表的插、删除、查找和输出等功能。(2)、分析算法 单链表的建立,使用动态建立链表,有头插法建表和尾插法建表。 头插法建表: input_font() { head=NULL; datatype ch; puts("请输入您的数据,想结束输入,请键入“#”"); fflush(stdin); ch=getchar(); while(ch!='#') { p=(linklist *)malloc(sizeof(linklist)); p->c=ch; p->next=head; head=p; length++; puts("恭喜,你的数据输入正确!请继续操作!"); fflush(stdin); ch=getchar(); }

尾插法建表: input_end() { head=(linklist *)malloc(sizeof(linklist)); r=head; datatype ch; puts("请输入您的数据,想结束输入,请键入“#”"); fflush(stdin); ch=getchar(); while(ch!='#') { p=(linklist *)malloc(sizeof(linklist)); p->c=ch; r->next=p; r=p; length++; puts("恭喜,你的数据输入正确!请继续操作!"); fflush(stdin); ch=getchar(); } r->next=NULL; } (3)、流程图: 函数层次:

单链表的定义及其基本操作技巧

单链表的定义及基本操作 一、实验目的、意义 (1)理解线性表中带头结点单链表的定义和逻辑图表示方法。 (2)熟练掌握单链表的插入,删除和查询算法的设计与实现。 (3)根据具体问题的需要,设计出合理的表示数据的链表结构,并设计相关算法。 二、实验内容及要求 说明1:本次实验中的链表结构均为带头结点的单链表。 说明2: 学生在上机实验时,需要自己设计出所涉及到的函数,同时设计多组输入数据并编写主程序分别调用这些函数,调试程序并对相应的输出作出分析;修改输入数据,预期输出并验证输出的结果,加深对有关算法的理解。 具体要求: 建立单链表,完成链表(带表头结点)的基本操作:建立链表、插入、删除、查找、输出;其它基本操作还有销毁链表、将链表置为空表、求链表的长度、获取某位置结点的内容、搜索结点。 三、实验所涉及的知识点 数据结构、C语言语法函数、结构体类型指针、单链表(建表、初始化链表、求表长、插入、删除、查询算法)等。 四、实验结果及分析 (所输入的数据及相应的运行结果,运行结果要有提示信息,运行结果采用截图方式给出。)

五、总结与体会 (调试程序的心得与体会,若实验课上未完成调试,要认真找出错误并分析原因等。) 调试程序时,出现了许多错误。如:结构体类型指针出错,忽略了释放存储空间,对头插法建表、尾插法建表不熟悉等。另外还有一些语法上的错误。由于对所学知识点概念模糊,试验课上未能完成此次上机作业。后来经过查阅教材,浏览网页等方式,才完成试验。这次试验出现错误最重要的原因就是对课本知识点理解不深刻以及编写代码时的粗心。以后要都去练习、实践,以完善自己的不足。 六、程序清单(包含注释) //单链表

头插法与尾插法

#include #include typedef char DataType; //假设节点的数据类型为字符 typedef struct node{ //节点类型定义 DataType data; //节点的数据域 struct node *next; //节点的指针域 }ListNode; typedef ListNode* LinkList; ListNode *p; //指向某一节点的指针LinkList head; //单链表的头指针 //头插法 LinkList createListF(void); LinkList createListF(void){ //返回单链表的头指针 char ch; LinkList head; //头指针 ListNode *s; //工作指针 head = NULL; //链表开始为空

while (ch != '\n') { s = (ListNode*)malloc(sizeof(ListNode)); //生成新节点 s->data = ch; //将读入的数据放入新节点的数据域中 s->next = head; head = s; ch = getchar(); //读入下一个字符} return head; } //尾插法 LinkList createListR(void); LinkList createListR(void){ //返回头指针 char ch; LinkList head; //头指针 ListNode *s,*r; //工作指针 head = NULL; //链表开始为空 r = NULL; //尾指针初始值为空

数据结构头插法和尾插法建立单链表

#include #include typedef struct node { int data; struct node *next; }*Listlink; /*前插法创建单链表*/ void qian_create(Listlink *head,int n) { int i; Listlink p; *head=(Listlink )malloc(sizeof(struct node)); (*head)->next=NULL;/*建立头结点*/ printf("input %d numbers:\n",n); for(i=0;idata)); p->next=(*head)->next; (*head)->next=p; } } /*后插法创建单链表*/ void hou_create(Listlink *head,int n) { int i; Listlink p,q; *head=(Listlink )malloc(sizeof(struct node)); (*head)->next=NULL;/*建立头结点*/ q=*head; for(i=0;idata)); p->next=q->next; q->next=p; q=p; } }

void print_list(Listlink head) { Listlink p; p=head->next; while(p!=NULL) { printf(" %d",p->data); p=p->next; } } main() { Listlink la,lb,lc; puts("houcha:"); hou_create(&lb,10); puts("qiancha:"); qian_create(&la,10); print_list(la); print_list(lb); getchar(); }

头插法和尾插法建立单链表

#include "stdio.h" #include "stdlib.h" typedef struct List { int data; struct List *next; //指针域 }List; void HeadCreatList (List *L) //头插法建立链表 { List *s; L->next=NULL; for (int i=0;i<10;i++) { s=(struct List*)malloc(sizeof(struct List)); s->data=i; s->next=L->next; //将L指向的地址赋值给S; L->next=s; } } void TailCreatList(List *L) //尾插法建立链表 { List *s,*r; r=L;

for (int i=0;i<10;i++) { s=(struct List*)malloc(sizeof(struct List)); s->data=i; r->next=s; r=s; } r->next=NULL; } void DisPlay(List *L) { List *p=L->next; while(p!=NULL) { printf ("%d ",p->data); p=p->next; } printf("\n"); } int main () {

List *L1,*L2; L1=(struct List*)malloc(sizeof(struct List)); L2=(struct List*)malloc(sizeof(struct List)); HeadCreatList(L1); DisPlay(L1); TailCreatList(L2); DisPlay(L2); } //头插法创建链表 #include #include struct node { int data; struct node * next; }; //建立只含头结点的空链表 struct node * create_list() { struct node * head = NULL; head = (struct node *)malloc(sizeof(struct node)); if (NULL == head)

找两条单链表的公共结点

题目:两个单向链表,找出它们的第一个公共结点。 链表的结点定义为: struct ListNode { int m_nKey; ListNode* m_pNext; }; 分析:这是一道微软的面试题。微软非常喜欢与链表相关的题目,因此在微软的面试题中,链表出现的概率相当高。 如果两个单向链表有公共的结点,也就是说两个链表从某一结点开始,它们的m_pNext 都指向同一个结点。但由于是单向链表的结点,每个结点只有一个m_pNext,因此从第一个公共结点开始,之后它们所有结点都是重合的,不可能再出现分叉。所以,两个有公共结点而部分重合的链表,拓扑形状看起来像一个Y,而不可能像X。 看到这个题目,第一反应就是蛮力法:在第一链表上顺序遍历每个结点。每遍历一个结点的时候,在第二个链表上顺序遍历每个结点。如果此时两个链表上的结点是一样的,说明此时两个链表重合,于是找到了它们的公共结点。如果第一个链表的长度为m,第二个链表的长度为n,显然,该方法的时间复杂度为O(mn)。 接下来我们试着去寻找一个线性时间复杂度的算法。我们先把问题简化:如何判断两个单向链表有没有公共结点?前面已经提到,如果两个链表有一个公共结点,那么该公共结点之后的所有结点都是重合的。那么,它们的最后一个结点必然是重合的。因此,我们判断两个链表是不是有重合的部分,只要分别遍历两个链表到最后一个结点。如果两个尾结点是一样的,说明它们用重合;否则两个链表没有公共的结点。 在上面的思路中,顺序遍历两个链表到尾结点的时候,我们不能保证在两个链表上同时到达尾结点。这是因为两个链表不一定长度一样。但如果假设一个链表比另一个长l个结点,我们先在长的链表上遍历l个结点,之后再同步遍历,这个时候我们就能保证同时到达最后一个结点了。由于两个链表从第一个公共结点考试到链表的尾结点,这一部分是重合的。因此,它们肯定也是同时到达第一公共结点的。于是在遍历中,第一个相同的结点就是第一个公共的结点。 在这个思路中,我们先要分别遍历两个链表得到它们的长度,并求出两个长度之差。在长的链表上先遍历若干次之后,再同步遍历两个链表,知道找到相同的结点,或者一直到链表结束。此时,如果第一个链表的长度为m,第二个链表的长度为n,该方法的时间复杂度为O(m+n)。 基于这个思路,我们不难写出如下的代码: 1.template 2.struct ListNode

单链表的创建及功能实现(java编写)

2014-6-28 //任一类学生为例,建立动态结构—单链表的结构形式;完成学生单链表的建立、插入、删除、查询等功能。请用面向对象的思想分析问题及书写程序。 import java.util.Scanner; public class List { //定义一个内部类 public class Node { int data; Node next;//指向下一个节点的引用 public Node(int data,Node next) { this.data=data;this.next=next; } }//内部类结束 public Node header; public Node p; static int length; public void CreatList(int a[])//尾插法创建单链表 { Node q=new Node(0,null); header=q; for(int i=0;ilength-1) { System.out.println("链表索引越界"); } Node k=header.next; for(int i=0;i

return null; } public void insertList(int index,int data)//插入元素{ if(index<0||index>length) { System.out.println("链表索引越界"); } else { Node j=getNodebyindex(index-1); Node newnode=new Node(data,null); newnode.next=j.next; j.next=newnode; length++; } } public void Delete(int index)//删除节点 { if(index<0||index>length-1) { System.out.println("链表索引越界"); } Node j=getNodebyindex(index-1); Node del=j.next; j.next=del.next; length--; } public void Getelem(int index)//查询索引index处的元素{ if(index<0||index>length-1) { System.out.println("链表索引越界"); } Node k=getNodebyindex(index); System.out.println("查询得到的元素为:"+k.data); } public void print()//输出链表 { Node p=header.next;

嵌入式linux-c语言-单链表之尾部插入节点

单链表之尾部插入节点 1、单链表的实现之从尾部插入节点 1.1、从尾部插入节点 先请看上面的图,我们现在已经有了一个只有一个节点的链表,并且用creat_node又创建了一个首地址为new节点。怎么将这两个节点链接起来? 答案是显而易见的,只需要一步:pHeader->pNext=new; 但是这样的一句代码显然只适用于上图的这一种情况,我们想要的insert_tail()函数的功能是不管链表后面有几个节点,都可以使用该函数来完成尾部插入新节点的目的。于是我们就有了下面的思路。 将从尾部插入节点的任务分成两个步骤: (1)找到链表的最后一个节点。 (2)将新的节点和原来的最后一个节点连接起来。 void insert_tail(struct node*pH,struct node*new) { struct node*p=pH; while(NULL!=p->pNext)//第一步 { p=p->pNext; } p->pNext=new;//第二步 } 函数的参数为链表的头指针pH和要插入的新节点的首地址new。第一步的while循环用来找到最后一个节点的首地址,第二步的作用就是将新的节点和原来的最后一个节点连接起来。

1.2、构建第一个简单的链表 好了,现在我们已经实现了creat_node()和insert_tail()两个必要的函数,可以开始构建真正的链表了,先构建一个有3个节点的链表好了。 #include #include #include struct node { int data; struct node*pNext; }; struct node*create_node(int data); void insert_tail(struct node*pH,struct node*new); int main(void) { struct node*pHeader=create_node(1); insert_tail(pHeader,create_node(2)); insert_tail(pHeader,create_node(3)); printf("node1data:%d.\n",pHeader->data); printf("node2data:%d.\n",pHeader->pNext->data); printf("node3data:%d.\n",pHeader->pNext->pNext->data); return0; } 1.3、什么是头结点 请思考一下如果像下面的方法来创建第一个节点可不可以? struct node*pHeader=NULL; insert_tail(pHeader,create_node(1)); 答案当然是不可以的。我们在insert_tail中直接默认了头指针指向了一个节点,如果我们不给头指针添加一个节点直接insert_tail(pHeader, create_node(1)),函数内部就会试图操作pHeader->pNext,但是此时pHeader的值是NULL,因此会导致段错误。我们不得不在定义了头指针后创建一个新节点给指针初始化,否则不能避免这个错误,但是这样的方法使得我们必须对链表的第一个节点进行特殊对待。 链表还有另外一种用法,就是把头指针指向的第一个节点作为头结点使用。头结 点有两个特点:它紧跟在头指针后面;头结点的数据部分是空的(或者存链表的节点数),指针部分指向第一个有效节点。 这样看来头结点确实和其他节点不同,头节点在创建头指针时一并创建并且和头指 针关联起来。后面真正存储数据的节点就用节点添加函数来完成,譬如insert_tail。这种处理方法的思路就是既然第一个节点注定是要特殊对待的就干脆让它更特殊一点。 链表有没有头结点是不同的。体现在链表的插入节点,删除节点,遍历节点

C语言头插法举例

/*功能:输入一行字符,且每个字符存入一个结点,按输入顺序建立一个链表结点的序列,然后再按相反顺序输出字符并释放全部结点*/ /*方法:以前插方式建立一个链表,然后从前向后输出结点的ch域值.*/ #include #include struct node /*创建链表结构*/ /*作业:用头插法创建45个结点的单链表,数据域成员包括姓名,班级,成绩.输出学生信息. 如果成绩大于或等于60分以上,就输出:“合格”,否则输出“不合格”*/ { char name[10]; /*数据域成员ch*/ int clas; int data; struct node *link; /*指针域*/ }; /* *top为头结点,*p为数据结点*/ struct node *create(int n) { struct node *top,*p; char xm[10]; int i,bj,cj; top=NULL; /*头结点赋空值*/ for(i=n;i>0;i--) { p=(struct node *)malloc(sizeof(struct node)); printf("Input name,class and data:"); scanf("%s%d%d",xm,&bj,&cj); strcpy(p->name,xm); p->clas=bj; p->data=cj; p->link=top; top=p; } printf("The result is:\n"); while(top!=NULL) {p=top; printf("Name:%s class:%d score:%d",p->name,p->clas,p->data); if(p->data>=60) printf("->pass"); else printf("->fail"); printf("\n"); top=p->link; free(p); } }

单链表(不带头结点)

一.单链表(不带头结点): 1.头插 /***************************************************** copyright (C), 2014-2015, Lighting Studio. Co., Ltd. File name: Author:Jerey_Jobs Version:0.1 Date: Description:创建链表用头插法 Funcion List: *****************************************************/ #include #include #include struct node /*定义链表节点*/ { int num; struct node *next; }; typedef struct node Node ; /*简化表示链表节点*/ typedef struct node *Link ; void create_link( Link *head ) /*创建新的,空的链表*/ { *head = NULL ; } void is_malloc_ok( Link *new_node ) /*判断节点是否创建成功*/ { if( ( *new_node == NULL ) ) { printf( " malloc error!\n" ); exit( -1 ); } } void create_new_node( Link *new_node, int i ) /*创建新的节点*/ { ( *new_node ) = ( Link )malloc( sizeof( Node ) ); is_malloc_ok( new_node );

相关文档
最新文档