c语言链表输出的子函数 c语言链表的输入

请帮我用C语言写一个创建链表的代码，创建链表的关键部分代码单独写成一个子函数。

struct stu

创新互联成都企业网站建设服务，提供成都网站建设、网站制作网站开发,网站定制,建网站,网站搭建,网站设计,成都响应式网站建设公司,网页设计师打造企业风格网站,提供周到的售前咨询和贴心的售后服务。欢迎咨询做网站需要多少钱:028-86922220

{

char A[10];

char E[4];

char C[14];

char D[30];

struct stu*B;

};

struct stu *creat(struct stu*head,char c) //功能1:创建链表

{

while(c-'y'==0||c-'Y'==0)

{

printf("请输入姓名，性别，电话号码，e-mail地址\n");

head=insert(head);

printf("是否继续输入Y/N\n");getchar();

scanf("%c",c);system("cls");

}

if(c-'n'==0||c-'N'==0)

return head;

else

{

printf("是否继续输入Y/N\n");

getchar();

scanf("%c",c);

system("cls");

return (creat(head,c));

}

}

C语言编程——单链表的建立与维护，要求：由主函数调用单链表的建立、元素插入、删除和输出子函数，谢了

link *creat(int n) //链表建立 n为长度

{

link *p,*p0;

top=(link*)malloc(sizeof(link));

printf("输入数据 ");

scanf("%d",top-n);

top-next=NULL;

p0=top;

while(--n)

{

p=(link*)malloc(sizeof(link));

printf("输入数据 ");

scanf("%d",p-n);

p0-next=p;

p-next=NULL;

p0=p;

}

return top;

}

void inlink(int n,link *p0,link *p) //插入 p q之间

{

link *r;

r=(link*)malloc(sizeof(link));

r-n=n;

r-next=p;

p0-next=r;

p0=r;

}

void printl(link *head) //输出

{

link *p0,*p;

p=head;

while(p!=NULL)

{

p0=p;

printf("%d\n",p-n);

p=p-next;

}

}

void remov(link *p0,link *p) 删除

{

p0-next=p-next;

free(p);

}

C语言链表输出函数功能? 求解答! 请问有些什么功能?

链表分类型有:单链表、双链表、单向环形链表、双向环形链表。

单链表:只有一个头节点为入口，并且每一个节点只有一个单向地址指向下一个节点，简单的说在后一个节点无法返回上一个节点。

双链表:有头节点和尾节点作为入口，每一个节点有两个地址，一个指向前一个节点，一个指向后一个节点。解决了单链表无法返回前一个节点的问题。

单向环形链表:这是一个特殊的单链表，这个链表是把它的最后一个节点地址指向首节点的入口处。如果它要查找前一个节点的时候需要，转回首节点然后才能到达前一个节点。

双向环形链表:顾名思义，构成环形结构的双向链表。

C语言：编写一个输出考生链表的函数print()

// PList.cpp : Defines the entry point for the console application.

//

#include "stdafx.h"

#include "stdlib.h"

struct node

{

int data;

struct node *next;

};

int initList(node *h)

{

h-next=NULL;

return 1;

}

int creatList(node *h)

{

node *p,*s;

int x;

p=h;

for(int i=0;i999;i++)

{

scanf("%d",x);

if(x==0)

{

printf("finish creat List!\n");

p-next=NULL;

return 1;

}

s=(node*)malloc(sizeof(node));

s-data=x;

p-next=s;

p=s;

printf("ok!\n");

}

p-next=NULL;

return 1;

}

int insertsl(node *h,int i,int x)

{

node *p,*t;

int j;

p=h;j=0;

while(p!=NULL ji-1)

{

p=p-next;

j++;

}

if(j!=i-1)

{

printf("i is invalid");

return -1;

}

t=(node*)malloc(sizeof(node));

t-data=x;

t-next=p-next;

p-next=t;

return 1;

}

int deletesl(node *h,int i)

{

node *p,*s;

int j;

p=h;j=0;

while(p-next!=NULL ji-1)

{

p=p-next;

j++;

}

if(j!=i-1)

{

printf("i is invalid");

return -1;

}

s=p-next;

p-next=s-next;

free(s);

return 1;

}

int ShowList(node* TList)

{

node *pList;

pList=TList;

pList=pList-next;

while(pList-next!=NULL)

{

printf("%d ",pList-data);

pList=pList-next;

}

printf("\n");

printf("Print Finish!\n");

return 1;

}

int main()

