初学顺序表

1. 基本定义
   • 顺序表是线性表的一种存储方式。线性表是具有相同类型的数据元素的有限序列，而顺序表是用一组地址连续的存储单元依次存储线性表的数据元素。简单来说，就像是把一系列的数据一个挨着一个地放在连续的 “小格子”（存储单元）里。
   • 存储结构特点：假设线性表中的元素类型为 DataType（可以是 int、float、char 等基本数据类型，也可以是自定义的结构体等复合数据类型），顺序表的数据结构可以用 C/C++ 语言来简单描述如下：

         一.静态分配（大小固定）

         顺序表的定义：

#define Maxsize 10                //定义最大长度
typedef struct                    
{
    ElemType data[Maxsize];       //用静态的“数组”存放数据元素   ElemType表示数据元素的类型
    int length;                   //顺序表的当前长度
}Sqlist;                          //顺序表的类型定义（静态分配方式）

#include<stdio.h>
#define Maxsize 10        //定义最大长度
typedef struct
{
    int date[Maxsize];    //用静态的“数组”存放元素数据
    int length;           //顺序表的当前长度
}SqList;                  //顺序表的类型定义


//基本操作——初始化一个顺序表
void InitList(SqList *L)
{
    for (int i = 0; i < Maxsize; i++)
    {
        L->date[i] = 0;  //将所有数据元素设置为默认初始值
        L->length = 0;   //顺序表初始长度为0
    }
}

int main()
{
        SqList L;            //声明一个顺序表
        InitList(&L);          //初始化顺序表
        //......未完待续，后续操作
        return 0;
}

二.动态分配（大小可变）

#define initsize 10                //顺序表的初始长度
typedef struct                    
{
    ElemType *data;               //指示动态分配数组的指针   ElemType表示数据元素的类型
    int maxsize;                  //顺序表的最大容量
    int length;                   //顺序表的当前长度
}Seqlist;                          //顺序表的类型定义（动态分配方式）

基本使用：

#include<stdio.h>
#include<stdlib.h>
#define initsize 10        
typedef struct
{
    int *date;
    int maxsize;
    int length;           
}seqlist;                  


//基本操作——初始化一个顺序表
void initlist(seqlist *L)
{       //用 malloc 函数申请一片连续的存储空间
        L->date = (int*)malloc(sizeof(int) * initsize);
        L->length = 0;
        L->maxsize = initsize;

}
//增加动态数组的长度
void increasesize(seqlist *L, int len)
{
    int* p = L->date;
    L->date = (int*)malloc(sizeof(int) * (initsize + len));
    for (int i = 0; i < L->length; i++)
    {
        L->date[i] = p[i];//将数据复制到新区域
    }
    L->maxsize = L->maxsize + len;//顺序表最大长度增加 len
    free(p);                    //释放原来的内存空间
}

int main()
{
        seqlist L;            //声明一个顺序表
        initlist(&L);          //初始化顺序表
        //...往顺序表中随便插入几个元素...
        increasesize(&L, 5);
        return 0;
}

顺序表的特点：

1. 随机访问，即可以在O(1)时间内找到第i个元素（代码实现：date[i-1]        静态分配，动态分配都一样      
2. 存储密度高，每个节点只存储数据元素
3. 拓展容量不方便（即便采用动态分配的方式实现，拓展长度的时间复杂度也比较高）
4. 插入，删除操作不方便，需要移动大量元素

知识点回顾：

 

 三.顺序表的插入

插入函数的写法：

void listinsert(sqlist* L, int i, int e)
{
	for (int j = L->length; j >= i; j--)  //将第i个元素及之后的元素后移  i的大小不能超过length 否则是不合法的
	{
		L->date[j] = L->date[j - 1];
	}
	L->date[i - 1] = e;					//在位置i处放入e
	L->length++;							//长度加1
}

 但这种写法，其他人在使用的过程中会存在一些问题，为了使函数满足健壮性，改进代码如下：

bool listinsert(sqlist* L, int i, int e)
{
	if (i<1 || i>L->length + 1)
	{
		return false;
	}
	if (L->length >= maxsize)
	{
		return false;
	}
	for (int j = L->length; j >= i; j--)  //将第i个元素及之后的元素后移
	{
		L->date[j] = L->date[j - 1];
	}
	L->date[i - 1] = e;					//在位置i处放入e
	L->length++;							//长度加1
	return true;
}

四.顺序表的删除

和插入雷同

bool listdelete(sqlist* L, int i)
{
	if (i<1 || i>L->length)
	{
		return false;
	}
	
	for (int j = i; j < L->length; j++)  //将第i个元素之后的元素前移
	{
		L->date[j-1] = L->date[j];
	}
	L->length--;							//长度减1
	return true;
}

五.顺序表的查找——按位查找

elemtype getelem(seqlist L,int i)
{
    return L.date[i-1];
}

        按值查找

int locateelem(seqlist L,int e)
{
    for(int i=0;i<L.length;i++)
        {
            if(L.date[i]==e)
                {
                    return i+1;
                }
        }
    return 0;
}