数据结构-----顺序表

题目：

#include<stdio.h>
#include<malloc.h>
#define MaxSize 50
typedef char elemType;

typedef struct
{
    
    elemType data[MaxSize];//存放顺序表中的元素
    int length;//存放顺序表的长度
    
}sqlist;//声明顺序表的类型

void createlist(sqlist * &L,elemType a[],int n)//建立整体顺序表
{
    L=(sqlist *)malloc(sizeof(sqlist));
    for(int i=0;i<n;i++)
    L->data[i]=a[i];
    L->length=n;
    

}
void initlist(sqlist * &L)//初始化线性表
{
    L=(sqlist *)malloc(sizeof(sqlist));
    L->length=0;
}

void destroylist(sqlist * &L)销毁顺序表
{
    free(L);
}

bool listempty(sqlist * L)//判断顺序表是否为空
{
    return (L->length==0);
}

int  listlength(sqlist * L)//求线性表的长度
{
    
    return(L->length);    
}

void displist(sqlist *L)//输出线性表
{
    for(int i=0;i<L->length;i++)
    printf("%c",L->data[i]);
    printf("\n");
}

void nizhilist(sqlist *L)//逆序输出顺序表
{
    int i;
    for(i=L->length-1;i>=0;i--)
    {
        printf("%c",L->data[i]);
    }
}

bool getelem(sqlist * L,int i,elemType &e)求出线性表中第i个元素的值
{
    if(i<1||i>L->length)
    return false;
    e=L->data[i-1];
    return true;
}

int locateelem(sqlist * L,elemType e)//查找第一个值域为e的元素的序号
{
    int i=0;
    while(i<L->length&&L->data[i]!=e)
    i++;
    if(i>=L->length)
    return 0;
    else 
    return i+1;
    
}

bool listinsert(sqlist * &L,int i,elemType e)//插入第i个元素
{
    int j;
    if(i<1||i>L->length+1||L->length==MaxSize)
    return false;
    i--;
    for(j=L->length;j>i;j--)
    L-> data[j]=L->data[j-1];
    L->data[i]=e;
    L->length++;
    return true;
    
    }
    
    
void dellist(sqlist *L)  
{  
    int i, j;  
    for (i = 0; i < L->length - 1; i++) {  
        for (j = i + 1; j < L->length; ) {  
            if (L->data[i] == L->data[j]) {  
                // 发现重复元素，移动后续元素并减少长度  
                for (int k = j; k < L->length - 1; k++) {  
                    L->data[k] = L->data[k + 1];  
                }  
                L->length--; // 减少长度  
            } else {  
                j++; // 没有重复，继续检查下一个元素  
            }  
        }  
    }  
}

bool listdelete(sqlist *&L,int i,elemType &e)
{
    int j;
    if(i<1||i>L->length)
    return false;
    i--;
    e=L->data[i];
    for(j=i;j<L->length-1;j++)
    L->data[j]=L->data[j+1];
    L->length--;
    return true;
    
}

//#include"sqlist.cpp"
int main()
{
    sqlist *L;
    elemType e;
    printf("顺序表的基本运算如下:\n");
    
    printf("1.顺序表初始化L\n");
    initlist(L);
    printf("2.依次插入元素1,2,3,4,5\n");
    listinsert(L,1,'1');
    listinsert(L,2,'2');
    listinsert(L,3,'3');
    listinsert(L,4,'4');
    listinsert(L,5,'5');    
    
    printf("3.输出顺序表L：");
    displist(L);
    
    printf("4.逆向输出顺序表L:");
    nizhilist(L);
    printf("\n");
    //printf("4.顺序表L的长度：%d\n",listlength(L));
    //printf("5.顺序表L为%s\n",(listempty(L)?"空":"非空"));
    
    getelem(L,3,e);
    
    printf("5.顺序表L的第三个元素：%c\n",e);
    //printf("7.元素a的位置：%d\n",locateelem(L,'a'));
    //
    //
    
    printf("6.输出顺序表L:");displist(L);
    printf("7.在第4个元素位置上插入元素\n");
    listinsert(L,5,'5');
    listinsert(L,5,'5');
    listinsert(L,5,'6');
    listinsert(L,5,'6');
    listinsert(L,5,'7');    
    //printf("10.删除L的第三个元素\n");
    //listdelete(L,3,e);
    printf("8.输出顺序表L:");
    displist(L);
    
    printf("9.删除顺序表L的重复元素:");
    dellist(L);
    printf("\n");
    
    printf("10.输出顺序表L:");
    displist(L);
    printf("11.释放顺序表L\n");
    destroylist(L);
return 1;
}

顺序表是线性表的一种顺序存储结构，它使用一段连续的存储单元依次存储线性表的数据元素。以下是顺序表的一些主要知识点总结：

1. 定义与结构

• 定义：顺序表是由零个或多个数据元素组成的有限序列，每个元素在逻辑上都有一个确定的位置。
• 结构：顺序表通常采用数组作为底层实现，包括一个数据数组用于存储元素，以及一个整型变量用于记录当前顺序表的长度（元素个数）。

2. 基本操作

• 初始化：创建一个空的顺序表，设置其长度为0。
• 插入：在顺序表的指定位置插入一个新元素，可能需要移动元素以腾出空间。
• 删除：从顺序表的指定位置删除一个元素，并可能需要移动元素以填补空缺。
• 查找：根据给定的元素值或位置，返回元素在顺序表中的位置或值。
• 遍历：按顺序访问顺序表中的每个元素。
• 清空：删除顺序表中的所有元素，使其变为空表。
• 获取长度：返回顺序表中元素的个数。
• 判断是否为空：检查顺序表是否为空。

3. 插入与删除操作的效率

• 插入：在顺序表的第i个位置插入一个元素，需要将第i个位置及其之后的元素都向后移动一位，时间复杂度为O(n)。
• 删除：删除顺序表的第i个元素，需要将第i个位置之后的元素都向前移动一位，时间复杂度同样为O(n)。
• 注意：在顺序表的开始或末尾进行插入和删除操作通常更高效，因为只需要移动较少的元素或不需要移动元素。

4. 顺序表的优缺点

• 优点：
  • 随机访问：可以通过下标直接访问任意位置的元素，时间复杂度为O(1)。
  • 存储密度高：顺序表在物理上是连续的，存储密度高，空间利用率高。
• 缺点：
  • 插入和删除操作效率低：需要移动大量的元素。
  • 存储空间固定：在初始化时需要指定顺序表的最大容量，当顺序表满时，需要进行扩容操作，可能会涉及大量元素的复制。

5. 扩容机制

• 当顺序表已满时，需要进行扩容操作，即分配一块更大的连续存储空间，并将原顺序表中的所有元素复制到新空间中。
• 扩容通常会将原容量扩大一定的倍数（如2倍），以减少扩容操作的频率。
• 扩容操作的时间复杂度较高，但在实际应用中，由于扩容操作的频率较低，通常不会对整体性能产生太大影响。

6. 静态顺序表与动态顺序表

• 静态顺序表：使用静态数组实现的顺序表，其容量在编译时就已确定，无法改变。
• 动态顺序表：使用动态数组（如C语言中的malloc/realloc，C++中的new/delete）实现的顺序表，其容量可以在运行时动态地改变。

7. 应用场景

• 顺序表适用于需要频繁访问元素，但插入和删除操作较少的应用场景。
• 例如，实现堆栈（Stack）和队列（Queue）等数据结构时，可以优先考虑使用顺序表。