顺序表，头结点链表，头指针链表，头结点循环链表

链表(Linked list)是一种常见的基础数据结构，是一种线性表，但是并不会按线性的链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。 相比于线性表顺序结构，操作复杂。由于不必须按顺序存储，链表在插入的时候可以达到O(1)的复杂度，比另一种线性表顺序表快得多，但是查找一个节点或者访问特定编号的节点则需要O(n)的时间，而线性表和顺序表相应的时间复杂度分别是O(logn)和O(1)。

顺序表

main.c

#include <stdio.h>
#include "SeqList.h"


int main1()
{
// 创建顺序表
SeqList *s = Create_List();
if (s == NULL)
{
printf ("创建失败\n");
return -1;
}

printf ("创建成功\n");

// 插入数据
int i;
for (i = 0; i < 20; i++)
{
Insert_Last(s, i);
}
#if 0
for (i = 0; i < 20; i++)
{
Insert_Head(s, i);
}
if (Insert_Pos(s, s->len, 1000) == FALSE)
{
printf ("插入失败");
}
Display(s);

SeqData data;
GetData(s, 5, &data);
printf ("%d\n", data);

int index;
if (FindData(s, 100, &index) == FALSE)
{
printf ("没有该元素\n");
}
else
printf ("index = %d\n", index);




if (Delete_Pos(s, 5) == FALSE)
{
printf ("删除失败\n");
}
if (Delete_Data(s, 15) == FALSE)
{
printf ("删除失败\n");
}
#endif
//Reverse_List(s);

Display(s);
Destroy(s);
s = NULL;
printf ("销毁成功\n");

return 0;
}


int main()
{
// 创建顺序表
SeqList *s1 = Create_List();
if (s1 == NULL)
{
printf ("创建失败\n");
return -1;
}

SeqList *s2 = Create_List();
if (s2 == NULL)
{
printf ("创建失败\n");
return -1;
}

int i;
for (i = 0; i < 20; i += 2)
{
Insert_Last(s1, i);
}

for (i = 1; i < 40; i += 2)
{
Insert_Last(s2, i);
}



SeqList *s3 = Merge_List(s1, s2);
printf ("s1: \n");
Display(s1);

printf ("s2: \n");
Display(s2);

printf ("s3: \n");
Display(s3);

return 0;
}




SeqList.c

#include "SeqList.h"
#include <stdlib.h>
#include <stdio.h>


SeqList *Create_List()
{
// 创建一个顺序表
SeqList* s = (SeqList*)malloc(sizeof(SeqList)/sizeof(char));
if (s == NULL)
{
return NULL;
}

// 初始化顺序的成员
// 为顺序表分配存储空间
s->list = (SeqData *)malloc(sizeof(SeqData)/sizeof(char)*INIT_SIZE);
if (s->list == NULL)
{
free(s);  // 创建存储空间失败，先释放顺序表结点
return NULL;
}
s->max_len = INIT_SIZE;
s->len = 0;

return s;
}


void Destroy(SeqList *s)
{
if (s == NULL)
return;

// 先释放存储空间
free (s->list);

// 释放顺序表
free (s);
}


int AgainMalloc(SeqList *s)
{
if (s == NULL)
return FALSE;

// 新申请空间的字节数
int new_size = sizeof(SeqData)/sizeof(char)*(INIT_SIZE + INCRESS_SIZE);
SeqData* tmp = (SeqData*)realloc(s->list, new_size);
if (tmp == NULL)
{
return FALSE;
}
s->list = tmp;
s->max_len += INCRESS_SIZE;



return TRUE;
}


int Insert_Last(SeqList *s, SeqData data)
{
if (s == NULL)
{
return FALSE;
}

// 检测顺序表是否存满
if (s->len == s->max_len)
{
// 扩展空间
if (AgainMalloc(s) != TRUE)
{
return FALSE;
}
}


// 插入数据
s->list[s->len] = data;
s->len++;

return TRUE;
}


int Insert_Head(SeqList *s, SeqData data)
{
if (s == NULL)
return FALSE;

// 检测顺序表是否存满
if (s->len == s->max_len)
{
if (AgainMalloc(s) != TRUE)
{
return FALSE;
}
}

// 进行移位
int i;
for (i = s->len-1; i >= 0; i--)
{
s->list[i+1] = s->list[i];
}

s->list[0] = data;
s->len++;


return TRUE;
}


