静态的顺序表（C语言实现）

最新推荐文章于 2022-08-19 21:52:08 发布
最新推荐文章于 2022-08-19 21:52:08 发布
阅读量247 收藏
点赞数
分类专栏： 数据结构 文章标签： 静态的顺序表 C语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40421919/article/details/80739645
版权

我对于静态的顺序表的理解就是类似于数组来存数据。直接来看代码吧。我一步一步解释。

  • 头文件

#include”SeqList.h”

#ifndef __SEQLIST_H__
#define __SEQLIST_H__

#include<assert.h>
#include<stdio.h>
#include<stdlib.h>
#include<string.h>

#define MAX 10  //存多少数据
typedef int DataType;

typedef struct SeqList
{
    DataType date[MAX];
    int sz;
}SeqList, *pSeqList;

void initSeqList(pSeqList  pseq);
void PushBack(pSeqList  pseq, DataType d); //尾插法
void PopBack(pSeqList pseq);  //尾删
void FrontBack(pSeqList pseq,DataType d); //头插
void PopFront(pSeqList pseq);  //头删
void PrintfSeqList(pSeqList  pseq);  //打印显示
int  Find(pSeqList pseq, DataType d);  //查找d元素，返回位置
void Insert(pSeqList pseq, int pos, DataType d);  //任意位置插入
void Erase(pSeqList pseq,int pos);  //任意位置删除
void Remove(pSeqList pseq, DataType d);  //移除第一个元素d
void TestRemoveAll(pSeqList pseq, DataType d); //移除所有元素d
int Size(pSeqList pseq);  //元素个数
int Empty(pSeqList pseq); //清空
void BubbleSort(pSeqList pseq); //冒泡排序
int BinarySearch(pSeqList pseq, DataType d); //二分查找
int BinarySearch_R(pSeqList pseq, int left, int right, DataType d); //二分查找优化
void selectsort(pSeqList pseq); //选择排序
void SelectSort_op(pSeqList pseq);//选择排序优化

#endif // __SEQLIST_H__

检测函数 test.c

#include"SeqList.h";

void Testbushback() //尾插检测
{
    SeqList seq;
    initSeqList(&seq);
    PushBack(&seq, 1);//尾部插入
    PushBack(&seq, 2);
    PushBack(&seq, 3);
    PushBack(&seq, 4);
    PopBack(&seq);
    PrintfSeqList(&seq);
}

void TestFrontback() //头插检测
{
    SeqList seq;
    initSeqList(&seq);
    FrontBack(&seq, 1); //头部插入
    FrontBack(&seq, 2);
    FrontBack(&seq, 3);
    FrontBack(&seq, 4);
    PopFront(&seq);
    PrintfSeqList(&seq);
}

void TestFind()  //查找元素检测
{
    int pos = 0;
    SeqList seq;
    initSeqList(&seq);
    PushBack(&seq, 1);
    PushBack(&seq, 2);
    PushBack(&seq, 3);
    PushBack(&seq, 4);
    PrintfSeqList(&seq);
    pos = Find(&seq, 4);
    if (-1 == pos)
        printf("不存在\n");
    else
        printf("%d\n", pos);

}

void TestInsert() //插入元素检测
{
    int pos = 0;
    SeqList seq;
    initSeqList(&seq);
    PushBack(&seq, 1);
    PushBack(&seq, 2);
    PushBack(&seq, 3);
    PushBack(&seq, 4);
    pos = Find(&seq, 3);
    if (pos != -1)
    {
        Insert(&seq, pos, 5);
    }
    PrintfSeqList(&seq);
}

void TestErase()  //删除指定元素检测
{
    int pos = 0;
    SeqList seq;
    initSeqList(&seq);
    PushBack(&seq, 1);
    PushBack(&seq, 2);
    PushBack(&seq, 3);
    PushBack(&seq, 4);
    pos = Find(&seq, 3);
    if (pos != -1)
    {
        Erase(&seq, 3);
    }
    PrintfSeqList(&seq);
}

