静态顺序表

最新推荐文章于 2023-01-25 16:37:09 发布
最新推荐文章于 2023-01-25 16:37:09 发布
阅读量287 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CH121625/article/details/80522947
版权

代码实现顺序表的操作函数

// 值类型
typedef int DataType;

typedef struct SeqList {
DataType data; // 值
int size; // 数量
} SeqList;

// 初始化
void SeqListInit(SeqList *pSL);

// 尾部插入
void SeqListPushBack(SeqList *pSL, DataType data);

// 头部插入
void SeqListPushFront(SeqList *pSL, DataType data);

// 尾部删除
void SeqListPopBack(SeqList *pSL);

// 头部删除
void SeqListPopFront(SeqList *pSL);

// 按下标插入，pos 的范围是 [0, size]
void SeqListInsert(SeqList *pSL, int pos, DataType data);

// 按下标删除，pos 的范围是 [0, size)
void SeqListErase(SeqList *pSL, int pos);

// 按值删除，只删遇到的第一个
void SeqListRemove(SeqList *pSL, DataType data);

// 按值删除，删除所有的
void SeqListRemoveAll(SeqList *pSL, DataType data);

// 清空
void SeqListClear(SeqList *pSL);

// 按值查找，返回第一个找到的下标，如果没找到，返回 -1
int SeqListFind(SeqList *pSL, DataType data);

// 判断是否为空，1 表示空， 0 表示不空
int SeqListEmpty(SeqList *pSL);

// 返回数量
int SeqListSize(SeqList *pSL);

// 销毁
void SeqListDestroy(SeqList *pSL);

Seqlist.h

#ifndef _Seqlist__H_
#define _Seqlist__h_
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<string.h>

#define MAX 100
typedef int DataType;

typedef struct Seqlist {
    int arr[MAX]; // 值 
    int size; // 数量 
} Seqlist,*pSeqlist;

void TestSeqlist();
void SeqlistInit(Seqlist *pSl);
void SeqlistPushBack(Seqlist *pSl, DataType data);
void SeqlistPushFront(Seqlist *pSl, DataType data);
void SeqlistPopBack(Seqlist *pSl);
void SeqlistPopFront(Seqlist *pSl);
void SeqlistInsert(Seqlist *pSl, int pos, DataType data);
void SeqlistErase(Seqlist *pSl, int pos);
void SeqlistRemove(Seqlist *pSl, DataType data);
void SeqlistRemoveAll(Seqlist *pSl, DataType data);
void SeqlistClear(Seqlist *pSl);
int SeqlistFind(Seqlist *pSl, DataType data);
void SeqlistBubbleSort(Seqlist *pSl);
void SeqListSelectSort(Seqlist *pSl);
int SeqlistEmpty(Seqlist *pSl);
int SeqlistSize(Seqlist *pSl);
void SeqlistDestroy(Seqlist *pSl);
void Seqlistprint(Seqlist *pSl);

#endif

main.c
#include"Seqlist.h"


int main()
{
    TestSeqlist();
    system("pause");
    return 0;
}
Seqlist.c

#include"Seqlist.h"


void SeqlistInit(Seqlist *pSl)//初始化
{
    pSl->size = 0;
    memset(pSl->arr, 0, sizeof(DataType)*MAX);
}
//尾插
void SeqlistPushBack(Seqlist *pSl, DataType data)
{
    assert(pSl != NULL);
    if (pSl->size >= MAX)
    {
        printf("顺序表已满\n");
        return;
    }
    pSl->arr[pSl->size] = data;
    pSl->size++;

}//头插
void SeqlistPushFront(Seqlist *pSl, DataType data)
{
    assert(pSl != NULL);
    if (pSl->size >= MAX)
    {
        printf("顺序表已满\n");
        return;
    }
    int i = 0;
    for (i = pSl->size - 1; i >= 0; i--)
    {
        pSl->arr[i + 1] = pSl->arr[i];
    }
    pSl->arr[0] = data;
    pSl->size++;
}

//尾删
void SeqlistPopBack(Seqlist *pSl)
{

    assert(pSl != NULL);
    assert(pSl->size > 0);
    if (pSl->size == 0)
    {
        printf("顺序表为空\n");
        return;
    }
    pSl->size--;
}
//头删
void SeqlistPopFront(Seqlist *pSl)
{
    assert(pSl != NULL);
    if (pSl->size == 0)
    {
        printf("顺序表为空\n");
        return;
    }
    int i = 0;
    for (i = 1; i<pSl->size; i++)
    {
        pSl->arr[i - 1] = pSl->arr[i];
    }

    pSl->size--;
}