int Insert_Pos(SeqList *s, int pos, SeqData data)
{
if (s == NULL || pos < 0 || pos > s->len)
return FALSE;

// 检测顺序表是否存满
if (s->len == s->max_len)
{
if (AgainMalloc(s) != TRUE)
{
return FALSE;
}
}

// 进行移位
int i;
for (i = s->len-1; i >= pos; i--)
{
s->list[i+1] = s->list[i];
}

s->list[pos] = data;
s->len++;


return TRUE;
}


int GetData(SeqList *s, int pos, SeqData *x)
{
if (s == NULL || pos < 0 || pos >= s->len || x == NULL)
return FALSE;

*x = s->list[pos];

return TRUE;
}


int FindData(SeqList *s, SeqData data, SeqData *x)
{
if (s == NULL || x == NULL)
return FALSE;

int i;
int flag = 0;
for (i = 0; i < s->len; i++)
{
if (s->list[i] == data)
{
*x = i;
flag = 1;
break;
}
}
if (flag == 0)
return FALSE;

return TRUE;
}


int Delete_Pos(SeqList *s, int pos)
{
if (s == NULL || pos < 0 || pos >= s->len)
{
return FALSE;
}

// 移动元素
int i;
for (i = pos; i < s->len-1; i++)
{
s->list[i] = s->list[i+1];
}

s->len--;

return TRUE;
}




int Delete_Data(SeqList *s, SeqData data)
{
if (s == NULL)
return FALSE;

int index = -1;
if (FindData(s, data, &index) == FALSE)
return FALSE;

return Delete_Pos(s, index);
}


int Reverse_List(SeqList *s)
{
if (s == NULL)
return FALSE;

int min = 0;
int max = s->len - 1;
SeqData tmp;
while (min < max)
{
tmp = s->list[min];
s->list[min++] = s->list[max];
s->list[max--] = tmp;
}

return TRUE;
}


SeqList * Merge_List(SeqList *s1, SeqList *s2)
{
if (s1 == NULL || s2 == NULL)
return NULL;

SeqList* s3 = (SeqList*)malloc(sizeof(SeqList)/sizeof(char));
if (s3 == NULL)
return NULL;

// 为s3分配存储空间
int size = sizeof(SeqData)/sizeof(char)*(s1->len + s2->len);
s3->list = (SeqData*)malloc(size);
s3->len  = s1->len + s2->len;
s3->max_len = s3->len;

int i = 0;     // 遍历 s1
int j = 0;     // 遍历 s2
int k = 0;     // 遍历 s3

while (i < s1->len && j < s2->len)
{
if (s1->list[i] < s2->list[j])
{
s3->list[k++] = s1->list[i++];
}
else
{
s3->list[k++] = s2->list[j++];
}
}

while (i < s1->len)
{
s3->list[k++] = s1->list[i++];
}

while (j < s2->len)
{
s3->list[k++] = s2->list[j++];
}

return s3;
}


void Display(SeqList *s)
{
if (s == NULL)
return;

int i;
int count = 0;
for (i = 0; i < s->len; i++)
{
if (i % 4 == 0)
printf ("\n");

printf ("%8d", s->list[i]);
}

printf ("\n");
}




SeqList.h

#ifndef __SEQLIST_H__
#define __SEQLIST_H__


#define FALSE  -1
#define TRUE    0


#define INIT_SIZE     100
#define INCRESS_SIZE  20  




typedef int SeqData;


// 顺序表结构
typedef struct _seqList
{
SeqData *list;  // 指向存储空间的指针
int max_len;       // 保存存储空间最大长度
int len;           // 保存当前使用的长度
}SeqList;




// 创建顺序表
SeqList *Create_List();


// 销毁顺序表
void Destroy(SeqList *s);


// 插入数据：尾插法
int Insert_Last(SeqList *s, SeqData data);


// 插入数据：头插法
int Insert_Head(SeqList *s, SeqData data);


// 插入数据：在下标为 pos 的位置插入数据
int Insert_Pos(SeqList *s, int pos, SeqData data);


int GetData(SeqList *s, int pos, SeqData *x);


// 查找元素，如果找到，将该元素的下标给x
int FindData(SeqList *s, SeqData data, SeqData *x);


// 删除 pos 下标的元素
int Delete_Pos(SeqList *s, int pos);


// 删除指定数据
int Delete_Data(SeqList *s, SeqData data);


// 逆序
int Reverse_List(SeqList *s);


