① 單鏈表中在結點前插入一個結點的演算法
假設插入的值為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函數要寫詳細，主函數可以用偽代碼表示。