数据结构--线性表及基本操作

线性表：1.相同数据类型  2.有限序列  3.每个数据元素所占的空间一样大

第i个元素位置：Lai=La1+(i-1)*d

基本操作：类型定义，初始化，创建表，插入元素，删除元素，查找元素（按值查找，按位查找），销毁表，求表长，输出表元素，判空

线性表的顺序表示和实现：

顺序存储：逻辑上相邻的元素物理上也相邻

实现方式：①静态分配：使用静态数组，大小一旦确定就无法改变   一维数组可以是静态分配的，也可以是动态分配的

​                  ②动态分配：使用动态数组

​                  ③顺序表满时，可再用malloc动态拓展空间。复制元素到新区域，用free函数释放原区域。

顺序表类型定义

//类型定义 假设元素数据类型为ElemType：
1.静态分配：
    #define MaxSize 100    //定义线性表的最大长度
    typedef struct {
        ElemType data[MaxSize];   //顺序表元素
        int length;    //顺序表当前长度
    }SqList;           //顺序表的类型定义
//-------------------------------------------
2.动态分配：
    #define InitSize 100    //定义线性表的初始长度
    typedef struct {
        ElemType *data;  //指示动态分配数组的指针
        int MaxSize，length；//数组的最大容量和当前长度
    }SqList;
L.data=(ElemType *)malloc(sizeof*ElemType))；//C语言初始动态分配语句

顺序表初始化

void Init_List(SqList &L)
{
    L.data=(ElemType *)malloc(Init_Size*sizeof(ElemType));
    L.length=0;
}

顺序表的建立与输出

//顺序表的建立
int Cre_List(SqList &L)
{
	int i=0;
	int x=0;
	scanf("%d",&x);
	while(x!=8888)
	{
		L.data[i++]=x;
		L.length++;
		scanf("%d",&x);
	}
	return OK;
}

//顺序表的输出
int Print_List(SqList &L)
{
	int i=0;
	for(i=0;i<L.length;i++)
	{
		printf("%d\n",L.data[i]);
	}
	return OK;
}
//------------------------------------
或者：
1.写入表元素
void Write_List(SqList &L)
{
    for(int i=0;i<L.length;i++)   //---要事先自定义表长度
        scanf("%d",&L.data[i]);
}

2.输出表元素
bool Print_List(SqLISt &L)
{
    if(!L.data) //空表
        return FALSE;
    for(i=0;i<L.length;i++)
        printf("%d",L.data[i]);
    return TRUE;
}

顺序表元素的插入和删除

//插入操作:在顺序表L的第i位置插入指定元素
//算法思想：----步骤
1.判断插入的位置是否合法     //考虑健壮性
2.第i个位置及其之后的元素后移 ,从最后一个元素开始后移
3.在第i个位置上存放要插入的元素
4.表长+1
//算法代码：
    bool Insert_List(SqList &L, int i, int e)
{
    if(i<1||i>L.length)
        return FALSE;
    if(L.length=MaxSize)
        return FALSE;
    for(int j=L.length;j>=i;j--)
    {
        L.data[j]=L.data[j-1];//这里注意元素位序与下标相差1，j-1代表最后一个元素
    }
        L.data[i-1]=e;//第i个位置的数组下标为i-1   e是要插入的元素
    L.length++;
    return OK;
}
---插入后必须保证元素是相邻连续的（考虑范围）
---表不满时可以插入（考虑存储空间）

---插入操作的时间复杂度：最好即在最后一个位置插入 O(1)，最坏在最前位置插入 O(n)，P=1/(n+1)，平均n/2；

//删除操作：删除第i个位置的元素
//算法思想：----步骤
1.判断插入的位置是否合法     //考虑健壮性
2.将要删除的元素赋值个e
3.将第i个元素之后的元素前移
4.表长-1
//算法代码:
    bool Delete_List(SqList &L, int i, &e)
{
    if(i<1||i>L.length)
        return FALSE;
    e=L.data[i-1];       //把要删除的元素用e返回
    for(j=i;j<L.length;j++)
    {
        L.data[j]=L.data[j+1]; //元素前移
    }
    L.length--;
    return OK;
}

---删除操作的时间复杂度：最好即在最后一个位置删除 O(1)，最坏在最前位置删除O(n)，P=1/n ，平均(n-1)/2；

顺序表元素的查找

顺序表有两种查找方式：按位查找和按值查找

1.按位查找：查找第i个位置的元素，返回数组下标
//算法思想：
1.判断查找的范围是否合法
2.返回下标
该算法时间复杂度为 O(1)---随机存取--易查找
bool Get_List(SqList &L, int i)
{
    if(i<1||i>L.length)
        return FALSE;
    return i-1;  //返回位序    若返回元素值：return L.data[i-1];
}
//-----------------------------------------
2.按值查找：查找表中元素值等于x的元素，返回位序
//算法思想：
1.遍历表，查找值为x的元素值
2.返回下标
该算法时间复杂度为 O(n)
int Locate_List(SqLIst L, ElemType x)
{
    int i; //下标
    for(i=0;i<L.length;i++)
    {
        if(L.data[i]==x)  //下标为i的元素等于x
            return i+1; //返回位序
        return 0;
    } 
}

按位查找的时间复杂度：O(1)  -----随机存取的特性

按值查找的时间复杂度：最好O(1)    最坏O(n)    平均：P=1/n,  O((n+1)/2)