// 将两个顺序表合并成一张顺序表
// 前提：两张表都是排好序表
// 合并后的表要求是从小到大排列的，函数返回新表的指针
SeqList * Merge_List(SeqList *s1, SeqList *s2);


void Display(SeqList *s);


#endif // __SEQLIST_H__

头指针链表

#include <stdio.h>
#include <stdlib.h>


#define TRUE   1
#define FALSE  0




typedef int LinkData;    // 链表的数据类型
typedef struct _node
{
LinkData data;       // 链表的数据
struct _node *next;  // 指向链表下一个结点的指针
}Node;


// 链表的头插
int Insert_Head(Node **h, LinkData data)
{
if (h == NULL)
return FALSE;

// 创建新节点
Node* node = (Node*)malloc(sizeof(Node)/sizeof(char));
if (node == NULL)
{
return FALSE;
}

// 给结点成员变量赋值
node->data = data;
node->next = *h;

// 让新节点变为链表的第一个结点
*h = node;

return TRUE;
}




// 尾插
int Insert_Last(Node **h, LinkData data)
{
if (h == NULL)
{
return FALSE;
}

// 创建新节点
Node* node = (Node*)malloc(sizeof(Node)/sizeof(char));
if (node == NULL)
{
return FALSE;
}

// 给结点成员变量赋值
node->data = data;
node->next = NULL;

// 找最后一个结点
Node * tmp = *h;  // 指向第一个结点
if (tmp == NULL)  // 空表
{
*h = node;
}
else
{
while (tmp->next)
{
tmp = tmp->next;
}

tmp->next = node;
}


return TRUE;
}




// 在第 pos 个节点处插入数据，链表结点从1开始，没有第0个结点
int Insert_Pos (Node** h, int pos, LinkData data)
{
if (h == NULL || pos < 1)
return FALSE;

// 创建新节点
Node* node = (Node*)malloc(sizeof(Node)/sizeof(char));
if (node == NULL)
{
return FALSE;
}

// 给结点成员变量赋值
node->data = data;



// 空表的状态下，只能插入在第一个结点处
if (*h == NULL)  
{
if (pos != 1)
{
printf ("当前为空表，无法在第 %d 结点处插入数据\n", pos);
free(node);
return FALSE;
}
node->next = NULL;
*h = node;
}
else  // 非空表，需要找到插入位置的前一个结点
{
if (pos == 1)
{
node->next = *h;
*h = node;
}
else
{
int i;
Node *tmp = *h;     // tmp 开始的时候指向第一个结点
for (i = 0; i < pos-2; i++)
{
if (tmp == NULL)  // 如果 pos 太大，会造成越界
break;
tmp = tmp->next;
}

if (tmp == NULL)
{
printf ("插入位置越界\n");
free(node);
return FALSE;
}

node->next = tmp->next;
tmp->next = node;
}
}

return TRUE;
}


int Delete_Pos(Node** h, int pos)
{
if (h == NULL || *h == NULL || pos < 1)
return FALSE;

Node *tmp = *h;
if (pos == 1)
{
*h = tmp->next;
free(tmp);
}
else
{
int i;
for (i = 0; i < pos-2; i++)
{
if (tmp->next == NULL)  // 如果 pos 太大，会造成越界
break;
tmp = tmp->next;
}


if (tmp->next == NULL)
{
printf ("删除位置越界\n");
return FALSE;
}
Node* p = tmp->next;
tmp->next = p->next;
free(p);
}


return TRUE;
}


int Reverse_List(Node **h)
{
// *h == NULL 空表 (*h)->next == NULL 只有一个元素
if (h == NULL || *h == NULL || (*h)->next == NULL)
return FALSE;

Node *pre = *h;
Node *cur = (*h)->next;
Node *tmp;

while (cur)
{
tmp = cur->next;
cur->next = pre;
pre = cur;
cur = tmp;
}

(*h)->next = NULL;
*h = pre;

return TRUE;
}




void Display(Node *h)
{
if (h == NULL)
return;
int count = 0;
while (h)
{
if (count++ % 4 == 0)
printf ("\n");
printf ("%8d", h->data);

h = h->next;
}
printf ("\n");
}


