#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct student
{
int id;
int csn;
int csy;
char name[10];
} STU;
typedef struct node
{
STU date;
struct node *next;
}NODE;
void chushihualink(NODE *H)
{
H->next=NULL;
}
void xinzenglink(NODE *H,NODE *newstu)
{
while(H->next)
H=H->next;
H->next=newstu;
newstu->next=NULL;
}
void charulink(NODE *H,NODE *newstu,int pos)
{
int i;
for(i=0;i<pos;i++)
H=H->next;
newstu->next=H->next;
H->next=newstu;
}
void shuchulink(NODE *H)
{
while(H->next)
{
printf("姓名%s，学号%d，出生年月%d,%d\n",H->next->date.name,H->next->date.id,H->next->date.csn,H->next->date.csy);
H=H->next;
}
}
void xiugailink(NODE *H,NODE *oldstu,NODE *newstu)
{
while(H->next)
{
if(H->next->date.id==oldstu->date.id)
{
oldstu->date=newstu->date;
newstu->next=oldstu->next;
break;
}
H=H->next;
}
}
void shanchulink(NODE *H,NODE *oldstu)
{
while(H->next)
{
if(H->next->date.id==oldstu->date.id)
{
H->next=H->next->next;
break;
}
H=H->next;
}
}
NODE paixulink(NODE *H)
{
NODE *p,*q;
STU temp;
for(p=H;p->next!=NULL;p=p->next)
{
for(q=p->next;q->next!=NULL;q=q->next)
{
if(p->next->date.id>q->next->date.id)
{
temp=p->next->date;
p->next->date=q->next->date;
q->next->date=temp;
}
}
}
return *H;
}
int main() {
NODE *H;
NODE newstu1;
NODE newstu2;
NODE newstu3;
NODE newstu4;
NODE newstu5;
H=(NODE *)malloc(sizeof(NODE));
newstu1.date.id=101;
newstu1.date.csn=1997;
newstu1.date.csy=10;
newstu1.next=NULL;
strcpy(newstu1.date.name,"zhangsan");
newstu2.date.id=102;
newstu2.date.csn=1995;
newstu2.date.csy=12;
newstu2.next=NULL;
strcpy(newstu2.date.name,"lisi");
newstu3.date.id=103;
newstu3.date.csn=1999;
newstu3.date.csy=5;
newstu3.next=NULL;
strcpy(newstu3.date.name,"wangwu");
newstu4.date.id=104;
newstu4.date.csn=1994;
newstu4.date.csy=4;
newstu4.next=NULL;
strcpy(newstu4.date.name,"zhaoliu");
newstu5.date.id=105;
newstu5.date.csn=1991;
newstu5.date.csy=5;
newstu5.next=NULL;
strcpy(newstu5.date.name,"tianqi");
chushihualink(H);
xinzenglink(H,&newstu1);
xinzenglink(H,&newstu2);
xinzenglink(H,&newstu3);
charulink(H,&newstu4,2);
xiugailink(H,&newstu2,&newstu5);
paixulink(H);
shanchulink(H,&newstu5);
shuchulink(H);
}
B. 如何用C语言实现简单的链式存储结构
使用结构体：
typedef struct node{
int data;
struct node* next;
}Node;
就可以实现，以上是一个单链表的节点元素，每个节点的next指向下一个节点，就可以实现链式存储了。遇到其他类似的问题，可以根据需要设置相应的指针域。
C. 如何用C语言链表实现学生信息管理系统
你来我们学校里吧，我这里有，济南市，文化东路55号，
这里同学学C语主的每人都做了
D. 用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
这是我写的一个线性表链式存储的综合程序，包含了你所要的创建、删除、插入、按值查找的功能，还有一些额外的功能。下面加注释的是程序运行结果，你可以参考试着改改程序，让程序更加完美。希望对你有帮助，呵呵！
E. c语言怎么利用 顺序或链式结构实现中序线索化二叉树
线索化二叉树实质就是将二叉树中的空指针改成指向前驱后者后继的指针 从而确定二叉树的唯一性
而前驱后后继只能在遍历中才能确定 所以要对二叉树进行中序遍历的过程中进行线索化
中序线索化二叉树源码
#include "stdio.h"
#include "stdlib.h"
typedef enum piontertag{link,thread};
typedef struct bithrnode
{char data;
piontertag ltag,rtag;
struct bithrnode *lchild,*rchild;
}BithrNODE;
BithrNODE *BithrCreat();//先序递归建立二叉树
BithrNODE *InOrderThreading(BithrNODE *);//中序线索化二叉树
void InThreading(BithrNODE *);//中序遍历过程中线索化二叉树的具体过程
void InOrderTraverse(BithrNODE *);//中序线索化二叉树输出
BithrNODE *pre;
int main(void)
{
BithrNODE *a=BithrCreat();
a=InOrderThreading(a);
InOrderTraverse(a);
return 0;
}
BithrNODE *BithrCreat()
{
char x;
BithrNODE *p=NULL;
scanf("%c%*c",&x);
if(x=='#')
return NULL;
p=(BithrNODE *)malloc(sizeof(BithrNODE));
p->data=x;
p->ltag=p->rtag=link;
p->lchild=BithrCreat();
p->rchild=BithrCreat();
return p;
}
BithrNODE *InOrderThreading(BithrNODE *a)
{
BithrNODE *h=(BithrNODE *)malloc(sizeof(BithrNODE ));
if(!h)
exit(-1);
h->ltag=link;
h->rtag=thread;
h->rchild=h;
if(!a) h->lchild=h;
else
{
h->lchild=a;
pre=h;
InThreading(a);
pre->rtag=thread;
pre->rchild=h;
h->rchild=pre;
}
return h;
}
void InOrderTraverse(BithrNODE *a)
{
BithrNODE *p=a->lchild;
while(p!=a)
{
while(p->ltag==link)
p=p->lchild;
printf("%c ",p->data);
while(p->rtag==thread&&p->rchild!=a)
{
p=p->rchild;
printf("%c ",p->data);
}
p=p->rchild;
}
}
void InThreading(BithrNODE *a)
{
if(a)
{
InThreading(a->lchild);
if(!a->lchild)
{
a->ltag=thread;
a->lchild=pre;
}
if(!pre->rchild)
{
pre->rtag=thread;
pre->rchild=a;
}
pre=a;
InThreading(a->rchild);
}
}
F. 数据结构——链式队列，，，，用C语言实现
#include <stdio.h>
#include <stdlib.h>
struct node
{
int data;
struct node *next;
};
typedef struct node Node;
int ifnull(Node *tail)
{
if(tail->next==NULL)
return 0;
return 1;
}
Node *qinit(Node *tail)
{
tail=(Node *)malloc(sizeof(Node));
tail->data=0;
tail->next=NULL;
return tail;
}
void push(Node *tail,int data)
{
if(tail==NULL)
{
perror("error!");
return;
}
Node *tmp=NULL;
if(ifnull(tail)==0)
tmp=tail;
else
tmp=(Node *)malloc(sizeof(Node));
tmp->data=data;
tmp->next=tail->next;
tail->next=tmp;
tail=tmp;
}
void pop(Node *tail)
{
if(tail==NULL)
{
perror("error!");
return;
}
if(ifnull(tail)==0)
printf("queue is empty!");
if(tail->next==tail)
{
free(tail);
tail=NULL;
return;
}
Node *tmp=tail->next;
while(1)
{
if(tmp->next==tail)
{
Node *n=tail;
tail=tmp;
tail->next=n->next;
free(n);
break;
}
tmp=tmp->next;
}
}
Node *getdata(Node *tail,int *data)
{
if(tail==NULL)
{
perror("error!");
return;
}
if(ifnull(tail)==0)
{
printf("queue is empty!");
return;
}
if(tail->next==tail)
{
*data=tail->data;
tail->data=0;
tail->next=NULL;
return tail;
}
Node *tmp=tail->next;
while(1)
{
if(tmp->next==tail)
{
Node *n=tail->next;
*data=tail->data;
free(tail);
tail=tmp;
tail->next=n;
break;
}
tmp=tmp->next;
}
return tail;
}
int main()
{
Node *tail=NULL;
tail=qinit(tail);
if(ifnull(tail))
printf("not null\n");
else
printf("is null\n");
int a[10]={0};
int i=1;
for(i=1;i<=10;i++)
push(tail,i);
for(i=0;i<10;i++)
{
tail=getdata(tail,&a[i]);
printf("%d,",a[i]);
}
printf("\n");
free(tail);
return 0;
}
G. c语言 建立线性表 链式 请写出代码
#include<stdio.h>
#include<stdlib.h>
typedef char elemtype;
typedef struct dnode
{elemtype data;
struct dnode *prior;
struct dnode *next;
}dlinklist;
void displist(dlinklist *L);
int listlength(dlinklist *L);
void list (void);
void initlist (dlinklist *&L);
void destorylist (dlinklist *L);
int listempty(dlinklist *L);
void listdelete (dlinklist *L,int i,elemtype &e);
void getelem (dlinklist *L,int i, elemtype &e);
int locateelem(dlinklist *L,elemtype e);
int listinsert (dlinklist *L,int i, elemtype e);
#include "head.h"
int length;
#include "head1.h"
int main (void)
{char ch;
dlinklist *L;
elemtype e;
int i;
while(1)
{list();
ch=getchar();getchar();
switch(ch)
{case '0': exit(0);
case '1': initlist(L);break;
case '2': destorylist(L);break;
case '3': printf("The length is %d\n",listlength(L));break;
case '4': if(listempty(L)) printf("表不空！\n");
else printf("表空！\n");break;
case '5': printf("请输入要取的元素的序号(1-%d)\n",length);scanf("%d",&i);getchar();
if(i>length)printf("只有%d个元素\n",length);
else if(length==0) printf("空表！\n");
else {getelem(L,i,e);printf("第%d个元素为%c\n",i,e);}break;
case '6': printf("请输入要找的元素\n"); scanf("%c",&e);getchar();i=locateelem(L,e);
if(i==0) printf("未找到！\n");
else printf("%c为第%i个元素\n",e,i);break;
case '7': printf("请输入要插入的元素及其序号(1-%d)\n",length+1);
scanf("%c%d",&e,&i);getchar();
if(listinsert(L,i,e))
printf("插入成功！\n");
else printf("插入失败！\n");break;
case '8': if(!listempty(L)) printf("空表\n");
else displist(L);break;
case '9': printf("请输入要删除的元素的序号:\n"); scanf("%d",&i);getchar();
if (i>length) printf("只有%d个元素!\n",length);
listdelete(L,i,e); printf("删除的元素为%c\n",e); break;
default: printf("输入错误！请重新输入\n");
}
}
return 0;
}
#include <stdio.h>
void list (void)
{printf("***************************************\n");
printf("1: 初始化链表 2: 释放链表\n");
printf("3: 求元素个数 4: 链表判空\n");
printf("5: 取第i 元素 6: 找元素e \n");
printf("7: 插入元素e 8: 输出链表\n");
printf("9: 删除第i 元 0: 退出程序\n");
printf("***************************************\n");
printf(" 请在上述功能中选择(0-9):");
}
#include"head.h"
extern int length;
void destorylist (dlinklist *L)
{ dlinklist *p=L->next;
if (length!=0)
{while(p!=L)
{L->next=p->next;
p->next->prior=L;
free(p);p=L->next;
}
length=0;
}
}
void displist(dlinklist *L)
{dlinklist *p=L->next;
while(p!=L)
{printf("%c ",p->data); p=p->next;}
printf("\n");
}
void getelem (dlinklist *L,int i, elemtype &e)
{int j=1;dlinklist *p=L->next;
while(p!=L&&j<i)
{p=p->next;j++;}
e=p->data;
}
extern int length;
void initlist (dlinklist *&L )
{
L=(dlinklist *)malloc(sizeof(dlinklist));
if(!L)
printf("初始化失败！\n");
else
{length=0;L->next=L->prior=L;}
}
void listdelete (dlinklist *L,int i,elemtype &e)
{dlinklist *p=L->next;
int j=1;
while(p!=L&&j<i)
{p=p->next;j++;}
if(j==i)
{p->prior->next=p->next;
p->next->prior=p->prior;
e=p->data;free(p);
length--;}
}
int listempty(dlinklist *L)
{
int i=0;
dlinklist *p=L->next;
while(p!=L)
{p=p->next;i++;}
return i;
}
int listinsert (dlinklist *L,int i, elemtype e)
{dlinklist *p=L->next,*q;int j=1;
while(p!=L&&j<i)
{p=p->next;j++;}
if(j==i)
{q=(dlinklist *)malloc(sizeof(dlinklist));
if(!q) return 0;
q->data=e; length++;
q->prior=p->prior;
p->prior->next=q;
q->next=p;
p->prior=q;
return 1;
}
else return 0;
}
int listlength(dlinklist *L)
{return length;
}
int locateelem(dlinklist *L,elemtype e)
{dlinklist *p=L->next;
int i=1;
while(p!=L&&p->data!=e)
{p=p->next;i++;}
if(p->data!=e)return 0;
else return i;
}
H. 关于C语言 数据结构中链式结构的问题
#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
typedef struct Dian
{
int data;
struct Dian * pnext;
}DIAN,*PDIAN;
void show(PDIAN head)
{
PDIAN p=head->pnext;
while (p)
{
printf("%d ",p->data);
p=p->pnext;
}
}
PDIAN creat_list();
//void traverse_list(PDIAN pHead);
void add_list(PDIAN phead,int val);
void main()
{
PDIAN phead=NULL;
phead=creat_list();
add_list(phead,5);
show(phead);
//traverse_list(phead);
}
PDIAN creat_list()
{
PDIAN phead=(PDIAN)malloc(sizeof(DIAN));
if(phead==NULL)
{
printf("分配内存失败，程序关闭！\n");
exit(-1);
}
PDIAN pend=(PDIAN)malloc(sizeof(DIAN));
printf("请输入添加数据:");
scanf("%d",&pend->data);
phead->pnext=pend;
pend->pnext=NULL;
return phead;
}
//往链表中添加元素
void add_list(PDIAN phead,int val)
{
PDIAN p=phead;
while(p->pnext!=NULL)
{
p=p->pnext;
}
PDIAN pnew=(PDIAN)malloc(sizeof(DIAN));
if(pnew == NULL)
{
printf("分配内存失败，程序关闭！\n");
exit(-1);
}
pnew->data=val;
p->pnext=pnew;
pnew->pnext=NULL;
}
I. c语言！！！程序设计:建立一个学生信息链表,包括学号,姓名,成绩.(实现添加,删除,查询,排序,平均)
代码如下：
/*用c语言链表编写一个学生信息系统程序，要求输出学生的学号，姓名，性别，学号，姓名，成绩(实现添加，删除，查询,排序，平均)*/
#include <stdio.h>
#include <iostream>
#include <string.h>
#include <stdlib.h>
using namespace std;
const int n=5;
/*
* nodeEntry : 节点数据类型
* nodeADT : 节点结构
* linkADT : 链表结构
*/
typedef struct Student
{
int num;
char name[30];
char sex;
float score1;//语文
float score2;//数学
float score3;//英语
//struct Student *next;
}Student;
typedef struct linkCDT {
nodeADT head;
}*linkADT;
/*
* InitLink : 初始化链表
* CreateNode : 创建节点
* AppendLink : 添加数据
*/
nodeADT CreateNode(Student entry) {
nodeADT p=(nodeADT)malloc(sizeof*p);
p->entry=entry,p->next=0;
return p;
}
/*
SortLink : 排序链表
//按学号排序
void SortLinkID(linkADT link) {
nodeADT pHead,pRear,p,tp;
if (!link) return;
for (pHead=link->head,pRear=0;pHead;pHead=pHead->next) {
for (tp=pHead,p=pHead->next;p;tp=p,p=p->next)
if (pHead->entry.num>=p->entry.num)
tp->next=p->next,p->next=pHead,pHead=p,p=tp;
if (!pRear) link->head=pHead;
else pRear->next=pHead;
pRear=pHead;
}
//按英语成绩排序
void SortLinkEnglish(linkADT link) {
nodeADT pHead,pRear,p,tp;
if (!link) return;
for (pHead=link->head,pRear=0;pHead;pHead=pHead->next) {
for (tp=pHead,p=pHead->next;p;tp=p,p=p->next)
if (pHead->entry.score3>=p->entry.score3)
tp->next=p->next,p->next=pHead,pHead=p,p=tp;
if (!pRear) link->head=pHead;
else pRear->next=pHead;
pRear=pHead;
}
}
//按姓名的字典序进行排序
void SortLinkName(linkADT link) {
nodeADT pHead,pRear,p,tp;
if (!link) return;
for (pHead=link->head,pRear=0;pHead;pHead=pHead->next) {
for (tp=pHead,p=pHead->next;p;tp=p,p=p->next)
if (pHead->entry.name[0]>=p->entry.name[0])
tp->next=p->next,p->next=pHead,pHead=p,p=tp;
if (!pRear) link->head=pHead;
else pRear->next=pHead;
pRear=pHead;
}
}
//按姓名的长度进行排序
void SortLinkNameLength(linkADT link) {
nodeADT pHead,pRear,p,tp;
if (!link) return;
for (pHead=link->head,pRear=0;pHead;pHead=pHead->next) {
for (tp=pHead,p=pHead->next;p;tp=p,p=p->next)
if (strlen(pHead->entry.name)>=strlen(p->entry.name))
tp->next=p->next,p->next=pHead,pHead=p,p=tp;
if (!pRear) link->head=pHead;
else pRear->next=pHead;
pRear=pHead;
}
循环链表是与单链表一样
是一种链式的存储结构，所不同的是，循环链表的最后一个结点的指针是指向该循环链表的第一个结点或者表头结点，从而构成一个环形的链。
循环链表的运算与单链表的运算基本一致。所不同的有以下几点：
1、在建立一个循环链表时，必须使其最后一个结点的指针指向表头结点，而不是象单链表那样置为NULL。此种情况还使用于在最后一个结点后插入一个新的结点。
2、在判断是否到表尾时，是判断该结点链域的值是否是表头结点，当链域值等于表头指针时，说明已到表尾。而非象单链表那样判断链域值是否为NULL。
以上内容参考：网络-链表
J. c语言编程 关于顺序存储与链式存储
<p></p>
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
struct
node
{
int
data;
node
*next;
};
node
*create(int
a[],int
len)
{
int
i;
node
*head=new
node;
head->data=a[0];
node
*p=head;
node
*q;
for(i=1;i<len;i++)
{
q=new
node;
q->data=a[i];
p->next=q;
p=q;
}
p->next=NULL;
return
head;
}
node
*
insert(node
*head,int
k)
{
node
*temp=new
node;
temp->data=k;
temp->next=head;
head=temp;
return
head;
}
node
*dele(node
*head,int
m)
{
int
i;
node
*p=head;
node
*x=new
node;
node
*y=new
node;
if(m==1)
{
node
*q=head;
head=head->next;
free(q);
}
else
{
for(i=1;i<m;i++)
{
x=p;
p=p->next;
y=p->next;
}
x->next=y;
free(p);
}
return
head;
}
void
main()
{
int
a[10]={1,2,3,4,5,6,7,8,9,10};
int
len=10;
node
*head=new
node;
head=create(a,len);
node
*p=head;
printf("原数组为：");
while(p!=NULL)
{
printf("%d
",p->data);
p=p->next;
}
printf("\n输入要插入的元素：");
int
k;
scanf("%d",&k);
head=insert(head,k);
p=head;
printf("增加元素后的数组为：");
while(p!=NULL)
{
printf("%d
",p->data);
p=p->next;
}
printf("\n要删除的元素位置为：");
int
m;
scanf("%d",&m);
head=dele(head,m);
p=head;
printf("删除元素后的数组为：");
while(p!=NULL)
{
printf("%d
",p->data);
p=p->next;
}
}<p>此处为链表实现的方式，链表的好处在于内存不必连续，并且顺序存储
</p>
<p>顺序存储结构的特点是：连续的内存，随机存储。</p>