数据结构 --- c语言实现顺序表

线性表

  • 零个或多个数据元素 组成的有限序列,除了头部元素和尾部元素之外,其他的所有元素只有一个前驱元素(前面那个数据)

  • 线性表包括数据结构中的:数组,单链表,双链表 ,循环链表(尾部可以指向头部)等

顺序表(数组的操作)

  • 也是一个线性表

  • 用数组描述数据元素物理存储的连续性,实际上就是一个数组的操作

  • 理解为数组的操作即可 ---> 用来封装数组的常规操作(增、删、改、查)

  • 采用顺序存储描述的线性表叫做顺序表

  • 要知道顺序表的长相,抽象结构体代码的根本

数据结构 --- c语言实现顺序表_第1张图片

45只有一个前驱元素(45前面只有一个元素12)

广义表(线性表的拓展)

  • 对前驱节点 | 前驱元素无任何限制

  • 深度的概念:看( )个数,不是看元素个数

了解广义表的表示方式:

  • 空表 E = ();  深度0

  • L = (a,b) 或  L (a,b);两个元素的表,表示:表中有a,b两个元素,长度为2      深度1

  • A = (x,L) = (x,(a,b));广义表中还有一个表叫L表,A表中有2个元素(其中一个为正常的数据,称为原子,另一个还是一个表)     深度2

  • B = (A,L) = ((a,b),(a,b,c));其他的组合情况:有两个子表,A表中有2个元素,L表中有3个元素    深度2

顺序表的实现

  • 用数组描述

  • maxSize:记录最大容量的变量

  • curSize:记录当前元素个数的变量(容器)

  • (顺序表中的定义需要有一个一级指针去做内存申请):定义一个数组指针 | 动态内存申请变成一个数组

sqlist.h

#pragma once
#include 
#include 
#include           //断言|用于判空处理|申请内存可能失败
#define MAX 10		         //最大元素个数
typedef int DataType;        //数据通用性处理|可以给数据类型定义别名
//结构体的抽象->抽象长相
enum INFO {OK=1,ERROR=-1};   //枚举变量类型 -1:错误信息
typedef struct 
{
	DataType* dataMemory;	 //一级指针动态内存申请变成一维数组
	int maxSize;		     //最大元素个数->容量
	int curSize;			 //当前元素个数
}Sqlist,*LPSqlist;           //结构体的别名|结构体指针别名

创建顺序表 

  • 用一个指针表示一个结构体变量,返回的是一个指针,创建过程就是初始化数据,有几个数据成员就给几个数据成员初始化即可

  • 任何一种结构都是一个结构体变量,只是表达方式不一样

//声明
LPSqlist createSqlist(int maxSize);	

//实现  
LPSqlist createSqlist(int maxSize)       //参数:最大值
{
    //创建过程,就是初始化数据->动态内存申请把指针变成变量
    LPSqlist sqlist = (LPSqlist)malloc(sizeof(Sqlist));
    assert(sqlist);                      //断言处理
    //给变量中的东西初始化
    sqlist->curSize = 0;
    sqlist->maxSize = maxSize;
    //指针变成一个数组->数组的内存需要二次申请
    sqlist->dataMemory = (DataType*)malloc(sizeof(DataType)*maxSize);
    assert(sqlist->dataMemory);
    return sqlist;
}
//sqlist中的一级指针也需要做内存申请 申请为数组从而可以存放多个数据

任何数据结构中都有的万金油函数 

//声明
int size(LPSqlist sqlist);     //获取当前的元素个数(或者返回bool类型)
int	empty(LPSqlist sqlist);    //判断是否为空

//实现
int size(LPSqlist sqlist)             
{
    if (sqlist == NULL)        //大前提:sqlist不等于空
        return ERROR;
    return sqlist->curSize;
}
int empty(LPSqlist sqlist)
{
    if (sqlist == NULL)
        return ERROR;
    return sqlist->curSize==0; //判断当前的curSize是不是为0
}

顺序表的增删改查的实现  

获取顺序表中的元素---通过下标去获取元素

  • 参数:获取哪个顺序表中的元素 

  • 注意:表不能为空 & 下标是否满足要求

  • 下标不合格的情况:当前元素个数 curSize < 要访问的下标 index

数据结构 --- c语言实现顺序表_第2张图片

//声明
DataType	getData(LPSqlist sqlist, int index);

//实现
//参数: LPSqlist sqlist:获取哪个顺序表中的元素  int index:通过下标去获取元素
DataType getData(LPSqlist sqlist, int index) 
{
    if (sqlist == NULL||sqlist->curSize==0)                 //为空(短路)
    {
        printf("sqlist is empty,unable to get......\n");    //错误提示 无法获取
        return ERROR;
    }
    if (sqlist->curSize < index)                           //下标是否满足要求?
    {
        printf("index is invalid,unable to get......\n");  //错误提示 invalid无效
        return ERROR;
    }
    //注意:index是第几个元素 第1个元素,第2个元素...没有第0个元素的概念
    return sqlist->dataMemory[index-1];                    //下标正确 直接返回
}