int main()
{
Node * head = NULL;   // 指向链表第一个结点的指针（头指针）

// 插入元素
int i;


for (i = 0; i < 10; i++)
{
//Insert_Head(&head, i);
Insert_Last(&head, i);
}
#if 0
Insert_Pos(&head, 1, 1000);
Insert_Pos(&head, 10, 2000);
Insert_Pos(&head, 13, 3000);
Insert_Pos(&head, 15, 3000);
Insert_Pos(&head, 0, 1000);
#endif
//Delete_Pos(&head, 11);
Display(head);

Reverse_List(&head);
Display(head);

return 0;
}

头结点链表

#ifndef __LINKLIST_H__
#define __LINKLIST_H__


#define FALSE 0
#define TRUE  1


typedef int LinkData;
typedef struct _node
{
LinkData data;
struct _node * next;
}Node;


// 创建链表
Node * Create_List();


// 尾插
int Insert_Last(Node *h, LinkData data);


// 头插
int Insert_Head(Node *h, LinkData data);


// 在第 pos 个结点处插入数据
int Insert_Pos(Node *h, int pos, LinkData data);


//删除 第 pos 个结点
int Delete_Pos(Node* h, int pos);


// 逆序
int Reverse_List(Node *head);


// 删除指定数据
int Delete_Data(Node*, LinkData data);


// 查找元素:如果有, 返回元素的位置
int Find_Element(Node* h, LinkData data, int *x);


// 获取顺序表中的元素：通过位置获取
int Get_Element(Node* s, int pos, int *x);


int Get_Len(Node * head);


// 清空所有结点
int Clean_List(Node * head);


// 销毁链表
int Destroy(Node *);


void Display(Node *h);
#endif 

#include "LinkList.h"
#include <stdlib.h>
#include <stdio.h>
Node * Create_List()
{
Node *list = (Node*)malloc(sizeof(Node)/sizeof(char));
if (list == NULL)
return NULL;

list->next = NULL;   // 空表

return list;
}


int Insert_Head(Node *h, LinkData data)
{
if (h == NULL)
return FALSE;
Node *node = (Node*)malloc(sizeof(Node)/sizeof(char));
if (node == NULL)
{
return FALSE;
}

node->data = data;
node->next = h->next;

h->next = node;

return TRUE;
}


int Insert_Last(Node *h, LinkData data)
{
if (h == NULL)
return FALSE;

Node *node = (Node*)malloc(sizeof(Node)/sizeof(char));
if (node == NULL)
{
return FALSE;
}
node->data = data;
node->next = NULL;

Node* tmp = h;
while (tmp->next)
{
tmp = tmp->next;
}

tmp->next = node;

return TRUE;
}


int Insert_Pos(Node *h, int pos, LinkData data)
{
if (h == NULL || pos < 1)
return FALSE;

// 找要插入位置的前一个结点
Node *tmp = h;
int i;
for (i = 0; i < pos-1; i++)
{
if (tmp == NULL)
break;
tmp = tmp->next;
}

if (tmp == NULL)   // 越界
{
printf("插入位置越界\n");
return FALSE;
}

Node *node = (Node*)malloc(sizeof(Node)/sizeof(char));
if (node == NULL)
{
return FALSE;
}
node->data = data;
node->next = tmp->next;
tmp->next  = node;

return TRUE;
}


int Delete_Pos(Node* h, int pos)
{
if (h == NULL || pos < 1)
return FALSE;

// 找要插入位置的前一个结点
Node *tmp = h;
int i;
for (i = 0; i < pos-1; i++)
{
if (tmp->next == NULL)
break;
tmp = tmp->next;
}

if (tmp->next == NULL)   // 越界
{
printf("删除位置越界\n");
return FALSE;
}

Node *p = tmp->next;
tmp->next = p->next;
free(p);

return TRUE;
}


int Reverse_List(Node *h)
{
// h->next 空表
// h->next->next 只有一个结点
if (h == NULL || h->next == NULL || h->next->next == NULL)
return FALSE;

Node *pre = h->next;
Node *cur = h->next->next;
Node *tmp;

while (cur)
{
tmp = cur->next;
cur->next = pre;
pre = cur;
cur = tmp;
}

h->next->next = NULL;
h->next = pre;

return TRUE;
}


int Delete_Data(Node* h, LinkData data)
{
if (h == NULL)
return FALSE;

Node *tmp = h;
while (tmp->next)
{
if (tmp->next->data == data)
break;
tmp = tmp->next;
}

if (tmp->next == NULL)
return FALSE;

Node *p = tmp->next;
tmp->next = p->next;
free(p);

return TRUE;
}


