数据结构线性表

线性表-顺序表（索引）

• 特点
  • 基本操作
    • 定义SqLlist
    • InitList(&L): 初始化操作，建立一个空的线性表L
    • LocateElem(L,e): 在线性表L中查找与给定值e相等的元素,返回位序数

    - GetElem(L,i): 按位查找，获取L中第i个元素的值
    - ListInsert(&L,i,e): 在线性表L中的第i个位置插入新元素e
    - ListDelete(&L,i,&e): 删除线性表L中第i个位置元素，并用e返回其值

 - 完整内容汇总

1.顺序表存储特点

①随机访问，通过首地址和元素序号在时间O(1)内找到元素
②存储密度高，每个节点只存储数据元素
③逻辑相邻元素物理上也相邻，故插入和删除需要移动大量元素

2.1.定义一个顺序表(采用一维数组静态分配)

                #define Maxsize 50
                typedef int ElemType; //这里重命名下 表示不同的数据类型（此处指的是int）

                //静态分配指定长度大小
                #define MaxSize 5  //定义最大长度注意不能写=不能打；号
                typedef struct {
                    ElemType data[MaxSize];//使用静态数组存放数据元素
                    int  length;//顺序表当前的长度
                }SqList;//顺序表的类型定义

2.2.初始化

                Void InitList(SqList &L){
                    for (int i = 0; i < MaxSize; i++)
                        {
                            L.data[i] = 0;//初始化将所有元素设置为0
                        }
                        L.length = 0;//将长度设置为0；(必须要设置为0)
                    }

2.3.按值查找

                Elemtype LocateElem(SqList &L,Elemtype e){
                   for (int i = 0; i < L.length; i++)
                    {
                        if (L.data[i]==e)
                        {
                            return i + 1;
                        }
                    }   
                }

2.4.按位查找

                bool GetElem(SqList L,int i,ElemType &e) {
                    if (L.length==0 || i<1 || i>L.length)
                    {
                        return false;
                    }
                    e = L.data[i-1];
                    return true;
                }

2.5.插入操作（时间复杂度,最好O(1),最坏O(n),平均O(n)）

• 在L的第i个位置插入e ,判断i是否合法,不合法 返回false,插入失败；
• 否则将i个元素及其后面的所有元素依次后移动一位

                //基于静态分配定义第i个节点插入操作
                bool ListInsert(SqList &L,int i,ElemType 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--)
                    {
                        L.data[j] = L.data[j-1];//将元素依次往后移动一位（此处下标是从0开始）
                    }

                    L.data[i - 1] = e;//在位置i处即数组下标i-1防止e
                    L.length++;
                    return true;
                }

2.6.删除操作 （时间复杂度,最好O(1),最坏O(n),平均O(n)

                bool ListDel(SqList &L,int i,ElemType &e) {
                    if (i < 1 || i > L.length)
                        return false;
                    e = L.data[i - 1];
                    for (int j= i; j < L.length; j++)
                    {
                        L.data[j - 1] = L.data[j];
                    }
                    L.length--;
                    return true;
                }

3.汇总

                #include <iostream>
                using namespace std;

                typedef int ElemType; //这里重命名下 表示不同的数据类型（此处指的是int）

                //静态分配指定长度大小
                #define MaxSize 5  //定义最大长度注意不能写=不能打；号
                typedef struct {
                    ElemType data[MaxSize];//使用静态数组存放数据元素
                    int  length;//顺序表当前的长度
                }SqList;//顺序表的类型定义

                //初始化
                void InitSqlList(SqList &L) {
                    for (int i = 0; i < MaxSize; i++)
                    {
                        L.data[i] = 0;//初始化将所有元素设置为0
                    }
                    L.length = 0;//将长度设置为0；(必须要设置为0)
                }


                #define InitSize 100
                typedef struct {
                    ElemType* data; //指针指向动态分配的数组
                    int Msize, Length;//最大容量和当前长度
                }SeqList;


                //动态列表初始化
                void InitList(SeqList& L) {
                    L.data = (int*)malloc(InitSize * sizeof(int));//初始化长度
                    L.Length = 0;
                    L.Msize = InitSize;
                }

                bool GetElem(SqList L, int i, ElemType& e) {
                    if (L.length == 0 || i<1 || i>L.length)
                    {
                        return false;
                    }
                    e = L.data[i - 1];
                    return true;
                }


                //动态增加列表长度
                void IncreaseSize(SeqList &L,int len) {
                    int* p = L.data; //p指针指向与*data指向一致
                    //L.data = new int[InitSize + len];
                    L.data = (int*)malloc(sizeof(int) * (InitSize + len)); //申请一片新空间 L的data指向该新空间
                    for (int i = 0; i <L.Msize; i++)
                    {
                        L.data[i] = p[i];//将之前存储的值赋值给新空间
                    }
                    L.Msize = L.Msize + len; //将l的maxsize 容量扩大
                    free(p);//释放p
                }


                //基于静态分配定义第i个节点插入操作
                bool ListInsert(SqList &L,int i,ElemType 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--)
                    {
                        L.data[j] = L.data[j-1];//将元素依次往后移动一位（此处下标是从0开始）
                    }

                    L.data[i - 1] = e;//在位置i处即数组下标i-1防止e
                    L.length++;
                    return true;
                }

                /// <summary>
                /// 删除第i个元素（i指的位序数）
                /// </summary>
                /// <param name="L">线性表</param>
                /// <param name="i">第i个</param>
                /// <param name="e">返回删除的元素</param>
                /// <returns></returns>
                bool ListDel(SqList &L,int i,ElemType &e) {
                    if (i < 1 || i > L.length)
                        return false;
                    e = L.data[i - 1];
                    for (int j= i; j < L.length; j++)
                    {
                        L.data[j - 1] = L.data[j];
                    }
                    L.length--;
                    return true;
                }

                /// <summary>
                /// 顺序表按值查找返回位序数
                /// </summary>
                /// <param name="L">顺序表</param>
                /// <param name="e">查找的元素的值</param>
                /// <returns></returns>
                int LocateElem(SqList L, ElemType e) {
                    int i;
                    for (int i = 0; i < L.length; i++)
                    {
                        if (L.data[i]==e)
                        {
                            return i + 1;
                        }
                    }
                    return 0;
                }

                int main() {
                    SqList L;
                    InitSqlList(L);
                    
                    for (int i = 0; i < MaxSize-1; i++)
                    {
                        L.data[i] = i + 1;
                        printf("第【%d】的元素为【%d】\n", i, L.data[i]);//给前四个赋值
                        L.length++;
                    }
                    
                    //将66插入位序为2的节点

                    ListInsert(L,2,66);
                    printf("-------------插入后的------------------\n");
                    for (int i = 0; i < MaxSize; i++)
                    {
                        printf("第【%d】的元素为【%d】\n", i, L.data[i]);//给前四个赋值
                        
                    }
                    int del;
                    ListDel(L, 4, del);
                    printf("-------------删除后的------------------\n");
                    for (int i = 0; i <L.length; i++)
                    {
                        printf("第【%d】的元素为【%d】\n", i, L.data[i]);//给前四个赋值

                    }

                    尝试“不设置默认值”打印整个data数组
                    //for (int i = 0; i <MaxSize; i++)
                    //{
                    //	printf("data[%d]=%d\n", i);
                    //}

                    return 0;
                }