数据结构与算法（二）线性表顺序表达

线性表：由n个数据元素(结点)组成的一个有限序列

        n定义为表的长度，n=0时称为空表

        线性表中的元素必定具有相同特性，数据元素间的关系是线性关系

定义：

ADT List{
    数据对象：D={ai}
    数据关系：R={<ai-1,ai>}
    基本操作：InitList()    DestroyList()    ListInsert()    ListDelete()
}ADT List

顺序存储结构

        把逻辑相邻的数据元素存储在物理上相邻的存储单元中的存储结构。

        顺序存储结构的第1个数据元素a1的存储位置，称作线性表的起始位置或基地址

        顺序存储结构不允许有空的存储单元

        存储位置计算        Loc(ai+1)=Loc(ai)+1

        实现 -> 数组（一维）

        解决线性表长度可变和数组长度不可动态定义的冲突-->使用变量表示顺序表的长度属性

#define LIST_INIT_SIZE 100//初始长度设置为100
typedef struct{
    ElemType elem[LIST_INIT_SIZE];
    int length;//当前长度
}SqList;

           ！！！线性表可以套娃（ElemType可以是自定义数据类型）

        数组动态分配

typedef struct{
    ElemType *data;
    int length;
}SqList;

//可以联动动态内存分配
SqList L;
L.data=(ElemType*)malloc(sizeof(ElemType)*MaxSize);
//释放内存
free(p);
//需要加载 <stdlib.h>

//使用C++表示（new）
int *p1 = new int;
int *p1 = new int(10);//存储了10
//释放内存     delete p;

        参数传递（实参、形参的类型、个数、顺序必须对应）

        参数传递的方法        传值（参数为整型、实型、字符型）

                                         传地址（参数为：指针变量、引用类型、数组名）

        指针作为形参一般会影响源数据的值，但是可以通过以下方法解除（变动地址）

void swap(float *m,float *n)
{
    float*t;//临时指针变量
    t=m;
    m=n;
    n=t;//实际上等于交换了指针地址
}

        数组名作为参数(传递的是数组的首地址、会影响源数据)

void Sub(char b[]){                //void Sub(char* b)
    b[]="world";
}

        引用类型作为参数（会影响源数据，实际上是直接对实参的直接操作<节约时间和空间>）

void swap(float &m,float &n)
{
    float temp;//临时指针变量
    temp=m;
    m=n;
    n=temp;
}

        逻辑位序与物理位序下标相差1

基本操作

        预定义常量

#define TRUE 1
#define FLASE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2

        1.初始化算法

Status InitList_Sq(SqList &L){
    L.elem=new ElemType[MAXSIZE];//按顺序分配空间
    if(!L.elem) exite(OVERFLOW);//内存分配失败
    L.length=0;//空表长度为0
    return OK;
}

        2.销毁线性表

void DestroyList(SqList &L){
    if(L.elem) delete L.elem;//释放存储空间
}

        3.清空线性表

void ClearList(SqList &L){
    L.length=0;//长度置0
}

        4.求线性表长度

int GetLength(SqList L){
    return (L.length);
}

        5.判断线性表是否为空

int IsEmpty(SqList L){
    if(L.length == 0)    return 1;
    else return 0;
}

        6.线性表取值

int GetElem(SqList L,int i,ElemType &e){
    if(i<1||i>L.length) return ERROR;
    e = L.elem[i-1];//位置换算
    return OK;
}

        7.按值查找

int LocateElem(SqList L,ElemType e){
    for(i=0;i<L.length;i++)
        if(L.elem[i]==e) return i+1;//成功找到
    return 0;//查找失败
}

                平均查找长度ASL(Average Search Length)：需要与给定值比较的关键字的期望值

                                                             ，查找算法的时间复杂度为O(n)

                                        （找到地i个记录需要比较的次数X第i个记录被找到的概率<>）

          8.线性表插入

Status ListInsert_Sq(SqList &L,int i,ElemType e){
    if(i<1||i>L.length+1) return ERROR;//i不合法
    if(L.length == MAXSIZE) return ERROR;//存储空间已满
    for(j=L.length-1;j>=i-1;j++)
        L.elem[j+1]=L.elem[j];    //循环后移
    L.elem[i-1]=e;//放入指定位置
    L.length++;//长度+1
    return OK;
}

                        平均移动次数=n/2，插入算法的时间复杂度为O(n)

        9.删除元素

Status ListDelete_Sq(SqList &L,int i){
    if(i<1||i>L.length) return ERROR;//i不合法
    for(j=i;j<L.length-1;j++)
        L.elem[j-1]=L.elem[j];//前移一位
    L.length--;
    return OK;
}

                        平均移动次数,删除算法的时间复杂度为O(n)

顺序表的优缺点

        存储密度大（节点本身占存储量）

        可以随机取表中任意元素

缺点

        插入、删除某个元素时需要移动大量元素

        浪费存储空间

        属于静态存储形式，数据元素个数不能自由扩张