求写C语言 创建链表实例子。要最基本的 包括注释。

题目：创建固定长度的单向链表

程序分析：链表是亏好动态分配存储空间的链式存储结构，

其包括一个“头指针”变量，其中第0个结点称为整个链表的头结点，头结点中存放一个地址，该地址指向一个元素，头结点一般不存放具体数据，只是存放第一个结点的地址。

链表中销孝铅每一个元素称为“结点”，每个结点都由两部分组成：存放数据元素的数据域和存储直接后继存储位置的指针域。指针域中存储的即是链表的下一个结点存储位置，是一个指针。多个结点链接成一个链表。

最后一个结点的指针域设置为空(NULL)，作为链表的结束标志，表示它没有后继结点。

使用结构体变量作为链表中的结点，因为结构体变量成员可以是数值类型，字符类型，数组类型，也可以是指针类型，这样就可以使用指针类型成员来存放下一个结点的地址，使其它类型成员存放数据信息。

在创建列表时要动态为链表分配空间，C语言的库函数提供了几种函数实现动态开辟存储单元。

malloc()函数实现动态开辟存慎液储单元：

malloc函数原型为：void *malloc(unsigned int size)

     其作用是在内存的动态存储区中分配一个长度为size的连续空间，函数返回值是一个指向分配域起始地址的指针（类型为void）。如果分配空间失败（如，内存空间不足），则返回空间指针（NULL）

#include<stdio.h>

#include<malloc.h>

struct LNode

{

int data

struct LNode *next

}

/*上面只是定义了一个结构体类型，并未实际分配内存空间

只有定义了变量才分配内存空间*/

struct LNode *creat(int n)

{

int i

struct LNode *head,*p1,*p2

/*head用来标记链表，p1总是用来指向新分配的内存空间，

p2总是指向尾结点，并通过p2来链入新分配的结点*/

int a

head=NULL

for(i=1i<=ni++)

{

p1=(struct LNode *)malloc(sizeof(struct LNode))

/*动态分配内存空间，并数据转换为(struct LNode)类型*/

printf("请输入链表中的第%d个数：",i)

scanf("%d",&a)

p1->data=a

if(head==NULL)/*指定链表的头指针*/

{

head=p1

p2=p1

}

else

{

p2->next=p1

p2=p1

}

p2->next=NULL/*尾结点的后继指针为NULL(空)*/

}

return head/*返回链表的头指针*/

}

void main()

{

int n

struct LNode *q

printf("请输入链表的长度：/n")

scanf("%d",&n)

q=creat(n)/*链表的头指针(head)来标记整个链表*/

printf("/n链表中的数据：/n")

while(q)/*直到结点q为NULL结束循环*/

{

printf("%d ",q->data)/*输出结点中的值*/

q=q->next/*指向下一个结点*/

}

}

用模板类写的，很基础

#include<iostream>

#include<assert.h>

using namespace std

template<class T>class Link

template<class T>class List

{

public:

List()

List(const List<T>&source)

virtual~ List()

virtual void add(T value)

virtual void deleteAllValues()

T firstElement() const

virtual int includes(T value)const

int isEmpty() const

virtual void removeFirst()

List<T>* duplicate() const

protected:

Link<T>*ptrToFirstLink

//friend class listIterator<T>

}

template<class T>class Link

{

private:

Tvalue//存储数据

Link<T>* ptrToNextLink//吵毁者存储后继结点的指针

//表类内部使用的函数

Link(T LinkV, Link<T> *nextPtr)//构造

Link(const Link<T>&source)//拷贝构造

Link<T> *duplcate()const//复制

friend class List<T>//表类友元

//friend class ListIterator<T>//遍历器友元

public:

Link<T>* insert(T val)//插入

}

template<class T>Link<T>::Link(T val,Link<T>*nxt)

:value(val),ptrToNextLink(nxt)

{}

template<class T>Link <T>::Link(const Link<T>&source)

:value(source.value),ptrToNextLink(source.ptrToNextLink)

{}

template <class T>

Link<T>*Link<T>::duplcate() const

{

Link <T>*newLink

if(ptrToNextLink!=0)

newLink=new Link<T>(value ,ptrToNextLink->duplcate())

else

newLink=new Link<T>(value,0)

assert(newLink !=0)

return newLink

}

template <class T>List<T>::List():ptrToFirstLink(0)

{}

template <class T>int List<余州T>::isEmpty() const

{

return ptrToFirstLink==0

}

template<class T>void List<T>::add(T val)

{

ptrToFirstLink=new Link<T>(val,ptrToFirstLink)

assert(ptrToFirstLink!=0)

}

template<class T>T List<T>::firstElement() const

{

assert(ptrToFirstLink!=0)

return ptrToFirstLink->value

}

template<class T>void List<升薯T>::removeFirst()

{

assert(ptrToFirstLink!=0)

Link<T>*p=ptrToFirstLink

ptrToFirstLink=p->ptrToNextLink

delete p

}

template <class T>int List<T>::includes(T v) const

{

for(Link<T>* p=ptrToFirstLinkpp=p->ptrToNextLink)

if(v==p->value) return 1

return 0

}

template <class T>void List<T>::deleteAllValues()

{

Link<T>*next

for(Link<T>*p=ptrToFirstLinkp!=0p=next)

{

next=p->ptrToNextLink

p->ptrToNextLink=0

delete p

}

ptrToFirstLink=0

}

template <class T>List<T>*List<T>::duplicate()const

{

Lict<T>* newlist=new List<T>

assert(newlist!=0)

if(ptrToFirstLink)

newlist->ptrToFirstLink=ptrToFirstLink->duplicate

return newlist

}

template <class T>List<T>::List(const List<T>&source)

{

if(source.isEmpty())

ptrToFirstLink=0

else

{

Link<T>* firstLink=source.ptrToFirstLink

ptrToFirstLink=firstLink->duplicate()

}

}

template <class T>List<T>::~List()

{

deleteAllValues()

}

void main()

{

List<int> lst

for (int m=0m<10m++) lst.add(m)

for (m=0 !lst.isEmpty()&&m<5 m++)

{

cout<<lst.firstElement()<<" "

lst.removeFirst()

}

cout<<endl

}

---