int Find_Element(Node* h, LinkData data, int *x)
{
if (h == NULL)
return FALSE;

Node *tmp = h->next;
int k = 1;
while (tmp)
{
if (tmp->data == data)
{
*x = k;
return TRUE;
}
k++;
tmp = tmp->next;
}

return FALSE;
}


int Get_Element(Node* h, int pos, int *x)
{
if (h == NULL || pos < 1)
return FALSE;

int i;
Node *tmp = h;
for (i = 0; i < pos; i++)
{
if (tmp == NULL)
break;
tmp = tmp->next;
}

if (tmp == NULL)
return FALSE;
else
*x = tmp->data;

return TRUE;
}


int Get_Len(Node * h)
{
if (h == NULL)
return 0;

Node *tmp = h;
int count = 0;
while (tmp->next)
{
count++;
tmp = tmp->next;
}

return count;
}


int Clean_List(Node * h)
{
if (h == NULL)
return FALSE;

Node *tmp = h;
while (tmp->next)
{
Delete_Pos(h, 1);
}

return 0;
}




void Display(Node *h)
{
if (h == NULL)
return;

int count = 0;
Node *tmp = h->next;
while (tmp)
{
if (count++ % 4 == 0)
printf ("\n");
printf ("%8d", tmp->data);

tmp = tmp->next;
}
printf ("\n");
}






int Destroy(Node *h)
{
if (h == NULL)
return FALSE;
Clean_List(h);
free(h);

return TRUE;
}





#include <stdio.h>
#include "LinkList.h"


int main()
{
// 创建链表
Node* head = Create_List();
if (head == NULL)
{
printf("创建链表失败\n");
return -1;
}


int i;
for (i = 0; i < 10; i++)
{
Insert_Head(head, i);
}
#if 0
for (i = 0; i < 10; i++)
{
Insert_Head(head, i);
}


Insert_Pos(head, 5, 1000);
Insert_Pos(head, 1, 2000);
Insert_Pos(head, 22, 2000);
Insert_Pos(head, 24, 2000);
Insert_Pos(head, 26, 2000);
Delete_Pos (head, 21);


Reverse_List(head);
#endif
Delete_Data(head, 0);

int x;
Find_Element(head, 7, &x);
Get_Element(head, 8, &x);
printf ("%d\n", x);

printf ("%d\n", Get_Len(head));
Display(head);
Clean_List(head);
printf ("清空后：\n");
Display(head);

return 0;
}



头结点循环链表

#ifndef __LINKLIST_H__
#define __LINKLIST_H__


#define FALSE 0
#define TRUE  1


typedef int LinkData;
typedef struct _node
{
LinkData data;
struct _node * next;
}Node;


// 创建链表
Node * Create_List();


// 尾插
int Insert_Last(Node *h, LinkData data);


// 头插
int Insert_Head(Node *h, LinkData data);


// 在第 pos 个结点处插入数据
int Insert_Pos(Node *h, int pos, LinkData data);


//删除 第 pos 个结点
int Delete_Pos(Node* h, int pos);


// 逆序
int Reverse_List(Node *head);


// 删除指定数据
int Delete_Data(Node*, LinkData data);


// 查找元素:如果有, 返回元素的位置
int Find_Element(Node* h, LinkData data, int *x);


// 获取顺序表中的元素：通过位置获取
int Get_Element(Node* s, int pos, int *x);


int Get_Len(Node * head);


// 清空所有结点
int Clean_List(Node * head);


// 销毁链表
int Destroy(Node *);


void Display(Node *h);
#endif 





#include "LinkList.h"
#include <stdlib.h>
#include <stdio.h>
Node * Create_List()
{
Node *head = (Node*)malloc(sizeof(Node)/sizeof(char));
if (head == NULL)
return NULL;

head->next = head;   // 空表

return head;
}


int Insert_Head(Node *h, LinkData data)
{
if (h == NULL)
return FALSE;
Node *node = (Node*)malloc(sizeof(Node)/sizeof(char));
if (node == NULL)
{
return FALSE;
}

node->data = data;
node->next = h->next;

h->next = node;

return TRUE;
}


int Insert_Last(Node *h, LinkData data)
{
if (h == NULL)
return FALSE;

Node *node = (Node*)malloc(sizeof(Node)/sizeof(char));
if (node == NULL)
{
return FALSE;
}
node->data = data;
node->next = h;

Node* tmp = h;
while (tmp->next != h)
{
tmp = tmp->next;
}

tmp->next = node;

return TRUE;
}


