c语言实现顺序表各个功能操作函数

最新推荐文章于 2024-09-29 12:33:36 发布
最新推荐文章于 2024-09-29 12:33:36 发布
阅读量2.9k 收藏 15
点赞数 7
分类专栏： xuy's c world!
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xy294636185/article/details/80454983
版权

c语言实现顺序表的操作函数

首先，一个顺序表先要用结构体定义
typedef struct Seqlist{
Datatype array[MAX_SIZE];
size_t Size;
}Seqlist,*psl;

然后要被初始化，这里用memset来初始化

    memset(psl->array, 0, MAX_SIZE*sizeof(Datatype));
    psl->Size = 0;

这里实现一个静态表，
然后就可以扩展它的功能了。
这里用代码大概写一些，把他们接口函数写在Seqlist.h头文件中：

#ifndef SEQ_LIST
#define SEQ_LIST
#define _CRT_SECURE_NO_WARININGS 1
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>

typedef int Datatype;
#define MAX_SIZE  100

typedef struct Seqlist{
    Datatype array[MAX_SIZE];
    size_t Size;
}Seqlist,*psl;

void InitSeqlist(Seqlist* seqlist);// 初始化 
void Pushback(Seqlist* seqlist, Datatype data);// 尾部插入
void Pushfront(Seqlist* psl, Datatype data);// 头部插入 
void Popback(Seqlist* psl);// 尾部删除 
void Popfront(Seqlist* psl);// 头部删除 
void Insert(Seqlist* psl, size_t pos, Datatype data);// 按下标插入，pos 的范围是 [0, size] 
void Erase(Seqlist* psl, size_t pos);// 按下标删除，pos 的范围是 [0, size) 
void Remove(Seqlist* psl, Datatype data);// 按值删除，只删遇到的第一个 
void Removeall(Seqlist* psl, Datatype data);// 按值删除，删除所有的 
void Clear(Seqlist* psl);// 清空 
void show(Seqlist* psl);//打印顺序表
int Find(Seqlist* psl, Datatype data);// 按值查找，返回第一个找到的下标，如果没找到，返回 -1 
int Empty(Seqlist* psl);// 判断是否为空，1 表示空， 0 表示不空
void Selectsort(Seqlist* psl);//选择排序
void bubblesort(Seqlist* psl);//冒泡排序
int Size(Seqlist* psl);// 返回数量 
void Destroy(Seqlist* psl);// 销毁

如果还有想法，可以附加在这些接口函数里面。

下面就是这些功能代码分步实现了，全部写在一个.c文件里

#define _CRT_SECURE_NO_WARININGS 1
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
#include "SeqList.h"

//初始化顺序表
void InitSeqlist(Seqlist* psl){
    memset(psl->array, 0, MAX_SIZE*sizeof(Datatype));
    psl->Size = 0;
}

//尾插
void Pushback(Seqlist* seqlist, Datatype data){
    assert(seqlist);
    if (seqlist->Size > MAX_SIZE){
        printf("full");
        return;
    }
    seqlist->array[seqlist->Size] = data;
    seqlist->Size++;
}

//头插
void Pushfront(Seqlist* psl, Datatype data){
    int begin = 0;
    assert(psl);
    if (psl->Size == MAX_SIZE){
        printf("full");
        return;
    }
    else{
        for (begin = psl->Size; begin >= 0; begin--){
            psl->array[begin + 1] = psl->array[begin];
        }
        psl->array[0] = data;
    }
    psl->Size++;
}

//尾删
void Popback(Seqlist* psl){
    assert(psl);
    if (psl->Size == 0){
        printf("empty");
        return;
    }
    psl->Size--;
}

//头删
void Popfront(Seqlist* psl){
    int begin = 0;
    assert(psl);
    if (psl->Size == 0){
        printf("empty");
        return;
    }
    else{
        for (begin = 0; begin <= psl->Size - 1; begin++){
            psl->array[begin] = psl->array[begin+1];
        }
    }
    psl->Size--;
}