//随机位置插入
void SeqlistInsert(Seqlist *pSl, int pos, DataType data)
{                                             
    assert(pSl != NULL);
    assert(pos >= 0 && pos <= pSl->size);

    if (pSl->size >= MAX)
    {
        printf("静态表已满");
        return;
    }

    int i = 0;
    for (i = pSl->size - 1; i >= pos; i--)
    {
        pSl->arr[i + 1] =pSl->arr[i];
    }
    pSl->arr[pos] = data;
    pSl->size++;
}

void SeqlistErase(Seqlist *pSl, int pos)//随机位置删除
{
    assert(pSl != NULL);
    if (pSl->size == 0)
    {
        printf("顺序表为空\n");
        return;
    }
    assert(pos >= 0 && pos < pSl->size);
    int i = 0;
    for (i = pos ; i < pSl->size-1; i++)
    {
        pSl->arr[i] = pSl->arr[i+1];
    }
    pSl->size--;
}

int SeqlistFind(Seqlist *pSl, DataType data)//查找数
{
    assert(pSl != NULL);
    int i = 0;
    for (i = 0; i < pSl->size; i++)
    {
        if (pSl->arr[i] == data)
        {
            return i; 
        }
    }
    return -1;
}

void SeqlistRemove(Seqlist *pSl, DataType data)//删除第一个出现的数
{
    int pos=SeqlistFind(pSl,data);
    if (pos != -1)
    {
        SeqlistErase(pSl, pos);
    }
}
void SeqlistRemoveAll(Seqlist *pSl, DataType data)//删除所有出现的数
{
    /*int pos;
    while ((pos = SeqlistFind(pSl, data)) != -1)
    {
        SeqlistErase(pSl, pos);
    }*/
    //1.重新申请空间，遍历原来的数组，如果不是要删除的，就copy
    //到新的空间
    //2.把新空间的数据copy回原来的数组。
    //3.要把copy的数量就是新的size。
    //4.free新空间。


    //俩个下标，空间下标，遍历下标。
    //逢要删的，跳过遍历下标，计数器++。
    //不是要删的，就把遍历对应的值copy到空间
    //Unitl ,遍历结束
    //size-计数器。
    int spacel = 0;
    int count = 0;
    int i = 0;
    for (i = 0; i < pSl->size; i++)
    {
        if (pSl->arr[i] == data)
        {
            count++;
        }
        else
        {
            pSl->arr[spacel] = pSl->arr[i];
            spacel++;
        }

    }

    pSl->size -= count;

}
void Swap(DataType *a, DataType *b)
{
    int tmp;
    tmp = *a;
    *a = *b;
    *b = tmp;
}


void SeqlistBubbleSort(Seqlist *pSl)
{
    int i = 0;
    int j = 0;
    for (i = 0; i < pSl->size - 1; i++)
    {
        for (j = 0; j < pSl->size - i - 1; j++)
        {
            if (pSl->arr[j] > pSl->arr[j+1])
            {
                Swap(pSl->arr + j, pSl->arr+(j + 1));

            }
        }

    }
}
void SeqListSelectSort(Seqlist *pSl)
{
    int i, j;
    int minPos, maxPos;
    for (i = 0; i < pSl->size / 2; i++)
    {
        minPos = maxPos = i;
        for (j = i; j < pSl->size - i; j++)
        {
            if (pSl->arr[j] < pSl->arr[minPos])
            {
                minPos = j;
            }
            if (pSl->arr[j] > pSl->arr[maxPos])
            {
                maxPos = j;
            }
        }
        Swap(pSl->arr + i, pSl->arr + minPos);
        if (i == maxPos)
        {
            maxPos = minPos;
        }
        Swap(pSl->arr + pSl->size - i - 1, pSl->arr + maxPos);
    }

}


int SeqlistSize(Seqlist *pSl)//顺序表的大小
{
    return pSl->size;
}

int SeqlistEmpty(Seqlist *pSl)//判断是否为空
{
    return pSl->size == 0 ? 1 : 0;
}


