⑴ c语言数据结构的问题，用尾插法建立链表
voidcreat(linklistL)//L为一级指针，也是头指针
{
intf=1;
node*s,*r;
r=L;
while(f){
s=(node*)malloc(sizeof(node));
scanf("%s",s->a);
if(s->a[0]!='^'){
r->next=s;
r=s;
}
else{
f=0;
free(s);//释放s
}
}
r->next=NULL;//对r设next为NULL
}
⑵ 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;
}
⑶ 求解C语言中尾插法建立链表的原理
没看懂你的代码，但尾插法的原理是很简单的，它就是两句话：
设r初始时指向头结点
设n为要输入结点的个数
下面是伪代码:
while(n>0)
{
p=动态为p分配内存
p->data=为当前结点赋值
r->next=p 令r的指针域指向新结点p
r=p;// 令r指向新结点的地址(方便下一次的结点继续成为r的后继,反复如此......直至n不大于0)
n--
}
它的核心就两句话 r->next=p和r=p
如果你依然未懂的话，你就拿一张白纸，拿只笔，在纸上模拟上面那两句话。相信你肯定会懂的。
⑷ 链表实现尾插法（C语言）
据个例子：
#include <stdio.h>
#define LEN sizeof(struct A)
#define NULL 0
struct A
{ int a;
struct A* next;
};
struct A* new() /*建立链表的函数，返回链表头指针*/
{ struct A *p1,*p2,*head;
head=p2=p1=(struct A*)malloc(LEN）；
scanf("%d",&p1->a;)
while(p2->a！=2155）/*以2155作为输入节点的结束标志*/
{p1=(struct A*)malloc(LEN);
scanf("%d",&p1->a);
p2->next=p1;
p2=p1;
}
p1->next=NULL;
return head;
}
⑸ C语言单向循环链表尾插法问题
建立单向循环链表的代码：
#include<stdio.h>
#include<stdlib.h>
typedefstruct_A{
intdata;
struct_A*next;
}A;
typedefA*IA;
voidcreateDoubleLink(IA*header){
intdata;
IAp;
printf("inputdataendwith-1:");
scanf("%d",&data);
while(data!=-1){
p=(IA)malloc(sizeof(A));
p->data=data;
if(*header==NULL){
*header=p;
(*header)->next=*header;
}
else{
IAq=*header;
while(q->next!=*header){
q=q->next;
}
q->next=p;
q->next->next=*header;
}
scanf("%d",&data);
}
}
voidprint(IAheader){
IAp=header;
if(header==NULL)return;
while(1){
printf("%d ",p->data);
if(p->next==header)break;
p=p->next;
}
printf(" ");
}
intmain()
{
IAheader=NULL;
createDoubleLink(&header);
print(header);
return0;
}
头结点的意思是链表的第一个节点，但这个节点不保存数据。
⑹ c语言单链表尾插法编译通过运行终止，这个写法哪里有问题
尾部插入，那么第一步要做的是遍历链表到结尾，然后创建节点插入；你的代码中没有看到遍历的过程，不知道从哪插呢！
⑺ 用c语言尾插法建立带头结点的单链表
EOF!=(scanf("%d",&x)是什么意思？把scanf("%d",&x）写在while语句的上面为什么不行？
这里是指输入成功的话，执行下面的大括号里面语句。
pre->next是指当前结点的前一个结点，这里用于交换位置的。你可以画个图来查看他们之间的联系，就会很清楚了
⑻ 用C语言编写链式存储结构下实现线性表的创建,插入,删除,按值查找
#include <stdio.h>
#include <stdlib.h>
typedef struct LNode{
int data; //链表数据
struct LNode* next; //链表指针
}LNode,*LinkList;
/*头插法-建立单链表*/
LinkList HeadCreate(LinkList la)
{
int num;
la=(LinkList)malloc(sizeof(LNode)); //建立头结点
la->next=NULL;
scanf("%d",&num);
while(num!=10)
{
LNode *p=(LinkList)malloc(sizeof(LNode));
p->data=num;
p->next=la->next;
la->next=p;
scanf("%d",&num);
}
return la;
}
/*尾插法-建立单链表*/
LinkList TailCreate(LinkList la)
{
int num;
la=(LinkList)malloc(sizeof(LNode));
la->next=NULL;
LinkList s,r=la;
scanf("%d",&num);
while(num!=10)
{
s=(LinkList)malloc(sizeof(LNode));
s->data=num;
r->next=s;
r=s;
scanf("%d",num);
}
r->next=NULL;
return la;
}
/*单链表遍历*/
void TravelList(LinkList la)
{
LinkList p=la->next;
while(p!=NULL)
{
printf("%d->",p->data);
p=p->next;
}
printf("\n");
}
/*单链表的按位查找*/
LinkList GetElem(LinkList la,int i)
{
int j=1;
LNode* p=la->next;
if(i<1)
return NULL;
while(p && j<i)
{
p=p->next;
j++;
}
return p;
}
/*单链表的按值查找*/
LinkList LocalElem(LinkList la,int e)
{
LNode* p=la->next;
while(p!=NULL && p->data!=e)
p=p->next;
return p;
}
/*单链表插入操作*/
bool InsertList(LinkList la,int i,int e)
{
//在la链表中的i位置插入数值e
int j=1;
LinkList p=la,s;
while(p && j<i)
{
p=p->next;
j++;
}
if(p==NULL)
return false;
if((s=(LinkList)malloc(sizeof(LNode)))==NULL)
return false;
s->data=e;
s->next=p->next;
p->next=s;
return true;
}
/*单链表删除操作*/
bool DeleteList(LinkList la,int i)
{
int j=1;
LinkList p=la,q;
while(p && j<i) //p指向第i-1个元素
{
p=p->next;
j++;
}
if(p==NULL || p->next==NULL) //表示不存在第i-1个和第i的元素
return false;
q=p->next;
p->next=q->next;
free(q);
return true;
}
/*单链表的表长*/
int LengthList(LinkList la)
{
int nLen=0;
LinkList p=la->next;
while(p)
{
p=p->next;
nLen++;
}
return nLen;
}
/*单链表逆置*/
LinkList Reserve(LinkList la)
{
if(la==NULL || la->next==NULL)
return la;
LinkList p=la->next,q=p->next,r=q->next;
la->next=NULL;
p->next=NULL;
while(r!=NULL)
{
q->next=p;
p=q;
q=r;
r=r->next;
}
q->next=p;
la->next=q;
return la;
}
int main()
{
LNode la;
LinkList p;
p=HeadCreate(&la); //头插法创建单链表
TravelList(p);
printf("%p\n",GetElem(p,1)); //获得第1个结点地址
InsertList(p,2,10); //在链表的第2个位置插入元素10
TravelList(p);
DeleteList(p,3); //删除链表的第3个元素
TravelList(p);
printf("%d\n",LengthList(p)); //获得链表长度
p=Reserve(p);
TravelList(p);
return 0;
}
//运行结果
//5 6 12 7 8 14 9 3 2 5 14 10 头插法创建链表
//14->5->2->3->9->14->8->7->12->6->5-> 显示链表
//00382490 第一个结点的地址
//14->10->5->2->3->9->14->8->7->12->6->5-> 插入元素值为10的结点
//14->10->2->3->9->14->8->7->12->6->5-> 删除第三个结点
//11 获得链表长度
//5->6->12->7->8->14->9->3->2->10->14-> 链表逆置
//Press any key to continue
这是我写的一个线性表链式存储的综合程序，包含了你所要的创建、删除、插入、按值查找的功能，还有一些额外的功能。下面加注释的是程序运行结果，你可以参考试着改改程序，让程序更加完美。希望对你有帮助，呵呵！
⑼ c语言采用头插法或尾插法建立链表，从键盘输入递增有序的数据建立链表
#include<stdio.h>
#include<stdlib.h>
/*定义链表结点*/
typedefstructst_node{
intvalue;
structst_node*next;
}node_t;
/*定义链表*/
typedefstruct{
node_thead;
node_t*tail;
}list_t;
/*插入到队列尾部*/
voidlist_push_back(list_t*l,intvalue){
node_t*t=(node_t*)malloc(sizeof(node_t));
t->value=value;
t->next=NULL;
l->tail->next=t;
l->tail=t;
}
/*有序地插入元素*/
voidlist_push_sort(list_t*l,intvalue){
/*找出小于或等于value的节点，插入到该节点前面*/
node_t*p=l->head.next,*last=&l->head,*t;
for(;p;last=p,p=p->next){
if(value<=p->value){
t=(node_t*)malloc(sizeof(node_t));
t->value=value;
t->next=p;
last->next=t;
return;
}
}
/*如果没有小于或等于value的节点，则直接插入到末尾*/
list_push_back(l,value);
}
/*使用数组初始化有序链表*/
voidlist_init(list_t*l,int*p,ints){
inti=0;
l->head.next=NULL;
l->tail=&l->head;
for(;i<s;++i){
list_push_sort(l,p[i]);
}
}
/*清空链表*/
voidlist_clear(list_t*l){
node_t*p=l->head.next,*t;
while(p){
t=p;
p=p->next;
free(t);
}
l->head.next=NULL;
l->tail=&l->head;
}
/*合并有序链表*/
voidlist_merge(list_t*l,list_t*r,list_t*o){
node_t*pl=l->head.next,*pr=r->head.next;
while(pl||pr){
if(pl&&pr){
if(pl->value<=pr->value){
list_push_back(o,pl->value);
pl=pl->next;
}else{
list_push_back(o,pr->value);
pr=pr->next;
}
}elseif(pl){
list_push_back(o,pl->value);
pl=pl->next;
}else{
list_push_back(o,pr->value);
pr=pr->next;
}
}
}
/*删除相同结点*/
voidlist_plicate_delete(list_t*l){
if(&l->head!=l->tail){
node_t*p=l->head.next,*last,*t;
intvalue=p->value;
last=p;
p=p->next;
while(p){
if(value==p->value){
t=p;
last->next=p->next;
p=p->next;
free(t);
}else{
value=p->value;
last=p;
p=p->next;
}
}
}
}
/*打印链表*/
voidlist_show(char*name,list_t*l){
node_t*p=l->head.next;
printf("%s:",name);
for(;p;p=p->next){
printf("%d,",p->value);
}
printf(" ");
}
/*主函数*/
voidmain(){
list_tlist1,list2,list3;
inta[]={10,4,6,12,1,8,14,10,14,6};
intb[]={7,11,6,1,13,5,1,14};
/*所有链表需要初始化后才能使用*/
list_init(&list1,a,sizeof(a)/sizeof(int));
list_init(&list2,b,sizeof(b)/sizeof(int));
list_init(&list3,NULL,0);
printf("初始值: ");
list_show("List1",&list1);
list_show("List2",&list2);
list_show("List3",&list3);
/*合并链表*/
list_merge(&list1,&list2,&list3);
printf("合并后: ");
list_show("List1",&list1);
list_show("List2",&list2);
list_show("List3",&list3);
/*去重复*/
list_plicate_delete(&list3);
printf("去重复后: ");
list_show("List1",&list1);
list_show("List2",&list2);
list_show("List3",&list3);
/*所有链表都需要释放空间*/
list_clear(&list1);
list_clear(&list2);
list_clear(&list3);
}
//这可是血汗钱啊.....
⑽ C语言链表尾插法建立，非常需要大家帮忙
你的代码看着不太习惯……而且……按说应该自己报错才对……
先说我觉得的核心：
addnode函数里，你while循环终止时，t是指向Null的，然后t直接就被指向了一个新开的空间，和你前面的链表完全没有联系……
改进：
1，加的时候应该判断一下，因为你建立头指针的时候，如果还没有元素，这个add的位置就应该是l->Next=(lnode *)malloc(sizeof(lnode))，如果已经有元素，那么需要找到末尾的那个元素(也就是t->Next==Null)，然后是t->Next=(lnode *)malloc(sizeof(lnode))
也就是按你目前改的话，addnode中需要：
void addnode(linklist *l, int x){
if((*l)->count==0)
{
(*l)->next=(lnode *)malloc(sizeof(lnode));
(*l)->next->NULL;
(*l)->data=x;
(*l)->count++;
return;
}
lnode *t=l->next;
while(t->next!=NULL) t=t->next;
t->next=(lnode*)malloc(sizeof(lnode));//一定先开启空间，有了下一个节点的地址，再指过去，不能t已经到空了，让t=，那是直接把t挪走，而不是让链表连接起来了
t->next->next=NULL;
t->next->data=x;
(*l)->count++;
return;
}
其实更建议定义一个新的函数叫创建节点，应该能让程序更清晰
lnode* createNode(int data)
{
lnode* node=(lnode*)malloc(sizeof(lnode));
node->data=data;
node->next=NULL;
return node;
}
这样的话，你的添加节点应该能更好理解，代码我不写了，逻辑为：
添加节点(链表l,数值x){
如果头指针下没有元素
{头指针下的元素指向一个新创建的元素(*l)->next=createNode(x);
头指针元素计数加1;
返回
}
声明新的节点指针t；
如果t不是最后一个元素(这里务必注意：条件应是t->next==NULL，而不是t==NULL)，让t指向其下一个节点并循环；
t的下一个节点指向一个新创建的指针(t->next=createNode(x);
l的计数加一；
}
PS：
linklist在声明的时候已经定义成了headnode的指针，为什么在初始化时候要(*l)=...呢？
l=(linklist *)malloc(sizeof(headnode))应该就好了吧，目的是开一个空间，并让l指过去