数据结构之顺序表的实现

主要参考：

【王道考研】王道数据结构与算法详细笔记（全）_王道数据结构笔记-CSDN博客

顺序表的概念

顺序表：用顺序存储的方式实现线性表顺序存储。把逻辑上相邻的元素存储在物理位置上也相邻的存储单元中，元素之间的关系由存储单元的邻接关系来体现。

顺序表的特点：

1. 随机访问，即可以在O(1)时间内找到第 i 个元素。

2. 存储密度高，每个节点只存储数据元素。

3. 拓展容量不方便（即使使用动态分配的方式实现，拓展长度的时间复杂度也比较高，因为需要把数据复制到新的区域）。

5. 插入删除操作不方便，需移动大量元素：O(n)

顺序表的实现

所谓顺序表，其实就是申请一整块的内存空间，比如我们可以定义一个数组或者malloc一片空间，然后我们再基于这块空间来进行数据项管理。

顺序表的静态分配 顺序表的表长刚开始确定后就无法更改(存储空间是静态的)

//顺序表的实现--静态分配
 
#include<stdio.h>
#define MaxSize 10          //定义表的最大长度 
typedef struct{
	int data[MaxSize];      //用静态的"数组"存放数据元素
	int length;             //顺序表的当前长度  
}SqList;                    //顺序表的类型定义（静态分配方式） 
void InitList(SqList &L){
	 for(int i=0;i<MaxSize;i++){
	 	L.data[i]=0;        //将所有数据元素设置为默认初始值
		 }
	 L.length=0;
}
int main(){
	SqList L;               //声明一个顺序表
	InitList(L);            //初始化一个顺序表
	for(int i=0;i<MaxSize;i++){                //顺序表的打印
		printf("data[%d]=%d\n",i,L.data[i]);
	}
	return 0; 
}

顺序表的动态分配

//顺序表的实现——动态分配
#include<stdio.h>
#include<stdlib.h>  //malloc、free函数的头文件 
#define InitSize 10 //默认的初始值
 
typedef struct{
	int  *data;    //指示动态分配数组的指针
	int MaxSize;   //顺序表的最大容量
	int length;    //顺序表的当前长度 
}SeqList; 
 
void InitList(SeqList &L){                 //初始化
	//用malloc 函数申请一片连续的存储空间
	L.data =(int*)malloc(InitSize*sizeof(int)) ;
	L.length=0;
	L.MaxSize=InitSize;
} 
 
void IncreaseSize(SeqList &L,int len){  //增加动态数组的长度
	int *p=L.data;
	L.data=(int*)malloc((L.MaxSize+len)*sizeof(int));
	for(int i=0;i<L.length;i++){
		L.data[i]=p[i];      //将数据复制到新区域 
	}
	L.MaxSize=L.MaxSize+len; //顺序表最大长度增加len
	free(p);                 //释放原来的内存空间 
	
} 
int main(){
	SeqList L;        //声明一个顺序表
	InitList(L);      //初始化顺序表
	IncreaseSize(L,5);//增加顺序表的长度
	return 0; 
}

注意，顺序表在定义时需要用结构体封装一个数组，用来存储元素，数组的大小就是该顺序表的最大容量，另外，需要封装一个长度，用来表示当前顺序表的有效长度，也就是当前所容纳的数据个数。

因为数组在声明时可以同时指定指针和容量，所以只需要定义两个变量；如果是使用动态分配的方式，就需要定义一个指针，一个最大容量，一个当前长度，共三个变量。但二者本质上是一样的。

顺序表的插入操作 ListInsert(&L,i,e)：插入操作。在表L中的第i个位置上插入指定元素e。 平均时间复杂度 = O(n)

#define MaxSize 10    //定义最大长度
typedef struct{
	int data[MaxSize];  //用静态的数组存放数据
	int length;         //顺序表的当前长度
}SqList;                //顺序表的类型定义  
 
bool ListInsert(SqList &L, int i, int e){ 
    if(i<1||i>L.length+1)    //判断i的范围是否有效
        return false;
    if(L.length>=MaxSize) //当前存储空间已满，不能插入  
        return false;
 
    for(int j=L.length; j>=i; j--){    //将第i个元素及其之后的元素后移
        L.data[j]=L.data[j-1];
    }
    L.data[i-1]=e;  //在位置i处放入e
    L.length++;      //长度加1
    return true;
}
 
int main(){ 
	SqList L;   //声明一个顺序表
	InitList(L);//初始化顺序表
	//...此处省略一些代码；插入几个元素
 
	ListInsert(L,3,3);   //再顺序表L的第三行插入3
 
	return 0;
}

注意，这些数据结构，插入数据的时候必须是相连的，比如顺序表，插入的时候不能让连续的数据断开。

顺序表的删除操作 ListDelete(&Li,&e): 删除操作。删除表L中第i个位置的元素，并用e返回删除元素的值。 平均时间复杂度 = O(n)

#define MaxSize 10
 
typedef struct {
	int data[MaxSize];
	int length;
} SqList;
 
// 删除顺序表i位置的数据并存入e
bool ListDelete(SqList &L, int i, int &e) {
	if (i < 1 || i > L.length) // 判断i的范围是否有效
		return false;
	e = L.data[i-1]; // 将被删除的元素赋值给e 
	for (int j = i; j < L.length; j++) //将第i个位置后的元素前移 
		L.data[j-1] = L.data[j];
	L.length--;
	return true; 
}
 