void TestRemove()  //删除链表中指定的元素的第一个
{
    SeqList seq;
    initSeqList(&seq);
    PushBack(&seq, 1);
    PushBack(&seq, 2);
    PushBack(&seq, 3);
    PushBack(&seq, 4);
    PushBack(&seq, 1);
    PrintfSeqList(&seq);
    Remove(&seq, 1);
    PrintfSeqList(&seq);

}

void TestRemoveAll () //删除指定全部元素
{
    SeqList seq;
    initSeqList(&seq);
    PushBack(&seq, 1);
    PushBack(&seq, 1);
    PushBack(&seq, 2);
    PushBack(&seq, 3);
    PushBack(&seq, 4);
    PushBack(&seq, 1);
    PrintfSeqList(&seq);
    RemoveAll(&seq, 1);
    PrintfSeqList(&seq);
}

void TestBubbleSort()  //冒泡排序
{
    SeqList seq;
    initSeqList(&seq);
    PushBack(&seq, 5);
    PushBack(&seq, 4);
    PushBack(&seq, 3);
    PushBack(&seq, 2);
    PushBack(&seq, 1);
    PushBack(&seq, 0);
    BubbleSort(&seq);
    PrintfSeqList(&seq);
}

void TestBinarySearch() //二分查找
{
    int i = 0;
    int pos = 0;
    SeqList seq;
    initSeqList(&seq);
    for (i = 0; i < 10; i++)
    {
        PushBack(&seq, i+1);
    }
    pos = BinarySearch_R(&seq,0,seq.sz-1,7);
    if (pos == -1)
    {
        printf("找不到\n");
    }
    else
    {
        printf("找到了，下标是%d\n",pos);
    }
}

void TestSelectSort() //选择排序
{
    int i = 0;
    int pos = 0;
    SeqList seq;
    initSeqList(&seq);
    for (i = 10; i > 0; i--)
    {
        PushBack(&seq, i);
    }
    PrintfSeqList(&seq);
    selectsort(&seq);
    PrintfSeqList(&seq);

}

void TestSelectSearch()  //选择排序优化
{
    int i = 0;
    int pos = 0;
    SeqList seq;
    initSeqList(&seq);
    for (i = 10; i > 0; i--)
    {
        PushBack(&seq, i);
    }
    PrintfSeqList(&seq);
    SelectSort_op(&seq);
    PrintfSeqList(&seq);
}

int main()
{

    Testbushback();
    printf("\n");
    TestFrontback();
    printf("\n");
    TestFind();
    printf("\n");
    TestInsert();
    printf("\n");
    TestErase();
    printf("\n");
    TestRemove();
    printf("\n");
    TestRemoveAll();
    printf("\n");
    TestBubbleSort();
    printf("\n");
    TestBinarySearch();
    printf("\n");
    TestSelectSort();
    printf("\n");
    TestSelectSearch();
    system("pause");
}

SeqList.c

#include"SeqList.h";

void initSeqList(pSeqList pSeq)   //初始化顺序表
{
    assert(pSeq);
    pSeq->sz = 0;
    memset(pSeq->date, 0, sizeof(pSeq->date));
}


void PushBack(pSeqList  pSeq, DataType d)  //尾插
{
    assert(pSeq);
    if (pSeq->sz == MAX)
    {
        printf("链表已满，不能插入\n");
        return;
    }
    pSeq->date[pSeq->sz] = d;
    pSeq->sz++;
}

void FrontBack(pSeqList pSeq, DataType d)  //头插
{
    assert(pSeq);
    if (pSeq->sz == MAX)
    {
        printf("顺序表已满，无法插入");
        return;
    }
    for (int i = pSeq->sz - 1; i >= 0; i--)
    {
        pSeq->date[i + 1] = pSeq->date[i];
    }
    pSeq->date[0] = d;
    pSeq->sz++;
}

void PopFront(pSeqList pseq)  //尾删
{
    assert(pseq);
    if (pseq->sz == 0)
    {
        printf("顺序表为空，无法删除");
        return;
    }
    for (int i = 0; i < pseq->sz-1; i++)
    {
        pseq->date[i] = pseq->date[i + 1];
    }
    pseq->sz--;
}

