一、单链表
以下为源代码,主要功能有:初始化、插入(插入随机数)、遍历、求链表长度、判断链表是否为空、获取p位置的元素、查找元素e的位置、删除、反转、清空、销毁。
1. LinkList.h
#ifndef _LINKLIST_H
#define _LINKLIST_H
#define FAILURE 10000
#define SUCCESS 10001
#define TRUE 10002
#define FALSE 10003
typedef int ElemType;
struct node
{
ElemType data; /*数据域*/
struct node *next; /*指针域*/
};
typedef struct node Node;
int LinkInit(Node **l);
int LinkInsert(Node *l, int n, ElemType e);
int LinkTraverse(Node *l, void (*p)(ElemType));
int LinkLength(Node *l);
int LinkEmpty(Node *l);
int GetElem(Node *l, int p, ElemType *e);
int LocateElem(Node *l, ElemType e, int (*p)(ElemType, ElemType));
int LinkDelete(Node *l, int p, ElemType *e);
int LinkReverse(Node *l);
int LinkClear(Node *l);
int LinkDestroy(Node **l);
#endif
2. LinkList.c
#include "LinkList.h"
#include <stdlib.h>
int LinkInit(Node **l)
{
*l = (Node *)malloc(sizeof(Node) * 1); /*分配头结点,l是头指针*/
if(NULL == *l)
{
return FAILURE;
}
(*l)->next = NULL; /*头结点指针域为空*/
return SUCCESS;
}
int LinkInsert(Node *l, int n, ElemType e) /*n插入位置,k移动次数*/
{
Node *p = l;
int k = 1;
if(NULL == l)
{
return FAILURE;
}
while(k < n && p != NULL)
{
p = p->next;
k++;
}
if(k > n || p == NULL)
{
return FAILURE;
}
Node *q = (Node *)malloc(sizeof(Node) * 1);
if(NULL == q)
{
return FAILURE;
}
q->data = e; /*数据域*/
q->next = p->next;
p->next = q;
return SUCCESS;
}
/*遍历*/
int LinkTraverse(Node *l, void (*p)(ElemType))
{
if(NULL == l)
{
return FAILURE;
}
Node *q = l;
while (q->next)
{
q = q->next;
p(q->data);
}
return SUCCESS;
}
/*求长度*/
int LinkLength(Node *l)
{
if(NULL == l)
{
return FAILURE;
}
int len = 0;
Node *p = l->next;
while(p)
{
len++;
p = p->next;
}
return len;
}
/*判断是否为空*/
int LinkEmpty(Node *l)
{
return (l->next == NULL) ? TRUE : FALSE;
}
/*获取p位置的元素*/
int GetElem(Node *l, int p, ElemType *e) /*p位置*/
{
if(NULL == l || p < 1) /*入参判断 p不能小于0*/
{
return FAILURE;
}
Node *q = l;
int i;
for(i = 0; i < p && q != NULL; i++) /*循环p次 同时满足p不为空*/
{
q = q->next;
}
if(!q) /*如果q为空,说明p(位置)大于长度*/
{
return FAILURE;
}
*e = q->data; /*q已经指向第p个结点*/
return SUCCESS;
}
/*查找元素e的位置*/
int LocateElem(Node *l, ElemType e, int (*p)(ElemType, ElemType))
{
if(NULL == l)
{
return FAILURE;
}
Node *q = l->next;
int len = 1;
while(q)
{
if(p(e, q->data) == TRUE)
{
return len;
}
q = q->next;
len++;
}
return FAILURE;
}
/*删除*/
int LinkDelete(Node *l, int p, ElemType *e)
{
int k = 1;
Node *q = l;
if(NULL == l)
{
return FAILURE;
}
while(k < p && q != NULL)
{
q = q->next;
k++;
}
if(k > p || q == NULL)
{
return FAILURE;
}
Node *n = q->next;
*e = n->data;
q->next = n->next;
free(n);
return SUCCESS;
}
/*反转*/
int LinkReverse(Node *l)
{
if(NULL == l)
{
return FAILURE;
}
Node *p = l->next;
l->next = NULL;
while(p != NULL)
{
Node *q = p;
p = p->next;
q->next = l->next;
l->next = q;
}
return SUCCESS;
}
/*清空*/
int LinkClear(Node *l)
{
if(NULL == l)
{
return FAILURE;
}
Node *p = l->next;
while(p)
{
l->next = p->next;
free(p);
p = l->next;
}
return SUCCESS;
}
/*销毁*/
int LinkDestroy(Node **l)
{
if(NULL == l)
{
return FAILURE;
}
free(*l);
(*l) = NULL;
return SUCCESS;
}
3. TestLinkList.c
#include "LinkList.h"
#include <stdio.h>
/*带头结点的链表*/
void print(ElemType e)
{
printf("%d ", e);
}
int equal(ElemType e1, ElemType e2)
{
return (e1 == e2) ? TRUE : FALSE;
}
int main()
{
int ret, i;
Node *first = NULL; /*头指针*/
srand(time(NULL));
/*初始化*/
ret = LinkInit(&first);
if(ret == FAILURE)
{
printf("Init Failure!\n");
}
else
{
printf("Init Success!\n");
}
/*插入*/
for(i = 0; i < 10; i++)
{
ret = LinkInsert(first, i + 1, rand() % 20);
if(ret == FAILURE)
{
printf("Insert Failure!\n");
}
else
{
printf("Insert Success!\n");
}
}
/*遍历*/
ret = LinkTraverse(first, print);
if(ret == FAILURE)
{
printf("\nTraverse Failure!\n");
}
else
{
printf("\nTraverse Success!\n");
}
/*求长度*/
ret = LinkLength(first);
if(ret == FAILURE)
{
printf("Get Length Failure!\n");
}
else
{
printf("Length is %d\n", ret);
}
/*判断是否为空*/
ret = LinkEmpty(first);
if(ret == TRUE)
{
printf("List is empty!\n");
}
else if(ret == FALSE)
{
printf("List is not empty!\n");
}
/*获取第p个元素*/
int p = 3;
ElemType e;
ret = GetElem(first, p, &e);
if(ret == FAILURE)
{
printf("Get element failure!\n");
}
else
{
printf("The %dth element is %d\n", p, e);
}
/*判断元素10的位置*/
e = 10;
ret = LocateElem(first, e, equal);
if(FAILURE == ret)
{
printf("%d not exist!\n");
}
else
{
printf("%d is %dth element!\n", e, ret);
}
/*删除*/
p = 3;
ret = LinkDelete(first, p, &e);
if(ret == FAILURE)
{
printf("Delete Failure!\n");
}
else
{
printf("Delete %d Success!\n", e);
}
/*删除后再次遍历*/
ret = LinkTraverse(first, print);
if(ret == FAILURE)
{
printf("\nTraverse Failure!\n");
}
else
{
printf("\nTraverse Success!\n");
}
/*反转*/
ret = LinkReverse(first);
if(ret == SUCCESS)
{
printf("Reverse Success!\n");
}
else
{
printf("Reverse Failure!\n");
}
/*反转后再次遍历*/
ret = LinkTraverse(first, print);
if(ret == FAILURE)
{
printf("\nTraverse Failure!\n");
}
else
{
printf("\nTraverse Success!\n");
}
/*清空*/
ret = LinkClear(first);
if(ret == SUCCESS)
{
printf("Clear Success!\n");
}
else
{
printf("Clear Failure!\n");
}
/*销毁*/
ret = LinkDestroy(&first);
if(ret == SUCCESS)
{
printf("Destroy Success!\n");
}
else
{
printf("Destroy Failure!\n");
}
return 0;
}
二、单链表结构与顺序存储结构的优缺点
存储分配方式 | 时间性能 | 空间性能 |
1. 顺序存储结构用一段连续的存储单元依次存储线性表的数据元素。
2. 单链表采用链式存储结构,用一组任意的存储单元存放线性表的元素。 | 1. 查找 顺序存储结构 O( 1 ) 单链表 O( n )
2. 插入和删除 顺序存储结构需要平均移动表长一半的元素。时间为 O( n ) ; 单链表在线出某位置的指针后,插入和删除时间仅为 O(1); | 1.顺序存储结构需要预分配存储结构,分大了,浪费,分小了易发生上溢。
2.单链表不需要分配存储空间,只要有就可以分配,元素个数也不受限制。 |
- 若线性表需要频繁查找,很少进行插入和删除操作时,采用顺序存储结构。若需要频繁的插入和删除时,则采用单链表结构。
- 当线性表中的元素个数变化较大,或者根本不知道有多大时,最好用单链表结构,这样可以不需要考虑存储空间的大小问题。如果事先知道了线性表的大致长度,用顺序存储结构效率会高很多。