//下标插
void Insert(Seqlist* psl, size_t pos, Datatype data){
    int begin = 0;
    assert(psl);
    if (pos > MAX_SIZE){
        printf("超范围！");
        return;
    }
    if (psl->Size == MAX_SIZE){
        printf("full");
        return;
    }
    else if (pos <= psl->Size){
        for (begin = psl->Size; begin > pos - 1; begin--){
            psl->array[begin] = psl->array[begin - 1];
        }
        psl->array[pos - 1] = data;
    }
    else{
        printf("位置错误！");
            return;
    }
    psl->Size++;
}

//下标删
void Erase(Seqlist* psl, size_t pos){
    int begin = 0;
    assert(psl);
    if (pos > psl->Size){
        printf("超出范围！");
            return;
    }
    if (psl->Size == 0){
        printf("empty!");
        return;
    }
    for (begin = pos - 1; begin < psl->Size; begin++){
        psl->array[begin] = psl->array[begin + 1];
    }
    psl->Size--;
}

//按值删除，只删遇到的第一个
void Remove(Seqlist* psl, Datatype data){
    int begin = 0;
    int pos = 0;
    assert(psl);
    if (psl->Size == 0){
        printf("empty!");
        return;
    }
    for (begin = 0; begin < psl->Size; begin++){
        if (psl->array[begin] == data){
            for (pos = begin; pos < psl->Size; pos++){
                psl->array[pos] = psl->array[pos + 1];
            }
            psl->Size--;
            return;
        }
    }
    printf("该表没有此元素！");
}

// 按值删除，删除所有的 
void Removeall(Seqlist* psl, Datatype data){
    int begin = 0;
    int count = 0;
    assert(psl);
    if (psl->Size == 0){
        printf("empty!");
        return;
    }
    for (begin = 0; begin < psl->Size; begin++){
        if (psl->array[begin] == data){
            count++;
        }
        else{
            if (count == 0){

            }
            else{
                psl->array[begin - count] = psl->array[begin];
            }
        }
    }
    psl->Size -= count;
}

//清空
void Clear(Seqlist* psl){
    psl->Size = 0;
}

//显示
void show(Seqlist* psl){
    int begin = 0;
    assert(psl);
    if (psl->Size == 0){
        printf("empty!");
        return;
    }
    else{
        for (begin = 0; begin < psl->Size; begin++){
            printf("%d ", psl->array[begin]);
        }
        printf("\n");
    }
}

// 按值查找，返回第一个找到的下标，如果没找到，返回 -1 
int Find(Seqlist* psl, Datatype data){
    int begin = 0;
    int left = 0;
    int right = psl->Size;
    int mid = 0;
    int flag = 1;
    assert(psl);
    if (psl->Size == 0){
        printf("empty!");
        return 0;
    }
    if (data > (psl->Size - 1)){
        printf("没有这个元素!");
        return -1;
    }
    while (flag){
        mid = left + (right - left) / 2;
        if (psl->array[mid] > data){
            right = mid + 1;
        }
        else if (psl->array[mid] < data){
            left = mid;
        }
        else{
            flag = 0;
            return mid + 1;
        }
    }
    return 0;
}

//判断是否为空，1 表示空， 0 表示不空
int Empty(Seqlist* psl){
    assert(psl);
    if (psl->Size == 0){
        return 1;
    }
    else{
        return 0;
    }
}

//返回数量 
int  Size(Seqlist* psl){
    return psl->Size;
}

//销毁 
void Destroy(Seqlist* psl){
    assert(psl);
    free(psl);
    printf("Destory success!");
    return;
}

//bubblesort排序
#if 1
void bubblesort(Seqlist* psl){
    int in = 0;
    int out = 0;
    int temp = 0;
    int count = 0;
    int flag = 0;
    for (out = 0; out < psl->Size - count; in++){
        flag = 0;
        count++;
        for (in = 0; in<psl->Size - count; in++){
            if (psl->array[in]>psl->array[in + 1]){
                temp = psl->array[in];
                psl->array[in] = psl->array[in + 1];
                psl->array[in + 1] = temp;
                flag = 1;
            }
            else{
                ;
            }
            if (flag == 0){
                return;
            }
        }
    }
}
#endif