无序顺序表的插入

  • 元素不存在顺序,直接插到顺序表中即可

  • 参数:插入的顺序表 插入的下标  插入的数据

  • 顺序表的插入操作就是数组的插入操作

  • 数组实现的数据结构,放进去要考虑满的状态(链表不需要),拿出来要考虑空的状态

方案1 (依次交换)

  • 把要插入的元素放在最后面      

  • 让最后面的元素一直与前面的元素依次交换到指定的位置

数据结构 --- c语言实现顺序表_第3张图片

int insertSqlist(LPSqlist sqlist, int index, DataType data)
{
    //大前提:无法插入
    if (sqlist == NULL) 
    {
        printf("sqlist is empty,unable to insert......\n");
        return ERROR;
    }
    //满的情况:无法插入
    if (sqlist->curSize == sqlist->maxSize) 
    {
        printf("sqlist is full,unbale to insert......\n");
        return ERROR;
    } 
    //index==0 curSize==0 第一次插入特殊情况需要做判断
    if (index == 0) 
    {
        sqlist->dataMemory[sqlist->curSize++] = data;           //插入数据 后置++即可
        return OK;
    }
    //index为其他值,看下标是否满足要求 第一次插只能用index == 0的情况
    if (sqlist->curSize < 1 || sqlist->curSize < index) 
    {
        printf("index is invalid,unable to insert......\n");    //下标无效 无法做插入 
        return ERROR;
    }
    //其他情况正常插入
        int pos = sqlist->curSize;                              //pos==最后一个下标
        sqlist->dataMemory[pos] = data;                         //插在最后面 直接把元素插在当前下标下即可
    //调整位置
    while (pos != index)             
    {                                                           //定义一个temp做交换
        DataType temp = sqlist->dataMemory[pos];                //第5个元素(index[0]-[4])
        sqlist->dataMemory[pos] = sqlist->dataMemory[pos - 1];  //交换pos和pos-1的位置
        sqlist->dataMemory[pos - 1] = temp;                     //把pos-1的值置为temp
        pos--;
    }
        sqlist->curSize++;                                      //插入成功后curSize++
}
/*测试代码 参数:插入的下标 插入的元素 都是在第1个位置插入
  第一次插入在下标[0]插入0 第一个元素
  在第1个位置插入1
  在第1个位置插入2
  在第4个位置插入444
  ...*/
	LPSqlist sqlist = createSqlist(MAX);
	printf("test insert:\n");
	insertSqlist(sqlist, 0, 0);   //0
	insertSqlist(sqlist, 1, 1);   //1 0
	insertSqlist(sqlist, 1, 2);   //2 1 0
	insertSqlist(sqlist, 1, 3);   //3 2 1 0
	insertSqlist(sqlist, 4, 444); //3 2 1 444 0
    printSqlist(sqlist);

方案2 (挪位置)

  • 在第3个位置插入666 
  • 先挪位置,再做插入 把最后一个元素999挪到curSize的位置,再把77挪到999的位置...

  • 要从后面的元素开始挪(把k-1的值赋给k),如果从前面的元素开始挪,25会把77覆盖

数据结构 --- c语言实现顺序表_第4张图片

for (int k = sqlist->curSize; k >= index; k--) 
{
    sqlist->dataMemory[k] = sqlist->dataMemory[k - 1];    //把k-1的值赋给k
}
    sqlist->dataMemory[index - 1] = data;                 //插入的第几个元素:在数组下标中一定是index-1
    sqlist->curSize++;
    return OK;

顺序表的打印---数组的打印

void printSqlist(LPSqlist sqlist)
{
    if (sqlist == NULL||sqlist->curSize==0)     //两种为空的情况 无法打印
    {
        printf("sqlist is empty,unable to print......\n");
        return;
    }
    //能够打印
    for (int i = 0; i < sqlist->curSize; i++) 
    {
        printf("%d\t", sqlist->dataMemory[i]);  //打印数组
    }
    printf("\n");
}

顺序表的删除(伪删除)---数组没有办法释放单一内存

  • 参数:要删除的表 要删除第几个元素(通过序号做删除)

  • 25是要删除的位置,先把77挪到25的位置,再把999挪到77的位置 

  • 只是77把25给覆盖了(逻辑上的删除),没有处理999的内存,元素999还在

  • 真正的删除是curSize从5变成了4,把记录大小的curSize做 - - 运算

数据结构 --- c语言实现顺序表_第5张图片

int deleteSqlist(LPSqlist sqlist, int index)
{
    if (sqlist == NULL || sqlist->curSize == 0)            //表为空无法删除
    {
        printf("sqlist is empty,unable to delete......\n");
        return ERROR;
    }
    if (sqlist->curSize < index)                           //判断下标是否满足规则
    {
        printf("index is invalid,unbale to delete......\n");
        return ERROR;
    }
    for (int k = index - 1; k < sqlist->curSize; k++) 
    {
        sqlist->dataMemory[k] = sqlist->dataMemory[k + 1]; //把k+1的值挪到k的位置
    }
    sqlist->curSize--;    //伪删除
    return OK;
}

