建链表算法

❶ 从表头插入节点建立单链表的算法如何写

何在指针q指向的结点后面插入结点。该过程的步骤如下：

（1）先创建一个新结点，并用指针p指向该结点。

（2）将q指向的结点的next域的值（即q的后继结点的指针）赋值给p指向结点的next域。

（3）将p的值赋值给q的next域。

通过以上3步就可以实现在链表中由指针q指向的结点后面插入p所指向的结点。可以通过图1-5形象地展示出这一过程。

图1-5 向链表插入结点过程
下面给出代码描述：

1.void insertList(LinkList *list,LinkList q,ElemType e) /*当链表为空时*/ 10. else 16.} 上面的这段代码描述了如何在指针q指向的结点后面插入结点的过程。其过程包括以下几步。

（1）首先生成一个新的结点，大小为sizeof(LNode)，用LinkList类型的变量p指向该结点。将该结点的数据域赋值为e。

（2）接下来判断链表是否为空。如果链表为空，则将p赋值给list，p的next域的值置为空。否则，将q指向的结点的next域的值赋值给p指向结点的next域，这样p指向的结点就与q指向结点的下一个结点连接到了一起。

（3）然后再将p的值赋值给q所指结点的next域，这样就将p指向的结点插入到了指针q指向结点的后面。

其实通过上面这段算法描述可以看出，应用这个算法同样可以创建一个链表。这是因为当最开始时链表为空，即list==NULL，该算法可自动为链表创建一个结点。在下面的创建其他结点的过程中，只要始终将指针q指向链表的最后一个结点，就可以创建出一个 链表。

注意：函数insertList()的参数中有一个LinkList *list，它是指向LinkList类型的指针变量，相当于指向LNode类型的指针的指针。这是因为在函数中要对list，也就是表头指针进行修改，而调用该函数时，实参是&list，而不是list。因此必须采取指针参数传递的办法，否则无法在被调函数中修改主函数中定义的变量的内容。以下的代码也有类似的情况。

❷ c语言如何创建单链表

C语言创建单链表如下：

#include"stdio.h"

#include"stdlib.h"

#include"malloc.h"

#include "iostream.h"

typedef struct node

{

intdata;

node * next;

}node , * List;

void create(int n)

{

int c;

List s,L;

L=(List)malloc(sizeof(node));

L->next=NULL;

printf("请输入第1个数据：");

scanf("%d",&c);

L->data=c;

for(int i=2;i<=n;i++)

{

s=(List)malloc(sizeof(node));

printf("请输入第%d个数据：",i);

scanf("%d",&c);

s->data=c;

s->next=L;

L->next =s;

}

printf("链表创建成功！");

}

void main()

{

int n;

printf("请你输入链表的个数：");

scanf("%d",&n);

create(n);

}

❸ C语言 头插法的链表该如何建立 算法是什么 麻烦各位兄弟讲一下 小弟实在理解不了

链表其实很简单，很容易理解的，只要把它当做循环理解就好了，只不过是一个较为特殊的循环，不要把它想象的太难

首先结构体知道吧，知道就好办，不知道就赶紧复习一下，只有吃透了结构体，才能明白链表，不然链表没法讲

首先定义全局变量 结构体（链表结点的结构体类型，也可以简单的理解所谓结点就是指这个结构体）

案例：输入学生名字和编号

#include "stdio.h"
struct person
{
char *name;
int numbers;
struct person *next;
};

//指针*next起连接作用，是结点和下一个结点的桥梁，必不可少！

在定义 主程序

main()
{
struct person *head,*p1,*p2;

//定义链表操作时的三个指针，*head为头指针；*p1为申请下一个结构体的内存空间（即新的结点），用于存放新的数据；*p2为保存*p1所申请的内存空间（即保存新结点），也就是保存p1中的数据;三个指针缺一不可！

p1=p2=(struct person *)malloc(size);
head=p1;

//malloc函数申请第一个结点，让p1、p2、head共同指向同一个内存空间（即申请的第一个结点）

scanf("%s%d",p1->name,&（p1->numbers));