void PopBack(pSeqList pseq)  //头删
{
    assert(pseq);
    if (pseq->sz == 0)
    {
        printf("顺序表为空，无法删除\n");
        return;
    }
    return pseq->sz--;
}

void PrintfSeqList(pSeqList  pSeq)  //显示
{
    int i = 0;
    if (pSeq->sz == 0)
    {
        printf("顺序表为空");
        return;
    }
    for (i = 0; i < pSeq->sz; i++)
    {
        printf("%d ", pSeq->date[i]);
    }
    printf("\n");
}

int Find(pSeqList pseq, DataType d)  //查找
{
    int i = 0;
    assert(pseq);
    for (i = 0; i < pseq->sz; i++)
    {
        if (pseq->date[i] == d)
        {
            return i;
        }
    }
    return -1; //不能返回0
}

void Insert(pSeqList pseq, int pos, DataType d)  //指定位置插入
{
    int i = 0;
    assert(pseq !=NULL && pos >= 0 && pos<pseq->sz);
    if (pseq->sz == MAX)
    {
        printf("顺序表已满，无法插入\n");
        return;
    }
    for (i = pseq->sz-1; i >= pos; i--)
    {
        pseq->date[i+1] = pseq->date[i];
    }

    pseq->date[pos] = d;
    pseq->sz++;
}

void Erase(pSeqList pseq, int pos)  //删除指定位置元素
{
    int i = 0;
    assert(pseq != NULL && pos >= 0 && pos < pseq->sz);
    if (pseq->sz == 0)
    {
        printf("顺序表为空，无法删除");
        return;
    }
    for (i = pos; i < pseq->sz - 1; i++)
    {
        pseq->date[i] = pseq->date[i + 1];
    }
    pseq->sz--;
}

void Remove(pSeqList pseq, DataType d)  //删除元素
{
#if 0
    int i = 0;
    assert(pseq);
    for (i = 0; i < pseq->sz; i++)
    {
        if (pseq->date[i] == d)
        {
            break;
        }
    }
    if (i == pseq->sz)
    {
        printf("要删除的元素不存在\n");
        return;
    }
    for (; i < pseq->sz-1; i++)
    {
        pseq->date[i] = pseq->date[i + 1];
    }
    pseq->sz--;
#endif
    int i = 0;
    int pos = 0;
    assert(pseq);
    pos = Find(pseq ,d);
    if (pos != -1)
    {
        Erase(pseq, pos);
    }
}

void RemoveAll(pSeqList pseq, DataType d)  //全部删除
{
#if 0
    int i = 0;
    assert(pseq);
    for (i = 0; i < pseq->sz; i++)
    {
        if (pseq->date[i] == d)
        {
            int j = 0;
            for (j=i; j < pseq->sz - 1; j++)
            {
                pseq->date[j] = pseq->date[j + 1];
            }
            pseq->sz--;
            i--;
        }
    }
#endif
#if 0
    int count = 0;
    int i = 0;
    DataType *tmp = NULL;
    assert(pseq);
    tmp = malloc(pseq->sz*sizeof(DataType));
    if (tmp == NULL)
    {
        perror(" use malloc");
        return;
    }
    for (i = 0; i < pseq->sz; i++)
    {
        if (pseq->date[i] != d)
        {
            tmp[count++] = pseq->date[i];
        }
    }
    memcpy(pseq->date, tmp, count*sizeof(DataType));
    pseq->sz = count;
    free(tmp);
    tmp = NULL;
#endif
    assert(pseq);
    int i = 0;
    int count = 0;
    for (i = 0; i < pseq->sz; i++)
    {
        if (pseq->date[i] != d)
        {
            pseq->date[count++] = pseq->date[i];
        }
    }
    pseq->sz = count;
}

int Size(pSeqList pseq)  //大小
{
    return pseq->sz;
}

int Empty(pSeqList pseq)  //清空
{

    return pseq->sz == 0;
}