int Insert_Pos(Node *h, int pos, LinkData data)
{
if (h == NULL || pos < 1)
return FALSE;

// 找要插入位置的前一个结点
Node *tmp = h;
int i;
for (i = 0; i < pos-1; i++)
{
if (tmp == h)
break;
tmp = tmp->next;
}

if (tmp == h)   // 越界
{
printf("插入位置越界\n");
return FALSE;
}

Node *node = (Node*)malloc(sizeof(Node)/sizeof(char));
if (node == NULL)
{
return FALSE;
}
node->data = data;
node->next = tmp->next;
tmp->next  = node;

return TRUE;
}


int Delete_Pos(Node* h, int pos)
{
if (h == NULL || pos < 1)
return FALSE;

// 找要插入位置的前一个结点
Node *tmp = h;
int i;
for (i = 0; i < pos-1; i++)
{
if (tmp->next == h)
break;
tmp = tmp->next;
}

if (tmp->next == h)   // 越界
{
printf("删除位置越界\n");
return FALSE;
}

Node *p = tmp->next;
tmp->next = p->next;
free(p);

return TRUE;
}


int Reverse_List(Node *h)
{
// h->next 空表
// h->next->next 只有一个结点
if (h == NULL || h->next == h || h->next->next == h)
return FALSE;

Node *pre = h->next;
Node *cur = h->next->next;
Node *tmp;

while (cur == h)
{
tmp = cur->next;
cur->next = pre;
pre = cur;
cur = tmp;
}

h->next->next = h;
h->next = pre;

return TRUE;
}


int Delete_Data(Node* h, LinkData data)
{
if (h == NULL)
return FALSE;

Node *tmp = h;
while (tmp->next != h)
{
if (tmp->next->data == data)
break;
tmp = tmp->next;
}

if (tmp->next == h)
return FALSE;

Node *p = tmp->next;
tmp->next = p->next;
free(p);

return TRUE;
}


int Find_Element(Node* h, LinkData data, int *x)
{
if (h == NULL)
return FALSE;

Node *tmp = h->next;
int k = 1;
while (tmp != h)
{
if (tmp->data == data)
{
*x = k;
return TRUE;
}
k++;
tmp = tmp->next;
}

return FALSE;
}


int Get_Element(Node* h, int pos, int *x)
{
if (h == NULL || pos < 1)
return FALSE;

int i;
Node *tmp = h;
for (i = 0; i < pos; i++)
{
if (tmp == h)
break;
tmp = tmp->next;
}

if (tmp == h)
return FALSE;
else
*x = tmp->data;

return TRUE;
}


int Get_Len(Node * h)
{
if (h == NULL)
return 0;

Node *tmp = h;
int count = 0;
while (tmp->next != h)
{
count++;
tmp = tmp->next;
}

return count;
}


int Clean_List(Node * h)
{
if (h == NULL)
return FALSE;

Node *tmp = h;
while (tmp->next != h)
{
Delete_Pos(h, 1);
}

return 0;
}




void Display(Node *h)
{
if (h == NULL)
return;

int count = 0;
Node *tmp = h->next;
while (tmp != h)
{
if (count++ % 4 == 0)
printf ("\n");
printf ("%8d", tmp->data);

tmp = tmp->next;
}
printf ("\n");
}


int Destroy(Node *h)
{
if (h == NULL)
return FALSE;
Clean_List(h);
free(h);

return TRUE;
}





#include <stdio.h>
#include "LinkList.h"


int main()
{
// 创建链表
Node* head = Create_List();
if (head == NULL)
{
printf("创建链表失败\n");
return -1;
}


int i;
for (i = 0; i < 10; i++)
{
Insert_Head(head, i);
}
#if 0
for (i = 0; i < 10; i++)
{
Insert_Head(head, i);
}


Insert_Pos(head, 5, 1000);
Insert_Pos(head, 1, 2000);
Insert_Pos(head, 22, 2000);
Insert_Pos(head, 24, 2000);
Insert_Pos(head, 26, 2000);
Delete_Pos (head, 21);


Reverse_List(head);
#endif
Delete_Data(head, 0);

int x;
Find_Element(head, 7, &x);
Get_Element(head, 8, &x);
printf ("%d\n", x);

printf ("%d\n", Get_Len(head));
Display(head);
Clean_List(head);
printf ("清空后：\n");
Display(head);

return 0;
}