//向申请的第一个结点输入数据

//下来就该进入循环了

while(p1->numbers !=0)
{
p2=p1;
p2->next=p1;
p1=( struct person *)malloc(size);
scanf("%s%d",p1->name,&(p1->numbers));
}
p2->next=NULL;

//此时就进入了链表的核心算法，得给你好好讲讲！

//循环的判断条件是学生的编号(numbers)不等于0,首先判断第一个结点输入的学生编号是否为0

1.当不为0时，执行循环当中的内容

首先，让p2保存p1申请的结点（即p2=p1)

然后让p2中的next指向p1（即p2->next=p1)，在让p1去开辟下个结点

然后用malloc函数申请下一个结点，也就是p1开辟新结点（即p1=（struct person *)malloc(size)）;在这个新开辟的结点输入数据（即scanf("%s%d",p1->name,&(p1->numbers)));

接着就又进入循环判断条件，满足条件继续进入循环语句，不满足则进入语句2

注意p1、p2、head都指向第一个结点，其中head保存第一个结点，而p1、p2都是相互配合变化的，即p1开辟新结点，p2保存p1开辟的结点，如果循环几次，你就可以发现他们的规律了，

2.当学生编号（numbers）等于0时，退出循环

执行p2->next=NULL;其意思是停止p1开辟新结点（在循环语句里next是指向p1，让p1去开辟新结点）

}

如果你能看懂以上内容，那么链表的输入和链表的删除、插入应该也就很容易明白，若有别的问题QQ留言121590680

如果对你有所帮助，请记得采纳最佳答案，谢谢！

❹ 请教关于尾插法建立单链表的算法

tailing是通过在列表尾部逐个插入新节点来创建列表。与前面的插值一样，每次应用新节点时，都会读入相应的数据元素值。不同之处在于，为了将新节点插入表的尾部，需要添加尾部指针r来指向链表的尾部。

[算法步骤]

创建一个只有头节点的空链表。

②尾部指针R的初始化，指向头部节点。

③根据链表创建中包含的元素n的个数，进行n个循环的以下操作：

生成新节点*p；

●将输入元素值赋给新节点*p的数据字段；

●在尾节点*R后插入新节点*P；

●尾部指针R指向新尾部节点*PS

如图所示，线性表（A、B、C、D、E）后插值的创建过程与线性表相同。

【算法描述】

voidCreatelist_R(Linklist&L,intn) //正位序输入n个元素的值,建立带表头结点的单链表L个人

{

L=newLNode; //先建立一个带头结点的空链表L->next=NULL； //尾指针指向头结点r=L;

for(i=0;i<n:++i) //生成新

{

p=newLNode; //输入元素值赋给新结点p的数据域cin>>p->data; //将新*p插入尾结点*r之后p->next=NULL;r->next=p；

r=p； //r指向新的尾结点*p

}

}

算法时间复杂度为O（n）。

(4)建链表算法扩展阅读：

尾部插入方法从空表开始，重复读取数据，生成新节点，将读取的数据存储在新节点的数据字段中，然后将新节点插入到当前链表的尾部，直到读取标记结束。从空表开始，重复读取数据，生成新节点，将读取的数据存储在新节点的数据字段中，然后将新节点插入到当前链表的末尾，直到读取标志结束。

❺ 头插法建立单链表的算法

void creatlist(Linklist &l)
{
Linklist p,q;
l=(Linklist)malloc(sizeof(LNode));
l->next=NULL;

p=l;

while(1)
{
q=(Linklist)malloc(sizeof(LNode));
q->next=NULL;
scanf("%d",&q->data);
if(q->data<0)
break;

p->next=q;
p=q;
}

}
http://blog.csdn.net/peerslee/article/details/49451277
这个链表建立时用的就是头插法，希望帮到你，希望采纳

❻ 写出按正序建立一个单链表的算法。