int main() {
	SqList L;
	InitList(L);
	int e = -1;
	if (ListDelete(L, 3, e))
		printf("已删除第3个元素，删除元素值为%d\n", e);
	else
		printf("位序i不合法，删除失败\n"); 
	return 0; 
} 

因为顺序表要保持连续性，所以插入和删除时都需要移动操作点之后的数据，这也就是时间复杂度所在之处。

顺序表的按位查找 GetElem(L,i):按位查找操作。获取表L中第i个位置的元素的值 平均时间复杂度O(1)

// 静态分配的按位查找
#define MaxSize 10
 
typedef struct {
	ElemType data[MaxSize]; 
	int length;
}SqList;
 
ElemType GetElem(SqList L, int i) {
	return L.data[i-1];
}

// 动态分配的按位查找
#define InitSize 10
 
typedef struct {
	ElemType *data;
	int MaxSize;
	int length;
}SeqList;
 
ElemType GetElem(SeqList L, int i) {
	return L.data[i-1];
}

按位查找的应用之一就是作为哈希表，通过key计算出哈希值，然后直接就能获取哈希值所在处的元素了，效率很高。

顺序表的按值查找 LocateElem(L,e): 按值查找操作。在表L中查找具有给定关键字值的元素 平均时间复杂度 =O(n)

#define InitSize 10          //定义最大长度 
typedef struct{
    ElemTyp *data;           //用静态的“数组”存放数据元素 
    int Length;              //顺序表的当前长度
}SqList;   
 
//在顺序表L中查找第一个元素值等于e的元素，并返回其位序
int LocateElem(SqList L, ElemType e){
    for(int i=0; i<L.lengthl i++)
        if(L.data[i] == e)  
            return i+1;     //数组下标为i的元素值等于e，返回其位序i+1
    return 0;               //推出循环，说明查找失败
}
//调用LocateElem(L,9)

待完善。

更多待补充。

注意

单纯的顺序表，在结构体定义时并没有头指针和尾指针。

队列是有头指针和尾指针的，这点要注意区别。

如何表示一个顺序表？直接定义一个顺序表的结构体，然后声明一个结构体变量或者指针（结构体一般传递指针的情况比较多，一般可以定义变量，然后如果需要指针就再获取变量的指针，如果直接定义指针，那么想要变量的时候就没有了），这个变量就表示一整个的顺序表。这是一个整体。

而链表是以结点为基本单位的，我们定义的是结点的结构体，并不是整个的链表，因为链表是动态变化的，并不能一开始就固定下来，我们如果需要一个链表，就定义一个结点指针，用来表示一个链表的开始，也就是用来表示一个链表。 

在实现数据结构的时候，思路一般是这样的：

#先定义数据结构的结构体；

#然后实现初始化；

#然后实现增删改查

@@增：指定位置插入，包括指定元素的前后，也包括头插和尾插这两种特殊情况；

@@删：删除指定位置的元素；

@@改：修改指定位置的元素；

@@查：获取指定位置的元素或者遍历； 

这里面的指定的位置要怎么理解呢？

比如指定第i个位置，或者指定某个元素？比如顺序表中插入指定下标的位置，又比如在链表中插入某个指定元素的后面，等等。

实战总结

暂附上一个自定义的顺序表

 

#include <string.h>
#include <stdio.h>

#define SQLIST_DATATYPE int
#define ELEMENT_MAX_COUNT 10

typedef struct sqlist
{
    SQLIST_DATATYPE sq_list_content[ELEMENT_MAX_COUNT];
    int current_len;
}sqlist;

void sqlist_init(sqlist *sq_list)
{
    memset(sq_list, 0, sizeof(sqlist));
    sq_list->current_len = 0;
}

//position start from one(1);
int sqlist_insert_by_position(sqlist *sq_list, int position, SQLIST_DATATYPE data)
{
    if(sq_list->current_len >= ELEMENT_MAX_COUNT)
    {
        return -1;
    }

    if(position < 1 || position > ELEMENT_MAX_COUNT)
    {
        return -2;
    }

    if(position > (sq_list->current_len + 1))
    {
        return -3;
    }

    for(int i = position - 1; i < sq_list->current_len; i++)
    {
        sq_list->sq_list_content[i + 1] = sq_list->sq_list_content[i];
    }

    sq_list->sq_list_content[position] = data;
    sq_list->current_len++;

    return 0;
}

int sqlist_delete_by_position(sqlist *sq_list, int position)
{
    if(position > sq_list->current_len)
    {
        return -1;
    }

    for(int i = position; i < sq_list->current_len; i++)
    {
        sq_list->sq_list_content[i - 1] = sq_list->sq_list_content[i];
    }

    sq_list->current_len--;

    return 0;
}

int sqlist_modify_by_position(sqlist *sq_list, int position, SQLIST_DATATYPE data)
{
    if(position > sq_list->current_len)
    {
        return -1;
    }

    sq_list->sq_list_content[position - 1] = data;

    return 0;
}

SQLIST_DATATYPE sqlist_get_element_in_position(sqlist *sq_list, int position)
{
    if(position > sq_list->current_len)
    {
        return -1;
    }

    return sq_list->sq_list_content[position - 1];
}

void sqlist_print_all_element(sqlist *sq_list)
{
    for(int i = 0; i < sq_list->current_len; i++)
    {
        printf("%d\n", sq_list->sq_list_content[i]);
    }
}

更多的以后再慢慢优化总结。