线性表的c语言实现

本文代码参考自《大话数据结构》

顺序存储结构

首先定义一下数据类型和函数类型：

#include<iostream>
#define MAXSIZE 20//存储空间初始分配量
#define OK 1
#define ERROR 0

typedef int ElemType;//数据类型，ElemType类型根据实际情况而定，这里假设为int
typedef int Status;//函数类型

以及定义一下结构体：

typedef struct {
	ElemType data[MAXSIZE];//数组存储数据元素，最大值为MAXSIZAE
	int length;//线性表当前长度，在任意时刻，length <= MAXSIZE
}SqList;

获取元素

//获得元素操作，时间复杂度为O(1)
//Status是函数的类型，其值是函数结果状态代码，如OK等
//初始条件：顺序线性表L已经存在
//操作结果：用e返回L中的第i个数据元素的值
Status GetElem(SqList L, int i, ElemType* e) {
	if (L.length == 0 || i<1 || i>L.length)
		return ERROR;
	*e = L.data[i - 1];
	return OK;
}

插入元素

//插入元素操作，时间复杂度为O(n)
//初始条件：顺序线性表L已经存在
//操作结果：在L中第i个位置之前插入新的数据元素e，L的长度加1
Status ListInsert(SqList* L, int i, ElemType e) {
	if (L->length == MAXSIZE)return ERROR;//线性表已满
	if (i<1 || i>L->length + 1)return ERROR;//添加的位置不在数组中
	if (i <= L->length)//把插入位置之后的元素全部后移一位
		for (int k = L->length - 1; k >= i - 1; k--)
			L->data[k + 1] = L->data[k];
	L->data[i] = e;
	L->length++;
	return OK;
}

删除元素

//删除操作，时间复杂度为O(n)
//初始条件：顺序线性表L已经存在
//操作结果：删除L的第i个数据元素，并用e返回其值，L的长度减1
Status ListDelete(SqList* L, int i, ElemType* e) {
	if (L->length == 0)return ERROR;//线性表为空
	if (i<1 || i>L->length)return ERROR;//删除位置不正确
	*e = L->data[i - 1];
	if (i <= L->length)//把删除位置后面的元素全部前移一位
		for (int k = i; k < L->length; k++)
			L->data[k - 1] = L->data[k];
	L->length--;
	return OK;
}

链式存储结构（以单链表为例）

首先定义一下数据类型和函数类型：

#include<iostream>
#define MAXSIZE 20//存储空间初始分配量
#define OK 1
#define ERROR 0

typedef int ElemType;//数据类型，ElemType类型根据实际情况而定，这里假设为int
typedef int Status;//函数类型

链表节点定义如下：

//线性表的单链表存储结构
typedef struct Node {
	ElemType data;
	struct Node* next;
}Node;
typedef struct Node* LinkList;//定义LinkList

获取元素

//获得元素操作，时间复杂度为O(n)
//初始条件：顺序线性表L已经存在
//操作结果：用e返回L中的第i个数据元素的值
Status GetElem(LinkList L, int i, ElemType* e) {
	if (i < 1)return ERROR;
	int j = 1;//j为计数器
	LinkList p;//声明一个节点p
	p = L->next;//让p指向链表L的第一个节点
	while (p && j < i) {//*p不为空或者计数器j还没等于i，循环继续
		p = p->next;
		j++;
	}
	if (!p || j > i)return ERROR;//第i个元素不存在
	*e = p->data;
	return OK;
}

插入元素

//插入元素操作，时间复杂度为O(n)
//初始条件：顺序线性表L已经存在
//操作结果：在L中第i个位置之前插入新的数据元素e，L的长度加1
Status ListInsert(LinkList* L, int i, ElemType e) {
	if (i < 1)return ERROR;
	int j = 1;
	LinkList p, s;
	p = *L;
	while (p && j < i) {
		j++;
		p = p->next;
	}
	if (!p || j > i)return ERROR;
	s = (LinkList)malloc(sizeof(Node));//生成新的节点
	s->data = e;
	s->next = p->next;
	p->next = s;
	return OK;
}

删除元素

//删除操作，时间复杂度为O(n)
//初始条件：顺序线性表L已经存在
//操作结果：删除L的第i个数据元素，并用e返回其值，L的长度减1
Status ListDelete(LinkList* L, int i, ElemType *e) {
	if (i < 1)return ERROR;
	int j = 1;
	LinkList p, q;
	p = *L;
	while (p->next || j < i) {
		j++;
		p = p->next;
	}
	if (!(p->next) || j > i)return ERROR;
	q = p->next;
	p->next = q->next;
	*e = q->data;
	free(q);
	return OK;
}

创建整表

创建整表分为头插法和尾插法，顾名思义就是新的数据分别插入在链表头部和尾部

//单链表的整表创建--头插法
//输入：未初始化的单链表L，需要创建的节点数n
//输出：带有n个节点的单链表L，其节点值为100以内的随机数
void CreatListHead(LinkList* L, int n) {
	LinkList p;
	srand(time(0));//初始化随机数种子
	*L = (LinkList)malloc(sizeof(Node));
	(*L)->next = NULL;
	for (int i = 0; i < n; i++) {
		p= (LinkList)malloc(sizeof(Node));
		p->data = rand() % 100 + 1;
		p->next = (*L)->next;
		(*L)->next = p;//插入到表头
	}
}

//单链表的整表创建--尾插法
//输入：未初始化的单链表L，需要创建的节点数n
//输出：带有n个节点的单链表L，其节点值为100以内的随机数
void CreatListHead(LinkList* L, int n) {
	LinkList p, r;
	srand(time(0));
	*L = (LinkList)malloc(sizeof(Node));
	r = *L;//r为指向尾部的节点
	for (int i = 0; i < n; i++) {
		p = (LinkList)malloc(sizeof(Node));
		p->data = rand() % 100 + 1;
		r->next = p;//将表尾终端节点指向新节点
		r = p;//将当前的新节点定义为表尾部终端节点
	}
	r->next = NULL;//当前链表结束
}

删除整表

//单链表的整表删除
//输入：顺序线性表L
//输出：删除成功OK，或者删除失败ERROR
Status ClearList(LinkList* L) {
	LinkList p, q;
	p = (*L)->next;
	while (p) {
		q = p->next;
		free(p);
		p = q;
	}
	(*L)->next = NULL;
	return OK;
}

顺序存储结构和单链表结构优缺点

存储分配方式

• 顺序存储结构用一段连续的存储单元依次存储线性表的数据元素
• 单链表采用链式存储结构，用一组任意的存储单元存放线性表的元素

时间性能

查找：

• 顺序存储结构O(1)
• 单链表O(n)

插入和删除：

• 顺序存储结构O(n)
• 单链表O(n)，但在找到某位置的指针后，只需要O(1)

空间性能：

• 顺序存储结构需要预分配存储空间，分大了，浪费，分小了易发生上溢
• 单链表不需要分配存储空间，只要有就可以分配，元素个数也不受限制