void SeqlistClear(Seqlist *pSl)//清空顺序表;
{
    pSl->size = 0;
}


void SeqlistDestroy(Seqlist *pSl)//销毁
{
    ;
}




void Seqlistprint(Seqlist *pSl)
{
    int i;
    for (i = 0; i < pSl->size; i++)
    {
        printf("%d ", pSl->arr[i]);
    }
    printf("\n");
}





 void TestSeqlist()
{
    Seqlist sl;
    SeqlistInit(&sl);//初始化顺序表

    SeqlistPushBack(&sl, 1);//尾插
    SeqlistPushBack(&sl, 2);
    SeqlistPushBack(&sl, 3);
    SeqlistPushBack(&sl, 4);
    Seqlistprint(&sl);

    SeqlistPushFront(&sl, 1);//头插
    SeqlistPushFront(&sl, 2);
    SeqlistPushFront(&sl, 3);
    SeqlistPushFront(&sl, 4);
    Seqlistprint(&sl);


    SeqlistPopBack(&sl);//尾删
    Seqlistprint(&sl);


    SeqlistPopFront(&sl);//头删
    Seqlistprint(&sl);

    SeqlistInsert(&sl,2,5);//随机位置插入
    SeqlistInsert(&sl,4,15);
    Seqlistprint(&sl);

    SeqlistErase(&sl, 3);//随机位置删除
    Seqlistprint(&sl);

    int ret=SeqlistFind(&sl, 15);//查找数

    if (ret == -1)
    {
        printf("没有找到\n");
     }
    else
    {
        printf("找到了，该数下标为:%d\n", ret);
    }

    SeqlistRemove(&sl, 3);//删除第一次出现的数
    Seqlistprint(&sl);

    SeqlistRemoveAll(&sl, 2);//删除所有出现的数
    Seqlistprint(&sl);

    SeqlistPushBack(&sl, 9);
    SeqlistPushBack(&sl, 12);
    SeqlistPushBack(&sl, 10);
    SeqlistPushBack(&sl, 11);
    SeqlistPushBack(&sl, 6);
    Seqlistprint(&sl);


    SeqlistBubbleSort(&sl);//冒泡排序
    Seqlistprint(&sl);

    SeqListSelectSort(&sl);//选择排序
    Seqlistprint(&sl);

    int tmp = SeqlistSize(&sl);//顺序表大小
    printf("%d\n", tmp);

    int r = SeqlistEmpty(&sl);//判断顺序表是否为空
    if (r == 1)
    {
        printf("为空\n");
    }
    else
    {
        printf("不为空\n");
    }

    SeqlistClear(&sl);//清空顺序表
    Seqlistprint(&sl);

 }
