c語言鏈表插入
在給定的單鏈表的第i位上插入值為n的節點。
#include <stdio.h>
#include<malloc.h>
#define N 5
typedef int elemtype;
typedef struct node
{
elemtype data;
struct node *next;
}linklist;
linklist *Creatlist(linklist*L){
L=(linklist*)malloc(sizeof(linklist));
L->next=NULL;
return L;
}
int Judge(linklist *L){
if(L->next==NULL)
{
printf("建表成功...\n");
}
else
printf("建表失敗.\n");
return 0;
}
int Input(linklist *L,int x,linklist *r){
int i;
linklist *p;
p=(linklist*)malloc(sizeof(linklist));
p->data=x;
p->next=NULL;
r->next=p;
printf("%d ",p->data);
return 0;
}
int Insert1(linklist *L,int i){
linklist *p,*q,*r,*t;
int j=1,item;
p=L->next;
q=L;
r=L;
if(L->next==NULL)
{
printf("表空.\n");
return 0;
}
else
{
while(p!=NULL&&j<i)
{
q=p;
p=p->next;
j++;
}
if(p==NULL)
{
printf("%d不在表的范圍內.\n");
return 0;
}
else
{
t=(linklist*)malloc(sizeof(linklist));
t->next=NULL;
printf("請輸入item:");
scanf("%d",&item);
t->data=item;
t->next=p;
q->next=t;
}
printf("在第%d位上插入值為%d的節點後的所有數據為\n",i,item);
for(j=0;j<N+1;j++)
{
r=r->next;
printf("%d ",r->data);
}
printf("\n");
return 1;
}
}
int main()
{
int i,item,k;
linklist *L,*r;
printf("單向鏈表的創建（包括初始化）與輸出\n");
L=Creatlist(L);
Judge(L);
printf("表中的數據為：");
r=L;
Input(L,11,r);
r=r->next;
Input(L,32,r);
r=r->next;
Input(L,17,r);
r=r->next;
Input(L,46,r);
r=r->next;
Input(L,9,r);
r=r->next;
printf("\n");
printf("在給定的單鏈表的第i位上插入值為item的節點\n");
printf("請輸入i:");
scanf("%d",&i);
Insert1(L,i);
return 0;
}
在給定單鏈表的值為m的節點的前面插入一個值為n的節點
#include <stdio.h>
#include<malloc.h>
#define N 5
typedef int elemtype;
typedef struct node
{
elemtype data;
struct node *next;
}linklist;
linklist *Creatlist(linklist*L){
L=(linklist*)malloc(sizeof(linklist));
L->next=NULL;
return L;
}
int Judge(linklist *L){
if(L->next==NULL)
{
printf("建表成功...\n");
}
else
printf("建表失敗.\n");
return 0;
}
int Input(linklist *L,int x,linklist *r){
int i;
linklist *p;
p=(linklist*)malloc(sizeof(linklist));
p->data=x;
p->next=NULL;
r->next=p;
printf("%d ",p->data);
return 0;
}
int Insert2(linklist *L,int item){
linklist *p,*q,*r,*t;
int j=1,m;
p=L->next;
r=L;
q=L;
if(L->next==NULL)
{
printf("表空.\n");
return 0;
}
else
{
while(p!=NULL)
{
if(p->data!=item)
{
q=p;
p=p->next;
}
else
break;
}
if(p==NULL)
{
printf("%d不在表的范圍內.\n");
return 0;
}
else
{
t=(linklist *)malloc(sizeof(linklist));
t->next=NULL;
printf("請輸入m:");
scanf("%d",&m);
t->data=m;
q->next=t;
t->next=p;
}
}
printf("在值為%d的節點的前面插入一個值為%d的節點後的所有數據為\n",item,m);
for(j=0;j<N+1;j++)
{
r=r->next;
printf("%d ",r->data);
}
printf("\n");
return 1;
}
int main()
{
int i,item,k;
linklist *L,*r;
printf("單向鏈表的創建（包括初始化）與輸出\n");
L=Creatlist(L);
Judge(L);
printf("表中的數據為：");
r=L;
Input(L,11,r);
r=r->next;
Input(L,32,r);
r=r->next;
Input(L,17,r);
r=r->next;
Input(L,46,r);
r=r->next;
Input(L,9,r);
r=r->next;
printf("\n");
printf("在給定單鏈表的值為item的節點的前面插入一個值為m的節點\n");
printf("請輸入item:");
scanf("%d",&item);
Insert2(L,item);
return 0;
}
2. c語言單鏈表鏈表如何插入多個節點
如果已知一個節點指針pre和一個節點指針cur，要把cur插入到pre節點之後，很顯然要保證鏈表不會斷開而丟失後面的節點，要先把後面的節點指針（指向lat的指針）保存下來，即有cur->next = pre->next，然後把cur連接的一串鏈表連接到pre後面，即pre->next = cur;
上面介紹了，在一個節點之後插入節點的情況。這是通常的情況。如果要向一個鏈表的頭部插入節點，就只需要將新節點的下一個指針指向鏈表的頭指針即可。
在這種情況下，有兩點要注意：
1，鏈表是否為空鏈表
2，要插入的節點是不是空指針。
代碼實現：
//向單鏈表中插入一個節點(插入在鏈開始處)
//輸入參數：單鏈表的頭指針和要插入的節點指針
//輸出參數：無
//返回值：指向單鏈表的頭指針
SingleList* Insert(SingleList *head,SingleList *node)
{
if(node == NULL)
{
return head;
}
else if(head == NULL)
{
return node;
}
node->next = head;
head = node;
return head;
}
3. C語言單鏈表插入點（插入點插到最後）問題
#include <stdio.h>
#include <stdlib.h>
#define N 3
typedef struct node {
int number;
float wage;
struct node *link;
}stu;
stu *creat(int n) {
stu *h,*p,*s;
int i;
if((h = (stu*)malloc(sizeof(stu))) == NULL) {
printf("error.\n");
return NULL;
}
h->number = 0;
h->wage = 0;
h->link = NULL;
p = h;
for(i = 0;i < n;i++) {
if((s = (stu*)malloc(sizeof(stu))) == NULL) {
printf("error.\n");
return NULL;
}
p->link = s;
printf("input number and wage : ");
scanf("%d%f",&s->number,&s->wage);
p = s;
}
p->link = NULL;
return (h);
}
void list(stu *h) {
stu *q;
for(q = h->link;q != NULL;q = q->link) {
printf("%d\t%f\n",q->number,q->wage);
}
}
stu *insert(stu *h) {
stu *p,*s;
int number;
float wage;
p = h;
printf("input insert number and wage : ");
scanf("%d%f",&number,&wage);
if((s = (stu *)malloc(sizeof(stu))) == NULL) {
printf("error\n");
return NULL;
}
s->number = number;
s->wage = wage;
if(h->link->number > number) {
s->link = h->link;
h->link = s;
}
else {
while(p->link && p->link->number < number)
p = p->link;
if(p->link) {
s->link = p->link;
p->link = s;
}
else {
p->link = s;
s->link = NULL;
}
}
return h;
}
int main() {
stu *h = creat(N);
list(h);
insert(h);
list(h);
// del(h);
// list(h);
system("pause");
return 0;
}
4. C語言鏈表插入
char data[4]?
結點data是字元串?
抽時間幫你寫了一個
有什麼不合要求的地方你自己改改吧
#include <stdio.h>
#include <string.h>
#include <malloc.h>
typedef struct Lnode{
char *data;
struct Lnode *next;
}Lnode, *LinkList;
void CreateList(LinkList &L, char *buff)
{
int flag=0, j=0;
int len=strlen(buff);
L=(Lnode *)malloc(sizeof(Lnode));
L->next=NULL;
LinkList q=L;
for(int i=0;i<len;i+=4)
{
j=0;
LinkList p=(Lnode *)malloc(sizeof(Lnode));
q->next=p;
p->next=NULL;
p->data=(char *)malloc(sizeof(char)*5);
while(j<4)
{
p->data[j++]=buff[flag++];
}
p->data[4]='\0';
q=q->next;
}
}//初始化鏈表L
void TraverseList(LinkList L)
{
LinkList p;
p=L->next;
while(p)
{
printf("%s",p->data);
p=p->next;
}
printf("\n");
}//遍歷鏈表L
void InsertList(LinkList &L,int i,char *ins)
{
LinkList p=L;
int temp=0;
i/=4;
while(temp<i)
{
p=p->next;
temp++;
}
if(!p) printf("Insert Failed");
LinkList s=(Lnode *)malloc(sizeof(Lnode));
s->data=(char *)malloc(sizeof(char)*5);
strcpy(s->data, ins);
s->next=p->next;
p->next=s;
}//在單鏈表L的第i個元素繼續插於入ins
void main()
{
fflush(stdin);
char buff[100],ins[4];
int m;
printf("Plz type in the string:");
gets(buff);
LinkList L;
CreateList(L, buff);
printf("The linklist L is : ");
TraverseList(L);
//printf("%d", flag);
printf("where to insert (m):");
scanf("%d", &m);
printf("what to insert:");
fflush(stdin);
scanf("%s", &ins);
//gets(ins);
InsertList(L, m, ins);
TraverseList(L);
}
5. c語言數據結構單鏈表（頭插入法）
head=(LNode
*)malloc(sizeof(LNode));
這一句不要，沒啥用處，除非你head指向的節點也就是第一個節點的data不需要數據
head->next=NULL;這里修改為head=NULL;
讓head先指向NULL，也就是沒有節點
其實這個可以不要，再主函數中，先讓鏈表是空鏈表即可（即讓head=NULL）
head->data=data;
head->next=p->next;
head->next=p;
關鍵在這里
你仔細考慮一下，一般來說頭插法的head只是一個指針，不要對head指向的那個節點操作，對p操作完成後，讓head指過去即可
所以修改為
p->data=data;
//賦值過去，因為你現在申請了p的內存空間
p->next=head;
//把head指向的那個節點連接到p的後面，這樣完成頭插
//
這是head沒有用了，p成為鏈表的頭指針
head=p;
//head再指向這個鏈表的頭部，也就是p指向的節點，為下一次循環做准備
head=Createlist(head);//鏈表初始化
主函數中這樣不太好，建議不要重名
6. c語言鏈表插入知識
在順序表中查找元素、獲取表長非常容易，但是，插入或者刪除一個元素卻需要移動大量的元素；相反，在鏈表中插入或者刪除一個元素很方便，但查找元素，需要進行遍歷。因此，當所涉及的問題常常進行查找等操作，而插入、刪除相對較少時，適合採用順序表；當常常需要插入、刪除的時候，適合採用鏈表。
7. C語言單鏈表的插入（已給出函數和結構體）
NODE * insert_note(NODE * head,NODE * p,int i)
{
NODE *pb=head,*pf=NULL ;
int n=0;
if(head==NULL)//如果為空就建立，空間在傳入前申請好
{
head=p;
p->next=NULL;
}
else
{
for (;i>0;i--)
pb=pb->next;
pf=pb->next;
pb->next=p;
p->next=pf; //在表後插入
}
return head;
}
8. c語言鏈表插入法求解下列問題
根據題意：
一、鏈表創建：根據輸入的數字，動態創建任意多個節點插入鏈表。（題目規定n<=40，如不想使用malloc動態申請內存，需直接定義最大上限40個節點）。
二、鏈表排序：交換節點內容（不是地址），保留鏈表指針的值（*next的值）。
三、列印鏈表：利用鏈表指針遍歷鏈表。
四、對動態申請的鏈表地址空間釋放（在本程序中創建後程序就結束了，即使不寫free釋放，結束後也會釋放。但在復雜程序中調用創建，後續還有代碼，需像我代碼中寫函數動釋放不用的內存，避免浪費）。
下面是代碼：
#include <stdio.h>
#include <malloc.h>
typedef struct numStruct
{
int num;
struct numStruct *next;
}NST;
NST *insert2List(int num);//根據數字創建節點（動態），插入鏈表（首次自動生成頭節點），成功返回頭節點，失敗返回NULL。
void showList(NST *nsthead);//列印鏈表
void px(NST *nsthead);//鏈表排序
void freeList(NST *nsthead);//釋放鏈表內存
int main()
{
NST *nsthead=NULL;
int i=0,n=50,*nums=NULL;
while(n>40)
scanf("%d",&n);
nums=(int *)malloc(sizeof(int)*n);
if(!nums) return 1;
while(i<n)
scanf("%d",&nums[i++]);
i=0;
while(i<n)
nsthead=insert2List(nums[i++]);
px(nsthead);
showList(nsthead);
freeList(nsthead);
return 0;
}
void freeList(NST *nsthead)
{
NST *temp=NULL,*nst=NULL;
if(nsthead)
{
nst=nsthead->next;
while(nst!=NULL)
{
temp=nst;
nst=nst->next;
free(temp);
}
}
free(nsthead);
}
void showList(NST *nsthead)
{
if(nsthead)
while(nsthead->next!=NULL)
{
printf("%d ",nsthead->next->num);
nsthead=nsthead->next;
}
printf(" ");
}
void px(NST *nsthead)
{
NST *nt1=NULL,*nt2=NULL,ntTemp,*nextSave=NULL;
if(nsthead)
{
nt1=nsthead->next;
while(nt1)
{
nt2=nt1->next;
while(nt2)
{
if(nt1->num>nt2->num)
{
ntTemp=*nt1;
nextSave=nt1->next;
*nt1=*nt2;
nt1->next=nextSave;
nextSave=nt2->next;
*nt2=ntTemp;
nt2->next=nextSave;
}
nt2=nt2->next;
}
nt1=nt1->next;
}
}
}
NST *insert2List(int num)
{
static NST *nsthead=NULL,*nstTail=NULL;
NST *nstNew=NULL;
nstNew=(NST *)malloc(sizeof(NST));
if(!nstNew) return NULL;
nstNew->next=NULL;
nstNew->num=num;
if(!nsthead)
{
nsthead=(NST *)malloc(sizeof(NST));
if(!nsthead) return NULL;
nsthead->next=nstNew;
}
else
nstTail->next=nstNew;
nstTail=nstNew;
return nsthead;
}
9. C語言鏈表中插入一個數
p->next=(*h)->next意思p->next結點指向(*h)->next；即(*h)->next的值賦給p->next。
//就和a = b;是把b的值賦給a一樣
第一個函數中，h是鏈表的頭節點，即通過h可以順次訪問到鏈表中的其他所有後續節點；是每次生成一個p，再把p插入到h為頭節點的鏈表中的。
第二個函數是將q插入到h為頭節點的鏈表中的。是在值為x的節點後面插入值為y的q節點。注意：p=h->next; p實際指向的是鏈表中的第一個節點。