#if 0
//选择排序
void Selectsort(Seqlist* psl){
    int i = 0;
    int j = 0;
    int count = 0;
    int max = 0;
    int min = 0;
    int imax = psl->array[0];
    int imin = psl->array[0];
    for (i = 0; i < (psl->Size / 2 + 1); i++){
        imax = psl->array[count];
        imin = psl->array[count];
        for (j = count; j < (psl->Size - count); j++){
            if (psl->array[j] >= imax){
                imax = psl->array[j];
                max = j;
            }
            if (psl->array[j] <= imin){
                imin = psl->array[j];
                min = j;
            }
        }
        imin = psl->array[count];
        psl->array[count] = psl->array[min];
        psl->array[min] = imin;

        imax = psl->array[psl->Size - count - 1];
        psl->array[psl->Size - count - 1] = psl->array[max];
        psl->array[max] = imax;
        count++;
    }
}
#endif

然后，在main函数内部写出部分函数实现一下：

#define  _CRT_SECURE_NO_WARNINGS
#include"seqlist.h"
#include"Seqlist.h"
int main(){
    Seqlist psl;
    int y,h,v,t,i,j,k,u,o,temp;
    Datatype data;

    printf("顺序表初始化\n");
    InitSeqlist(&psl);
    printf("please input 10nums!\n");
    for (i = 0; i < 10; i++){                 //这里循环可以设置在100以内，可在头文件修改N值扩大
    printf("please input :");
    scanf("%d", &t);
    Pushback(&psl, t);
    }
    show(&psl);

    printf("\n进行冒泡排序\n");
    bubblesort(&psl);
    show(&psl);

    printf("\n将顺序表中第k个元素赋值为temp\n");
    printf("请输入第k个元素的k值和temp值：\n");
    scanf("%d %d", &k, &temp);
    Insert(&psl, k, temp);
    printf("\n此时顺序表为：\n");
    show(&psl);

    printf("\n在顺序表表尾删除元素\n");
    Popback(&psl);
    printf("此时顺序表为：\n");
    show(&psl);

    printf("\n请输入要删除的数下标：");
    scanf("%d", &y);
    Erase(&psl, y);
    show(&psl);

    printf("\n请输入要删除的数(只删除1个)：");
    scanf("%d", &v);
    Remove(&psl, v);
    show(&psl);

    printf("\n请输入要删除的数(全部删除)：");
    scanf("%d", &h);
    Removeall(&psl, h);
    show(&psl);


    printf("\n请输入要查找的元素：\n");
    scanf("%d", &j);
    o = Find(&psl, j);
    printf("%d为第%d位：\n", j, o);

    printf("\n输出长度\n");
    u = Size(&psl);
    printf("顺序表的长度为%d\n", u);

    system("pause");
    return 0;
}

下面放出测试图：
这里写图片描述
可以看出简易实现还是可以的。

如果想要测试更多的功能，可以在main函数里调用这些函数，这里就不再一一测试，
如果有什么建议或者想法，欢迎加好友一起交流！