void Sawp(DataType* px, DataType*py)  //交换
{
    DataType tmp = *px;
    *px = *py;
    *py = tmp;
}

void BubbleSort(pSeqList pseq)  //冒泡
{
    int i = 0; 
    int j = 0;
    int flag = 0;
    assert(pseq);
    for (i = 0; i < pseq->sz-1; i++)
    {
        flag = 0;
        for (j = 0; j < pseq->sz-1-i; j++)
        {
            if (pseq->date[j] > pseq->date[j + 1])
            {
                Sawp(pseq->date+j, pseq->date+j + 1);
                flag = 1;
            }
        }
        if (flag == 0)
            return;
    }
}

int BinarySearch(pSeqList pseq, DataType d) //二分查找
{

    int left = 0;
    int right = pseq->sz - 1;
    assert(pseq);
    while (left <= right)
    {
        int mid = left + (right - left) / 2;
        if (pseq->date[mid] > d)
        {
            right = mid - 1;
        }
        else if (pseq->date[mid] < d)
        {
            left = mid + 1;
        }
        else
        {
            return mid;
        }
    }
    return -1;
}

int BinarySearch_R(pSeqList pseq, int left, int right, DataType d)  //二分查找优化
{
    int mid = 0;
    if (left > right)
        return -1;
    mid = left + (right - left) / 2;
    if (pseq->date[mid] < d)
    {
        return BinarySearch_R(pseq, mid + 1, right, d);
    }
    else if (pseq->date[mid]>d)
    {
        return BinarySearch_R(pseq, left,mid-1, d);
    }
    else
    {
        return mid;
    }
}

void selectsort(pSeqList pseq)  //选择排序
{
    assert(pseq);
    int i = 0;
    int j = 0;
    for (i = 0; i < pseq->sz-1; i++)
    {
        int MaxPos = 0;
        for (j = 0; j<pseq->sz - i; j++)
        {
            if (pseq->date[j]>pseq->date[MaxPos])
            {
                MaxPos = j;
            }
        }

        if (MaxPos != pseq->sz - 1 - i)
        {
            int tmp = pseq->date[MaxPos]; 
            pseq->date[MaxPos] = pseq->date[pseq->sz - 1 - i];
            pseq->date[pseq->sz - 1 - i] = tmp;
        }
    }
}

void SelectSort_op(pSeqList pseq)  //选择排序优化
{
    int i = 0;
    int start = 0;
    int end = pseq->sz - 1;
    while (start < end)
    {
        int MaxPos = start;
        int MinPos = end;
        for (i = 1; i < end; i++)
        {
            if (pseq->date[i]>pseq->date[MaxPos])
            {
                MaxPos = i;
            }
            if (pseq->date[i] < pseq->date[MinPos])
            {
                MinPos = i;
            }
        }
        if (MinPos != start)
        {
            Sawp(pseq->date+MinPos, pseq->date+start);
        }
        if (MaxPos == start)
        {
            MaxPos = MinPos;
        }
        if (MaxPos != end)
        {
            Sawp(pseq->date+MaxPos, pseq->date+end);
        }
        start++;
        end--;
    }

}

有问题请留言。