CH121625
关注
#C顺序表的静态实现
Sinjiufai的博客
07-13 122
#C顺序表的静态实现 跟着b站吴叔学的 不过被我省略了好多细节。。。 流程#C顺序表的静态实现定义以及引用的头文件函数声明初始化函数具体功能实现测试输出结果 定义以及引用的头文件 #include <stdio.h> #include <string.h> #include <stdlib.h> #include <assert.h> #define MAXSIZE 10 #define ElemType int typedef struct { E
数据结构静态顺序表
diandianqiqi的博客
12-06 222
顺序表：用一段地址连续存储单元依次存储数据元素的线性结构。 #define MAX_SIZE 10 typedef int DataType; struct SeqList {DataType _array[MAX_SIZE]; int _size;//顺序表中元素的个数} 以上代码，就是创建一个顺序表，其中SeqList是整个顺序表的空间而size是顺序表中元素的个数。 接下来我将用静态顺
静态顺序表的概念及实现
Eric_qiushui的博客
04-16 501
静态顺序表，不涉及动态申请空间一、顺序表概念1.首先，顺序表的概念了解一下： 顺序表是在计算机内存中以数组的形式保存的线性表，是指用一组地址连续的存储单元依次存储数据元素的线性结构。线性表采用顺序存储的方式存储就称之为顺序表。顺序表是将表中的结点依次存放在计算机内存中一组地址连续的存储单元中。//顺序表声明 typedef int DataType; #define MAX_SIZE 10 ty
静态链表的增，删，清空，销毁等操作
weixin_43854256的博客
05-18 422
创建slinklist.h文件 #pragma once //静态链表：利用顺序表模拟链表操作，包含两条带头循环链表 //一条为有效数据链表，头结点为0下标；一条为空闲链表，头结点为1下标 #define MAXSIZE 10 typedef struct SNode { int data;//数据 int next;//后继指针，其实为后继节点的下标 }SNode,SLinkList[MAXSIZE],*PSLinkList; //typedef SNode SLinkList[MAXSIZE];
数据结构c++代码（顺序表的代码，包括静态顺序表和动态顺序表）
07-13
顺序表是一种线性结构，它的所有元素在内存中连续存放，可以分为静态顺序表和动态顺序表。静态顺序表通常是在编译时就预分配好固定大小的数组，而动态顺序表则可以根据需要动态地调整其容量。 静态顺序表的优点在于...
数据结构静态顺序表.zip
02-03
在这个“数据结构静态顺序表.zip”压缩包中，包含的是作者用C语言实现的静态顺序表源代码。 首先，让我们深入理解静态顺序表的概念。静态顺序表是一种固定大小的数组，其长度在创建时就已经确定，且在表的整个生命...
【数据结构】2. 顺序表（完整代码实现：顺序表的初始化、销毁、尾插、尾删、任意位置的插入和删除、判空、查找、扩增）
瞌睡的博客
01-29 1084
目录SeqList.hSeqList.ctest.c SeqList.h #pragma once #if 0 //静态顺序表 struct SeqList { int array[MAXSIZE]; int size; // 顺序表中有效元素的个数 }; #endif typedef int DataType; // 动态类型的顺序表 typedef struct SeqList { DataType* array; int capacity; // 表示a
顺序表 —— 初始化、销毁、打印、增加、删除、查找、修改
平淡中造就不平凡
12-31 1832
顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。
顺序表的相关操作（静态&动态）
The Laughing Uncle的博客
09-09 478
静态顺序表 定义 定义结构体 初始化顺序表 销毁顺序表 打印顺序表 插入元素 尾插 头插 任意位置插入元素 删除元素 尾删 头删 任意位置删除 删除遇见的第一个指定元素 删除所有的指定元素 查找指定元素 排序 冒泡排序 选择排序 测试函数 动态顺序表 定义结构体 初始化 销毁 插入 尾插 头插 任意位置插入元素 一般情...
静态顺序表的增删改查
Freedom_的博客
06-13 383
头文件seqList.h#pragma once typedef int DataType; #define MAX_SIZE (100) #include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; #include&lt;assert.h&gt; #include&lt;string.h&gt; typedef struct SeqList{ Da...
【数据结构和算法】实现线性表中的静态、动态顺序表
最新发布
小王学代码
01-25 1290
顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。我们本文讲解了，线性表中的顺序表的使用，我们分别实现了静态和动态的顺序表，这是数据结构的基础，我们接下来讲解的内容是线性表中的链表。
线性表：顺序表（静态分配、动态分配）
LOG_IN_ME的博客
04-21 5387
顺序表：线性表的顺序存储实现。 静态分配方式 静态分配一个数组，由于没有使用动态分配内存的方式（malloc），所以并没有DestroyList(&L)函数，在程序结束后会自动销毁该数组。重要的操作有： InitList(&L) ：初始化顺序表。 ListInsert(&L,i,e)：在L的位序i处插入元素e。 ListDelete(&L,i,&e...
数据结构-静态顺序表
m0_61433144的博客
07-04 1268
顺序表又分为静态顺序表和动态顺序表。对于静态顺序表，在静态分配时，由于数组的大小和空间事先已经固定好了，一旦空间占满，再加入新的数据就会产生溢出，进而导致程序崩溃。
静态顺序表的初始化以及插入删除操作
狂想者
11-01 2668
静态顺序表的初始化以及插入删除操作 1. 首先是静态顺序表结构体的编写 typedef struct { int data[MaxSize]; int length; }Sqlist; 2. 初始化 void InitList(Sqlist *L) { L->length = 0; } 3. 插入操作 bool ListInsert(Sqlist *L,int i,int e){ ...
数据结构—顺序表的销毁
热门推荐
qq_39830449的博客
08-20 1万+
//顺序表的销毁 #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; #define OK 1 #define OVERFLOW -2 #define LIST_INIT_SIZE 10// 线性表存储空间的初始分配量 typedef int Status; //Status是函数数据类型 ，其值是函数结果状态，如OK typedef ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值