C语言顺序表
12-08
C语言，顺序表的构建和简单操作。顺序表 //定义结构类型 typedef struct list //构建一个空线性表 void CreateList(List *lst, int maxsize) //若线性表为空，则返回TURE，否则返回FALSE BOOL IsEmpty(List lst) //若线性表已满，则返回TURE，否则返回FALSE BOOL IsFull(List lst) //移除所有元素，线性表为空表 void Clear(List *lst) //若线性表未满且0<=pos<=n，则原表中位置在pos及其以后的所有元素后移一位，元素x插在位置pos处，并且函数返回TURE，否则返回FALSE BOOL Insert(List *lst, int pos, int x) //若线性表非空且0<=pos<=n，则位置在pos处的元素复制到参数*x，从原表中移去该元素，表中pos之后所有元素前移一位，并且函数返回TURE，否则返回FALSE BOOL Remove(List *lst, int pos, int *x) //若线性表非空且0<=pos<=n，则位置在pos处的元素复制到参数*x，并且函数返回TURE，否则返回FALSE BOOL Retrive(List lst, int pos, int *x) //若线性表非空且0<=pos<=n，则位置在pos处的元素值被x替代，并且函数返回TURE，否则返回FALSE BOOL Replace(List *lst, int pos, int x) //输出顺序表 void PrintList(List lst,int maxsize)
(C语言数据结构) 顺序表
09-16
C语言实现 顺序表 Init(初始化) Length(当前结点个数) Add(添加) Insert(插入) Delete(删除) FindByKey(查找返回序号) FindByNum(查找返回元素) ShowAll(显示所有元素)
数据结构之顺序表的实现（c语言）
m0_64334842的博客
11-03 446
因为静态顺序表只适用于确定知道需要存多少数据的场景。静态顺序表的定长数据导致长度定大，空间开多了浪费，开少了不够用。所以现实中基本使用的动态顺序表，根据需要动态的分配空间大小。所以主要实现动态顺序表。
C语言—顺序表（含通讯录项目）
最新发布
2302_81120572的博客
09-29 1607
C语言—顺序表（含通讯录项目）
C语言-顺序表
m0_73605503的博客
07-11 1583
欢迎来到HanLop博客的C语言数据结构初阶系列。在这个系列中，我们将深入探讨各种基本的数据结构和算法，帮助您打下坚实的编程基础。本次我将为你讲解。顺序表（也称为数组）是一种线性表，因其简单易用而广泛应用于各类编程任务中。在本篇文章中，我们将介绍顺序表的基本概念、顺序表的创建和操作方法，以及其优缺点。通过一些实际的代码示例，您将更好地掌握顺序表在C语言中的应用，从而为后续学习其他数据结构打下坚实的基础。
C语言：顺序表
ChaseRaod的博客
03-06 539
顺序表是在计算机内存中以数组的形式保存的线性表，是指用一组地址连续的存储单元依次存储数据元素的线性结构，下面我们简单实现顺序表。 test.c中 #define _CRT_SECURE_NO_WARNINGS 1 #include "seqlist.h" void menu() { printf("****************************\n"); printf("1.P
c语言实现顺序表的基本操作
01-20
数据结构顺序表操作 代码如下:#include <stdio>#include <stdlib>#include <malloc>#define LIST_INIT_SIZE 100#define LISINCREMENT 10#define ElemType int#define Status inttypedef struct Sq{ ElemType *elem...
C语言实现顺序表基本操作汇总
09-04
【C语言实现顺序表基本操作汇总】 顺序表是一种在计算机科学中常见的数据结构，它将一组元素存储在一块连续的内存区域中。这种结构允许快速访问元素，因为可以通过索引来直接定位元素。本文将深入讨论如何使用C语言...
利用C语言实现顺序表的实例操作
09-01
在C语言中，实现顺序表涉及到动态内存管理、元素的插入和删除等操作。以下是对标题和描述中涉及的知识点的详细说明： 1. **顺序表的定义**： 顺序表是由一组具有相同类型的数据元素构成的线性结构，这些元素在内存...
c语言 顺序表的功能实现
07-11
完成顺序表的建立、查找、求长度、插入、删除、输出，清空，销毁等函数的功能
C语言—顺序表
七月❤的博客
11-26 164
顺序表的初始化，插入，删除，打印 #include <stdio.h> #include <stdlib.h> #define INITSIZE 100 //线性表能达到的最大长度 #define bool int #define true 1 #define false 0 typedef int DataType;//ElemType表示线性表中元素的类型 ...
C语言——顺序表
学习C++的小陈同学
11-23 552
C语言实现顺序表
顺序表---C语言
有勇气的牛排博客
05-05 620
顺序表中k0的存储位置 loc（k0）在有n个元素的线性表里下标为i的元素前。考虑到线性表元素的变化，创建一个。可以看出，在顺序表中进行一次。是表示线性表最简单的方法。下标为i的元素需要移动。
C语言实现顺序表操作函数详解
本文提供的代码展示了如何用C语言实现一个顺序表，并提供了丰富的操作函数来管理这个数据结构。顺序表的主要优点是访问速度快，因为元素都是连续存储的，可以通过索引直接访问。但插入和删除操作可能涉及到大量的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值