就是尾插法创建单链表吧
LNode *create_LinkList(void)
/* 尾插入法创建单链表,链表的头结点head作为返回值 */
{ int data ;
LNode *head, *p, *q;
head=p=(LNode *)malloc(sizeof(LNode));
p->next=NULL; /* 创建单链表的表头结点head */
while (1)
{ scanf(“%d”,& data);
if (data==32767) break ;
q= (LNode *)malloc(sizeof(LNode));
q–>data=data; /* 数据域赋值 */
q–>next=p–>next; p–>next=q; p=q ; /*钩链，新创建的结点总是作为最后一个结点*/
}
return (head);
}

❼ 链表算法设计

我现在在别人电脑上，没有编译器，没法测试，先写了第1个程序。等明天在自己电脑上再写第2个吧。

1.
#include "stdio.h"
#include "stdlib.h"
typedef struct LNode{
int data;
struct LNode *next;
}LNode;
LNode *R=NULL;

void Insert(int e)
{
LNode *temp=(LNode *)malloc(sizeof(LNode));
temp->data=e;
if(R==NULL)
{
R=temp;
temp->next=R;
}
else
{
temp->next=R->next;
R->next=temp;
R=temp;
}
}

void print()
{
if(R!=NULL)
{
LNode *p=R;
do
{
p=p->next;
printf("%d ",p->data);
}while(p!=R);
}
}

void DeletePreR()
{
if(R!=NULL)
{
if(R->next==R)
{
free(R);
R=NULL;
}
else
{
LNode *p=R->next,*q;
while(p->next->next!=R)
p=p->next;
q=p->next;
p->next=q->next;
free(q);
}
}
}

