数据结构--线性表

一.概述

说线性表之前先简单说一下线性结构，下面是线性结构的书本定义

在数据元素的非空有限集中：

• 存在唯一的一个被称做“第一个”的数据元素

• 存在唯一的一个被称做“最后一个”的数据元素

• 除第一个之外，集合中的每个数据元素均只有一个前驱

• 除最后一个之外，集合中的每个数据元素均只有一个后继

使用线性结构的常用数据结构有：线性表，栈，队列，串

其中栈和队列实际上是线性表的子集，属于操作受限的线性表，串其实就是一维数组。所以线性表是学好数据结构的基础。

线性表是最简单且是最常用的数据结构，形如n1,n2,n3......n这样的含有n个数据元素的有限序列，就被称为线性表。

二.线性表的基本操作

//创建线性表
Array* creat_array(size_t cap);

//销毁线性表
void destory_array(Array* array);

//清理线性表
void clear_array(Array* array);

//判断线性表是否为空表
bool empty_array(Array* array);

//线性表的长度
size_t length_array(Array* array);

//访问指定位置的元素
bool get_array(Array* array,int index,TYPE* elemp);

//在末尾添加
void add_back_array(Array* array,TYPE elem);

//插入元素
bool insert_array(Array* array,int index,TYPE elem); 

//删除元素，按位置删除
bool delete_index_array(Array* array,int index);

//查询元素
int query_array(Array* array,TYPE elem,int (*compare)(const void*,const void*));

//删除元素，按值删除
bool delete_value_array(Array* array,TYPE elem,int (*compare)(const void*,const void*));

//对线性表进行排序  
void sort_array(Array* array,int (*compare)(const void*,const void*));

//遍历线性表,只是为了测试  
void show_array(Array* array);

三.线性表的表示和实现

线性表有两种表示和实现方法，分为顺序实现和链式实现，顺序实现指的是用一组地址连续的存储单元依次存储线性表的数据元素，实际上就是用数组实现，链表实现则是使用链存储结构来实现，两者各有自己的优缺点，本文先用顺序实现

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#define TYPE int

// 设计数据结构，这里采用成员指针来设计数据结构，也可以使用柔性数组，区别不大
typedef struct Array
{
	TYPE* base;	// 存储元素的基址
	size_t cnt; // 元素的数量 
	size_t cap; // 表的容量
}Array;

// 创建线性表,调用者需要提供容量参数，成功返回线性表指针
Array* creat_array(size_t cap)
{
	// 为线性表创建内存空间
	Array* array = malloc(sizeof(Array));
	// 创建存储元素的内存空间
	array->base = malloc(sizeof(TYPE)*cap);
	// 初始化数量成员
	array->cnt = 0;
	// 备份线性表的容量
	array->cap = cap;
	// 返回线性表指针
	return array;
}

// 销毁线性表,调用者只需要提供线性表指针即可
void destory_array(Array* array)
{
	// 释放存储元素的内存空间
	free(array->base);
	// 释放线性表内存空间
	free(array);
}

// 清理所有元素
void clear_array(Array* array)
{
	array->cnt = 0;
}

// 判断线性表是否是空表
bool empty_array(Array* array)
{
	return 0 == array->cnt;
}

// 求线性表的长度
size_t length_array(Array* array)
{
	return array->cnt;
}

// 访问指定位置的元素
bool get_array(Array* array,int index,TYPE* elemp)
{
	if(index >= array->cnt)
		return false;

	*elemp = array->base[index];
	return true;
}

// 在末尾添加元素
void add_back_array(Array* array,TYPE elem)
{
	// 容量如果不够用
	if(array->cnt >= array->cap)
	{
		// 容量扩展两倍
		array->cap *= 2;
		// 元素存储空间扩展两倍
		array->base = realloc(array->base,sizeof(TYPE)*array->cap);
	}

	// 末尾添加元素
	array->base[array->cnt++] = elem;
}

// 插入元素
bool insert_array(Array* array,int index,TYPE elem)
{
	// 如果下标不合法则插入失败
	if(index >= array->cnt)
		return false;

	// 把最后一个元素添加到末尾
	add_back_array(array,array->base[array->cnt-1]);

	// 线性表的顺序存储才可以使用
	memmove(array->base+index+1,array->base+index,sizeof(TYPE)*(array->cnt-index-2));
	
	array->base[index] = elem;
	return true;
}

// 删除元素，按位置删除
bool delete_index_array(Array* array,int index)
{
	if(index >= array->cnt)
		return false;

	memmove(array->base+index,array->base+index+1,sizeof(TYPE)*(array->cnt-index-1));
	array->cnt--;
	return true;
}

// 查询元素
int query_array(Array* array,TYPE elem,int (*compare)(const void*,const void*))
{
	for(int i=array->cnt-1; i>=0; i--)
	{
		if(!compare(&elem,array->base+i))
			return i;
	}
	return -1;
}

// 删除元素，按值删除
bool delete_value_array(Array* array,TYPE elem,int (*compare)(const void*,const void*))
{
	return delete_index_array(array,query_array(array,elem,compare));
}

// 对线性表进行排序
void sort_array(Array* array,int (*compare)(const void*,const void*))
{
	bool flag = true;
	for(int i=array->cnt-1; flag && i>0; i--)
	{
		flag = false;
		for(int j=0; j<i; j++)
		{
			if(1 == compare(array->base+j,array->base+j+1))
			{
				TYPE tmp = array->base[j];
				array->base[j] = array->base[j+1];
				array->base[j+1] = tmp;
				flag = true;
			}
		}
	}
}

// 遍历线性表,只是为了测试
void show_array(Array* array)
{
	for(int i=0; i<array->cnt; i++)
	{
		printf("%d ",array->base[i]);
	}
	printf("\n");
}

int main(int argc,const char* argv[])
{
	Array* array = creat_array(10);
	for(int i=0; i<10; i++)
	{
		add_back_array(array,rand()%100);
	}
	
	show_array(array);

	int intcmp(const void* p1,const void* p2)
	{
		if(*(int*)p1 > *(int*)p2)
			return 1;
		if(*(int*)p1 < *(int*)p2)
			return -1;
		return 0;

	}
    
	delete_value_array(array,77,intcmp);

	sort_array(array,intcmp);
	
	show_array(array);
	destory_array(array);
	return 0;
}

线性表的顺序实现优点在于可以随机存取表中的任一元素，并且它的长度可以根据需要来增加和减少，比较灵活但因为顺序实现要求逻辑结构上相邻的两个元素在物理地址上也必须相邻，导致插入，删除操作时需要移动大量的元素，时间复杂度为O（n），链式实现不要求逻辑地址相邻的元素物理地址也相邻，所以它很好的弥补了顺序实现的缺点，但同样的也失去了顺序实现的优点，关于线性表的链式实现，放在下一篇再交流。

本人是刚刚入门的菜鸡，写下博客也是记录自己的学习进程，如果有错误的地方欢迎指正，我会第一时间修改的。