一条傻傻的二哈
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言实现静态顺序表
R_T_P_A_D的博客
11-17 275
实现顺序表分为以下几步： 1.先写出封装顺序表结构的结构体； 2.初始化顺序表； 3.增删查改； 4.顺序表的逆置等。 #define MAX_SIZE 100 typedef int DataType; typedef struct SeqList { DataType data[MAX_SIZE]; DataType length; }SeqList; //顺序表的初始化就是...
c语言实现静态顺序表
lu_1079776757的博客
07-28 664
c语言实现静态顺序表
C语言实现静态顺序表的实例详解
01-01
C语言实现静态顺序表的实例详解 线性表 定义一张顺序表也就是在内存中开辟一段连续的存储空间，并给它一个名字进行标识。只有定义了一个顺序表，才能利用该顺序表存放数据元素，也才能对该顺序表进行各种操作。 接下来看看静态的顺序表，直接上代码： SeqList.h #define _CRT_SECURE_NO_WARNINGS 1 #ifndef __SEQLIST_H__ #define __SEQLIST_H__ #include <stdio> #include <stdlib> #include <assert> #include <string> #define MAX 1
C语言实现动态顺序表的实现代码
12-31
C语言实现动态顺序表的实现代码 顺序表是在计算机内存中以数组的形式保存的线性表，是指用一组地址连续的存储单元依次存储数据元素的线性结构。线性表采用顺序存储的方式存储就称之为顺序表。顺序表是将表中的结点...
数据结构静态顺序表.zip
02-03
在这个“数据结构静态顺序表.zip”压缩包中，包含的是作者用C语言实现的静态顺序表源代码。 首先，让我们深入理解静态顺序表的概念。静态顺序表是一种固定大小的数组，其长度在创建时就已经确定，且在表的整个生命...
顺序表静态分配代码实现
qq_19037931的博客
08-19 147
静态链表
【c语言】c语言实现顺序表（静态）
如风逝去
11-06 295
//头文件//seqlist.h #ifndef __SEQLIST_H__ #define __SEQLIST_H__ #include #include #include #include #define MAX 10 typedef int DataType; typedef struct SeqList { DataType data[MAX]; int sz;
C语言-静态实现顺序表
Demons的博客
04-19 344
C语言实现了个静态的顺序表，如果有不对的地方，还请指正 SeqList.h #ifndef _SEQLIST_H_ #define _SEQLIST_H_ #include &amp;amp;lt;stdio.h&amp;amp;gt; #include &amp;amp;lt;assert.h&amp;amp;gt; #include &amp;amp;lt;stdlib.h&amp;amp;gt; #include &amp;amp;
静态顺序表（C语言实现）
Zhoujy1996的博客
05-30 346
数据结构： typedef struct Seqlist//顺序表 { DataType data[MAX]; int sz; } Seqlist,*pSeqlist;1234512345 方法： void InitSeqlist(pSeqlist ps);//初始化 void PushBack(pSeqlist ps, DataType d);//尾插 void PrintSe
C语言实现顺序表(静态)
Ruichen_L的博客
09-04 234
静态顺序表 头文件 #ifndef SeqList_h #define SeqList_h typedef int DataType; #define MAX_SIZE 10 //顺序表的容量，可调整 typedef struct SeqList { DataType _array[MAX_SIZE]; int _size; //已存元...
【数据结构】静态顺序表各种功能实现(C语言)
Qingmou's_blog
09-19 877
顺序表的存储方式 定义一个顺序表 #define MAX_SIZE (100) typedef int DataType; typedef struct SeqList { DataType data[MAX_SIZE]; int size; } SeqListR; 顺序表要实现的功能 void InitSeqList(SeqListR *pSeq); //初始化...
c语言实现静态顺序表 ------------第一次自己独立完成
baidu_37964044的博客
02-08 251
Seqlist.htypedef struct SeqList { DataType array[N]; size_t size; }SeqList; void InitSeqList(SeqList *s); void PushBack(SeqList *s, DataType x); void PopBack(SeqList *s); void PushFront(SeqList *s, ...
C语言静态顺序表的基本操作
m0_48781598的博客
07-27 236
1.本文章主要介绍的是对数据结构中用C语言来实现静态顺序表的一些操作。 2.如果您觉得本文章对你有帮助的话，可以点个赞什么的~ 3.如果你正在学习C或者C++或者数据结构的一些内容，那么欢迎你加入我的交流群：637987498。本群不包含任何广告，纯粹为编程爱好者交流。 注意：本文章适合有c语言基础的人看 废话不多说，直接上代码 /* @Time：2021/7/27 @Author:King @Content:顺序表的静态实现方式 @ContactByQQ:1224608.
静态顺序表的实现c语言
最新发布
03-19
下面是静态顺序表的C语言实现： ```c #define MAX_SIZE 100 // 定义静态顺序表的最大容量 typedef struct { int data[MAX_SIZE]; // 用数组存储数据元素 int length; // 当前顺序表的长度 } SeqList; // 初始化...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值