{

node nList,*pList;//定义一个链表

int nT,nP;

pList=nList;//将链表的地址付给指针

if(initList(pList)==1)//初始化链表

printf("Init success!\n");

else

{

printf("Init error!\n");

return -1;

}

creatList(pList);//创建链表

for(int i=0;i9999;i++)

{

scanf("%d %d",nP,nT);

if(nP==9999)//若输入的nP=9999，则进行链表的输出操作

{

ShowList(pList);

}

if(nP0)//若输入的nP0,则进行删除操作

{

if(deletesl(pList,nT)==1)//删除,nT为要删除的节点

{

printf("Delet list number %d success\n",nT);

continue;

}

else

{

printf("error!\n");

continue;

}

}

if(nP0)

{

if(insertsl(pList,nP,nT)==1)//若nP0,则进行插入操作

printf("Insert success!\n");

else

{

printf("Insert error!\n");

continue;

}

}

}

return 1;

}

这个是个链表 你改下

C语言：链表的常用操作，完成下列子函数，并写主函数调用。

const int NULL =0;

template class T

struct Node

{

T data; //数据域

struct Node T * next; //指针域，在这里T可省略

};

template class T

class LinkList

{

public:

LinkList(){first = new Node T; first-next = NULL;}//无参构造函数

LinkList(T a [], int n);//有参构造函数，使用含有n个元素的数组a初始化单链表

~LinkList(); //析构函数

int GetLength(); //获取线性表的长度

Node T * Get(int i); //获取线性表第i个位置上的元素结点地址

int Locate (T x); //查找线性表中值为x的元素，找到后返回其位置

void Insert (int i, T x);//在线性表的第i个位置上插入值为x的新元素

T Delete(int i); //删除线性表第i个元素，并将该元素返回

void PrintList(); //按次序遍历线性表中的各个数据元素

Node T * GetFirst(){return first;}

private:

Node T * first; //头指针

};

#include "linklist.h"

#include "iostream"

using namespace std;

/*

template class T

LinkListT::LinkList(T a [], int n) //头插法建立单链表

{

first = new Node T;

first -next = NULL; //构造空单链表

for (int i=n-1;i=0;i--)

{

Node T * s = new Node T;//①建立新结点

s-data = a[i]; //②将a[i]写入到新结点的数据域

s-next = first-next; //③修改新结点的指针域

first-next = s; //④修改头结点的指针域，将新结点加入到链表中

}

}

*/

template class T

LinkListT::LinkList(T a [], int n) //尾插法建立单链表

/*

① 在堆中建立新结点：Node T * s = new Node T;

② 将a[i]写入到新结点的数据域：s-data = a[i];

③ 将新结点加入到链表中： r-next = s;

④ 修改尾指针：r = s;

*/

{

first = new Node T;

Node T * r = first;

for (int i=0;in;i++)

{

Node T * s = new Node T;//①建立新结点

s-data = a[i]; //②将a[i]写入到新结点的数据域

r-next = s; //③将新结点加入到链表中

r = s; //④修改尾指针

}

r-next = NULL; //终端结点的指针域设为空

}

template class T

LinkListT::~LinkList() //析构函数

{

Node T * p = first; //初始化工作指针p

while (p) //要释放的结点存在

{

first = p; //暂存要释放的结点

p = p - next; //移动工作指针

delete first; //释放结点

}

}

template class T

Node T * LinkListT::Get(int i) //获取线性表第i个位置上的元素

{

Node T * p = first - next; //初始化工作指针

int j = 1; //初始化计数器

while ( p j != i ) //两个条件都满足，则继续循环

{

p = p - next; //工作指针后移

j++;

}

if (!p) throw "查找位置非法"; //工作指针已经为空

else return p; //查找到第i个元素

}

template class T

int LinkListT::Locate (T x) //查找线性表中值为x的元素，找到后返回其位置

{

Node T * p = first -next; //初始化工作指针

int j=1;

while (p)

{

if (p-data == x) return j; //找到被查元素，返回位置

p = p-next;

j++;

}

return -1; //若找不到，返回错误标识-1

}

template class T

void LinkListT::Insert (int i, T x)//在线性表的第i个位置上插入值为x的新元素

{

Node T * p = first; //初始化工作指针

if (i != 1) p = Get(i-1); //若不是在第一个位置插入，得到第i-1个元素的地址。

Node T * s = new Node T;//建立新结点

s-data = x;

s-next = p-next;

p-next = s; //将新结点插入到p所指结点的后面

}

template class T

T LinkListT::Delete(int i) //删除线性表第i个元素，并将该元素返回

{

Node T * p = first; //初始化工作指针

if (i != 1) p = Get(i-1); //若不是在第一个位置插入，得到第i-1个元素的地址。

Node T * q = p-next;

p-next = q-next;

T x = q-data;

delete q;

return x;

}

template class T

void LinkListT::PrintList() //按次序遍历线性表中的各个数据元素

{

Node T * p = first-next ; //初始化工作指针

while (p){

cout p-data endl;

p = p- next;

}

}