//测试代码
    printf("test delete:\n");    //3 2 1 444 0
	deleteSqlist(sqlist, 4);     //3 2 1 0
	printSqlist(sqlist);

头插 & 尾插 

void push_front(LPSqlist sqlist, DataType data)   //头部插入
{
    insertSqlist(sqlist, 1, data);                //在第一个位置插入数据
}
void push_back(LPSqlist sqlist, DataType data)    //尾部插入
{
    if (sqlist == NULL)                           //为空无法插入
    {
        printf("sqlist is empty,unable to pushback");
        return;
    }
    if (sqlist->curSize == sqlist->maxSize)       //满了也无法做插入
    {
        printf("sqlist is full,unable to pushback");
        return;
    }
    sqlist->dataMemory[sqlist->curSize++] = data; //能够插入 插在最后面 后置++
}

//测试代码
    printf("test push:\n");
	push_front(sqlist, 666);    //666 3 2 1 0
	push_back(sqlist, 999);     //666 3 2 1 0 999
	printSqlist(sqlist);

头删 & 尾删 

void pop_front(LPSqlist sqlist)            //头部删除
{
    deleteSqlist(sqlist, 1);               //删除第一个位置
}
void pop_back(LPSqlist sqlist)             //尾部删除
{
    deleteSqlist(sqlist, sqlist->curSize); //删除最后一个位置
}

//测试代码
    pop_front(sqlist);    //666 3 2 1 0 999
    pop_back(sqlist);     //3 2 1 0 999
    printSqlist(sqlist);  //3 2 1 0

顺序表的查找---通过元素去找下标 

  • 按数据去查找,返回找到数据的下标

int searchSqlist(LPSqlist sqlist, DataType data)
{
    if (sqlist == NULL)                    //为空无法查找
    {
        printf("sqlist is empty,unable to search......\n");
        return ERROR;                      //数组下标没有-1
    }
    //遍历数组
    for (int i = 0; i < sqlist->curSize; i++) 
    {
        if (sqlist->dataMemory[i] == data) //当前元素==data    
        {
            return i;                      //返回下标
        }
    }
    return ERROR;                          //没找到返回ERROR
}

//测试代码
    int pos = searchSqlist(sqlist, 3);     //查找元素:3 
    printf("pos:%d\n", pos);	           //输出:元素3在数组下标[0]的位置 pos:0

有序顺序表的问题---有序性插入

  • 插入后的序号由元素决定

  • 直接插入元素,不需要根据序号做插入,会自动根据数据做排序

  • 注意是在插入时做排序,不是先插完再排序

 数据结构 --- c语言实现顺序表_第6张图片

数据结构 --- c语言实现顺序表_第7张图片

void insert_sort(LPSqlist sqlist, DataType data)
{
    if (sqlist == NULL)                     //为空无法插入
    {
        printf("sqlist is empty,unable to insert......\n");
        return;
    }
    if (sqlist->curSize == sqlist->maxSize) //满的情况无法插入
    {
        printf("sqlist is full,unable to insert......\n");
        return;
    }
    if (sqlist->curSize == 0)                //直接插入
    {
        sqlist->dataMemory[sqlist->curSize++] = data;
    }                                        //不等于0的情况 直接插在最后面
    /* int pos = sqlist->curSize; */
    sqlist->dataMemory[sqlist->curSize/* pos */] = data;
    for (int k = sqlist->curSize;k > 0; k--) //k 等于最后一个下标 k <= 0 也要退出循环
    {
        if (sqlist->dataMemory[k] < sqlist->dataMemory[k - 1]) //交换
        {
            DataType temp = sqlist->dataMemory[k];    
            sqlist->dataMemory[k] = sqlist->dataMemory[k - 1];
            sqlist->dataMemory[k - 1] = temp;
        }
        else 
        {
            break;                          //其他情况:大于|等于的情况 直接break即可
        }
    }
    sqlist->curSize++;                      //插入成功后++
}
//测试代码
    LPSqlist sortSqlist = createSqlist(MAX);
    insert_sort(sortSqlist, 1);
	insert_sort(sortSqlist, 100);
	insert_sort(sortSqlist, 77);
	insert_sort(sortSqlist, -1);
	printSqlist(sortSqlist);                 //-1 1 1 77 100

销毁顺序表 

void destroySqlist(LPSqlist* sqlist)
{
    if (*sqlist == NULL) 
    {
        printf("sqlist is empty, unable to destory......\n");
        return;
    }
    free((*sqlist)->dataMemory);
    free(*sqlist);
    *sqlist = NULL;
}
//测试代码
    destroySqlist(&sortSqlist);
    destroySqlist(&sqlist);

你可能感兴趣的:(数据结构,数据结构,顺序表,线性表)