void main()
{
int a;
scanf("%d',&a);
while(a!=0)
{
Insert(a);
scanf("%d",&a);
}
print();
DeletePreR();
print();
}

❽ c语言采用头插法或尾插法建立链表，从键盘输入递增有序的数据建立 链表

void DeleteRepetedNode(PNode head)
{
int a[100]={0};
int i = 0,j;
int flag = 1;
PNode p,q,pre;
pre = head;
p = pre->next;
q = p->next;
while(p)
{
a[i++] = pre->data;
for(j=0;j<i;j++)
if(a[j]==p->data)
{
pre->next = q;
free(p);
p = q;
flag = 0;
break;
}
if(flag)
pre = p;
if(q&&p)
{
p = q;
q = q->next;
}
flag = 1;
}
}

❾ 编写链表算法

node *newhead;
p=head->next;
q=head;
newhead=head;
while(p!=NULL)
{
if(p->data<head->data)
{
q->next=p->next;
p->next=newhead;
newhead=p;
p=q->next;
}
else
{
q=q->next;
p=p->next;
}
}
return newhead;
直接写的 没在程序里试 你试试看行不行

❿ 如何用C语言创建一个链表，实现增、删、改、查

#include<stdio.h>
#include<string.h>
#include <malloc.h>
//先定义一种student类型,表示一个学生的信息，如下：
typedef struct student
{
int num; //表示学号
char name[30]; //表示姓名
float score; //表示分数
}student;
//定义一种NODE类型,表示一个结点信息，如下：
typedef struct node
{
student st; //表示一个学生的信息
struct node *next; //表示一个NODE类型的指针
}NODE;
//1、写出建立一个带头结点的线性链表的函数，其中每个结点包括学号、姓名、分数三个数据域。函数形式如下：
NODE *creat_link(int direction)
{
NODE *head,*p,*tail;
int xh,i=1;
if(direction==1) //当direction的值为1时，新建立的结点连到尾部
{
tail=head=(NODE *)malloc(sizeof(NODE));
head->next=NULL;
printf("请输入第%d个学生的学号：",i);
scanf("%d",&xh);
while(xh>0) //从键盘临时输入学生情况，当输入的学号非正，则链表建立完毕
{
p=(NODE *)malloc(sizeof(NODE));
p->st.num=xh;
printf("请输入第%d个学生的姓名：",i);
scanf("%s",p->st.name);
printf("请输入第%d个学生的成绩：",i);
scanf("%f",&p->st.score);
p->next=NULL;
tail->next=p;
tail=p;
i=i+1;
printf("请输入第%d个学生的学号：",i);
scanf("%d",&xh);
}
}
else if(direction==0) //当direction为0时，新建立的结点成为第一个结点
{
head=(NODE *)malloc(sizeof(NODE));
head->next=NULL;
printf("请输入第%d个学生的学号：",i);
scanf("%d",&xh);
while(xh>0) //从键盘临时输入学生情况，当输入的学号非正，则链表建立完毕
{
p=(NODE *)malloc(sizeof(NODE));
p->st.num=xh;
printf("请输入第%d个学生的姓名：",i);
scanf("%s",p->st.name);
printf("请输入第%d个学生的成绩：",i);
scanf("%f",&p->st.score);
p->next=head->next;
head->next=p;
i=i+1;
printf("请输入第%d个学生的学号：",i);
scanf("%d",&xh);
}
}
return head;
}
//2、写出输出上述链表各结点数据域值的函数。该函数对应的函数需要一个形参，表示链表的头指针，形式如下：
void print_link(NODE *head)
{
NODE *p;
p=head->next;
printf("%-10s%-20s%-10s\n","学号","姓名","分数");
while(p!=NULL)
{
printf("%-10d%-20s%-10.1f\n",p->st.num,p->st.name,p->st.score);
p=p->next;
}
//该函数能输出head所指的链表的所有结点值，输出形式如下：
/*本函数输出线性表sq中所有数据，形式如下：
学号 姓名 分数
12 张三 234.5
18 李四 987.7
……… ……… …….*/
}
//3、写出在链表中删除结点的函数
int del_link(NODE *head,char name[])
{
NODE *p,*p1;
p=head->next;
p1=head;
while(p!=NULL)
{
if(strcmp(p->st.name,name)!=0)
{
p1=p;
p=p->next;
}
else
{
break;
}
}
if(p!=NULL)
{
p1->next=p->next;
free(p);
return 1;
}
else
{
return 0;
}
//删除head所指的链表中，名字为name的结点，删除成功返回1，不成功返回0
}
//4、写出在链表中插入结点的算法
int insert(NODE *head,student x,int wz)
{
NODE *p=head;
int i=0,jg;
if(wz<=0)
{
jg=0;
}
else
{
while(i<wz-1&&p!=NULL)
{
i++;
p=p->next;
}
if(p==NULL)
{
jg=0;
}
if(i=wz-1)
{
//找到wz前面的节点，p指向它
NODE *q;
q=(NODE *)malloc(sizeof(NODE));
q->st.num=x.num;
strcpy(q->st.name,x.name);
q->st.score=x.score;
q->next=p->next;
p->next=q;
jg=1;
}
}
return jg;
//该函数能够在wz这个结点之前，插入一个新结点，新结点的数据域为x。插入成功返回1，不成功返回0。
}
//5、写出主函数，分别调用上面算法所对应的程序，建立链表，并输出链表的值。
void main()
{
NODE *head; //定义指针变量head
int wz; //表示插入位置
char xm[30];
student st; //定义一个变量st，用来表示一个学生的信息
head=creat_link(1);
print_link(head); //调用函数建立链表，并把返回值送给head;
//调用函数，输出链表中各个结点的值
//输入一个学生的有关信息，送给变量st的有关成员
printf("\n\n请输入要插入的位置：");
scanf("%d",&wz); //输入wz的值
printf("请输入要插入的学生的学号：");
scanf("%d",&st.num);
printf("请输入要插入的学生的姓名：");
scanf("%s",st.name);
printf("请输入要插入的学生的成绩：");
scanf("%f",&st.score);
//调用函数，在链表中把学生st的值作为一个结点插入,如果插入成功，输出新链表
if(insert(head,st,wz)==1)
{
printf("\n插入成功，新表为：\n");
print_link(head);
}
else
{
printf("插入不成功");
}
//调用函数，在链表中删除一个指定结点的值,如果删除成功，输出新链表
printf("\n\n请输入要删除的学生的姓名：");
getchar();
gets(xm);
if(del_link(head,xm)==1)
{
printf("\n删除成功，新表为：\n");
print_link(head);
}
else
{
printf("删除不成功");
}
}