① 单链表中在结点前插入一个结点的算法
假设插入的值为int类型，为a;
void Insert(LinkList P)
{
LinkList s;
int a,tempt;
s=(LinkList)malloc(sizeof(LNode));
s->data=a;
s->next=x->next;
x->next=s;
tempt=s->data;
s->data=x->data;
x->data=tempt;
}
这个算法的思想是在x的节点后插入一个节点，然后将x节点的值和插入节点的值交换，这就相当于在x节点前插入一个节点了。
void Del(LinkList P)
{
LinkList L,S;
S=P;
L=s->next;
while(S->next)
{
if(L->data==x)
{
S->next=L->next;
free(L);
L=S->next;
}
else
{
S=S->next;
L=L->next
}
}
}
这是第二个了
② C语言单链表插入问题
链表的插入应该是复制要插入地点元素，然后插入在后面，再修改原来节点值为插入值
因为像在函数中使用k = q;这样不会修改函数外的指针，只有修改k指向的内容才可以。
插入函数修改为：
void Insert (linklist * k, int n)
{
linklist * t, * q;
q = (linklist *)malloc(sizeof(linklist));//不管如何都要申请空间
//增加一个节点的操作是复制要插入地点元素，插入，然后修改原来节点值为插入值
while (n <= k->data )//这个是查找位置
k = k->pl;
q->data = k->data;//复制当前k元素
q->pl = k->pl;
k->pl = q; //修改k下级指向，完成插入
k->data = n; //修改为插入值
}
③ 从表头插入节点建立单链表的算法如何写
何在指针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。因此必须采取指针参数传递的办法，否则无法在被调函数中修改主函数中定义的变量的内容。以下的代码也有类似的情况。
④ 数据结构:描述单链表中插入一个结点e的算法
LinklistListInsert(LinkListL,intx,Elemtypee){//在带头节点单链表第X个节点前插入新元素eLinklistp,s;intj;p=L;j=0;while(p!=NULL&&jnext;j++}//找第x-1个节点if(p==NULL||j>x-1){printf("参数X错");exit(1);}S=(Linklist)malloc(sizeof(LNode));//创建新节点，其数据为eS->data=e;S->next=p->next;//新节点插入在第X-1个节点的后面P->next=S;returnL;}
⑤ 以单链表为存储结构实现直接插入排序的算法,求程序
下面的程序是以单链表为储存结构的各种操作集合，包括插入，删除，访问等操作，你可以全部都看看，关键的地方我都有注释，希望能帮到你
#define true 1
#define false 0
#include<stdio.h>
#include<malloc.h>
typedef struct node
{
int data;
struct node *next;
}node;
node *initiatesl(node *h) /*初始化链表*/
{
h->next=NULL;
return(h);
}
int pread()
{
int x;
scanf_s("%d",&x);
return(x);
}
void createsl(node *h) /*创建单链表*/
{
node *p,*s;
int x;
p=h;
x=pread();
while(x!=-1)
{
s=(node*)malloc(sizeof(node));
if(!s) /*判定S是否有效，如无效，则结束*/
{
printf("Memory Out!!!");
return;
}
s->data=x;
p->next=s;
p=s;
x=pread();
}
p->next=NULL; /*设定尾节点*/
}
int access(node *h,int i) /*访问的算法*/
{
int j;
node *p;
p=h;
j=0;
while(p->next!=NULL&&j<i) /*寻找节点I*/
{
p=p->next;
j++;
}
if(p!=NULL&&j==i) /*判断i是否有效*/
return(p->data);
else
return(NULL);
}
void enter(node *h,int i,int x) /*插入的算法*/
{
node *p,*t;
int j;
p=h;j=0;
while(p!=NULL&&j<i-1) /*寻找节点I*/
{
p=p->next;
j++;
}
if(j!=i-1) /*判断i是否有效*/
{
printf("i is invalued!!!\n");
return;
}
t=(node*)malloc(sizeof(node)); /*插入的关键*/
t->data=x;
t->next=p->next;
p->next=t;
}
void deletesl(node *h,int i) /*删除的算法*/
{
node *p,*s;
p=h;
int j;
j=0;
while(p->next!=NULL&&j<i-1) /*寻找节点I*/
{
p=p->next;
j++;
}
if(j!=i-1||p->next==NULL) /*判断i是否有效*/
{
printf("i is invalued!!!\n");
return;
}
s=p->next; /*记录i节点的位置*/
p->next=s->next;
}
void print(node *h) /*打印输出链表*/（注：此处函数名不能用printf，因为printf是关键词，不能用来做函数名）
{
node *q;
q=h->next;
if(h!=NULL)
{
if(h->next!=NULL)
{
printf(" h->( ,--)->");
do {
printf("(%d,--)->",q->data);
q=q->next;
}while(q->next!=NULL);
printf("(%d,^)\n\n",q->data);
}
else
printf("h->( ,^)\n");
}
}
void main()
{
node *h;
int i,m,n;
h=(node*)malloc(sizeof(node));
if(!h)
{
printf("Memory Out!!!\n");
}
h=initiatesl(h);
createsl(h);
print(h);
i=5;m=23;n=7;
enter(h,i,m);
print(h);
deletesl(h,n);
print(h);
}
⑥ 单链表的元素插入算法
#include <stdlib.h>#include<stdio.h>typedef struct LNode{
int data;
LNode *next;
}*List,LNode;void Creat(List &L,int n){//创建链表
List p;//用于循环创建的节点
L=(List)malloc(sizeof(struct LNode));
L->next=NULL;
for(int i=1;i<=n;i++){
p=(List)malloc(sizeof(struct LNode));
scanf("%d",&p->data);
p->next =L->next;
L->next=p;
}
}//创建成功void Print(List L3){
L3=L3->next;
while(L3){
printf("%d",L3->data);
L3=L3->next;
}
}void Insert(List &L,int i,int e){//在第i个位置之前插入e
List p,s;
p=L;
int j=0; while(p&&j<=i-1){
if(j==i-1){
s=(List)malloc(sizeof(struct LNode));
s->data=e;
s->next=p->next;
p->next=s;
}
j++;
p=p->next;
}
}
int main(){ List L;
int n,i,e;
scanf("%d,%d,%d",&n,&i,&e);
Creat(L,n);
Insert(L,i,e);
Print(L); return 0;
}1
⑦ 数据结构单链表插入的算法求解。。。在线等
第一题指明了q的下一个结点是p换句话说已知q的下一个结点，第二题是没有表明p的下一个结点是什么，但第二题它也加了个条件“不是尾结点”，只是条件不同而已，原理都是一样的。
第一题已经指明了下一个结点了是什么了，就没必要去先保存后继结点，举个例子吧：
在第一题中假设p是最后一个结点，q任然是p的直接前驱结点，我们都知道最后一个结点的的指针域为NULL，即使p->next=NULL;这时你保存p的后继结点有意义吗？
第二题保存结点原因是p的后一个结点只能用p->next来表明，所以要保存结点
⑧ 单链表的直接插入排序的算法。问题
一开始head->next=NULL;与q=head->next;表示将头指针与后面的链表完全断开，然后p就是后面链表的第一个结点，第一个while就是用来判断后面的那个链表是否有剩，然后q表示head的下一个结点，因为第一次操作head下一个是空的，所以第二个while跳出来，后面链表首结点下一个指向head的下一个即空，head下一个变成后面链表首结点，总的说就是把后面链表的首结点插到head的后面，之后p=pre来使后面链表首结点向后移。后面的操作也是一样，不过经过第一轮操作后，head后面已经有了结点，所以第二轮操作需要第二个while来控制应该插在哪里
⑨ 单链表的建立，插入
#include<stdio.h>
#include<stdlib.h>
struct node
{
int data;//结点存放的数据
struct node *next;//指向下一个结点的指针
};
/*建立单链表的函数，返回的是头结点*/
struct node *Create_slist()
{
int x;
struct node *h,*s,*r;
h=(struct node *) malloc(sizeof(struct node));//h为头结点
r=h;
scanf("%d",&x);
while(x!=-1)//输入数据时以-1作为结束标志
{
s=(struct node *)malloc(sizeof(struct node));
s->data=x;
r->next=s;
r=s;
scanf("%d",&x);
}
r->next='\0';
return h;
}
/*输出链表的函数，形参为头结点*/
void print_slist(struct node *h)
{
struct node *p;
p=h->next;
if(p=='\0')
printf("Linklist is null!\n");
else
{
printf("head");
while(p!='\0')
{
printf("->%d",p->data);
p=p->next;
}
printf("->end\n");
}
}
/*插入结点的函数*/
void insert_node(struct node *h,int x)
{
struct node *s,*p,*q;
s=(struct node *)malloc(sizeof(struct node));
s->data=x;
q=h->next;//q初始值为第一个结点
p=q->next;//p初始值为第二个节点
while(p!='\0')
{
if(x<=q->data&&x>=p->data)//当x满足条件时终止循环
{
q->next=s;//在q和P中插入结点
s->next=p;
break;
}
else
{
q=p;
p=p->next;
}
}
if(s->data<=q->data)//如果插入的值比最小值（也是最后一个值）小，则插入在最后面
{
q->next=s;
s->next=p;
}
else//如果插入的值比最大值（也就是第一个值）大，则插入在最前面
{
q=h->next;
h->next=s;
s->next=q;
}
}
/*从大到小排序函数*/
void sort_slist(struct node *h)
{
struct node *p,*q,*t;
t=(struct node *)malloc(sizeof(struct node));
q=h->next;
p=q;
while(q!='\0')//利用冒泡排序方法
{
p=q->next;
while(p!='\0')
{
if(q->data<=p->data)
{
t->data=q->data;
q->data=p->data;
p->data=t->data;
p=p->next;
}
else
p=p->next;
}
q=q->next;
}
}
/*主函数*/
void main()
{
struct node *head;
int x,y;
printf("建立并初始化,以-1为结束标志，遍历访问链表\n");
head=Create_slist();
sort_slist(head);
print_slist(head);
printf("输入插入点结点的数据值x=");
scanf("%d",&x);
printf("在链表中插入结点\n");
insert_node(head,x);
print_slist(head);
}
运行结果：
建立并初始化,以-1为结束标志，遍历访问链表
1 2 3 5 4 6 -1
head->6->5->4->3->2->1->end
输入插入点结点的数据值x=7
在链表中插入结点
head->7->6->5->4->3->2->1->end
Press any key to continue
建立并初始化,以-1为结束标志，遍历访问链表
1 2 3 4 5 -1
head->5->4->3->2->1->end
输入插入点结点的数据值x=0
在链表中插入结点
head->5->4->3->2->1->0->end
Press any key to continue
建立并初始化,以-1为结束标志，遍历访问链表
1 2 3 4 -1
head->4->3->2->1->end
输入插入点结点的数据值x=2
在链表中插入结点
head->4->3->2->2->1->end
Press any key to continue
希望对你有所帮助！！
⑩ 求解一道单链表的插入算法问题
用折半法！假设Y为递增的整数序列，用数组a[n]来表示：
/*
设顺序表Y中的元素递增有序.试写一算法,将X插入到顺序表的适当位置上,以保持该表的有序性.
*/
#include <stdio.h>
int* find(int *min,int *max,int i){
int *mid;
if((max-min)>1){ //如果剩下超过2个数
mid=min+(max-min)/2; //则取中间的一个数的地址值
} else{ //如果只剩下2个数
return max; //则返回较大数的地址给主函数
}
if(*mid>i){ //如果中间这个数（*mid）比i大
max=mid; //则把中间这个数设为最大的数
find(min,max,i); //继续查找
}else{ //如果中间这个数（*mid）比i小
min=mid; //则把中间这个数设为最小的数
find(min,max,i); //继续查找
}
}
int main(){
int a[]=;
int n=sizeof(a)/sizeof(int);
int i=0;
printf("原序列为： ");
while(i<n)
int x=84;//所要插入的数
printf("\n请输入要插入的数：");
scanf("%d",&x);
int a2[n+1];
if(x>=a[n-1]){//如果x大于数组中最大的数
a2[n]=x;//把x插入数组末尾
for(i=0;i<n;i++) a2[i]=a[i];
}else if(x<a[0]){//如果x小于数组中最小的数
a2[0]=x;//把x插入数组开头
for(i=0;i<n;i++) a2[i+1]=a[i];
}else{ //如果x介于数组最小值与最大值之间
int *tmp;
tmp=find(&a[0],&a[n-1],x); //从a[0]与a[n-1]之间找到x插入的位置
for(i=0;i<n+1;i++){
if(&a[i]<tmp){
a2[i]=a[i];
}else if(&a[i]==tmp){
a2[i]=x;
}else{
a2[i]=a[i-1];
}
}
}
printf("插入%d后的序列为：",x);
i=0;
while(i<=n)
printf("\n");
return 0;
}
晕！算法不是更简单吗？ 精华就是那个find函数。自己提炼一下吧。 写算法主要是那个find函数要写详细，主函数可以用伪代码表示。