实现静态顺序表和动态顺序表

最新推荐文章于 2023-01-07 23:58:10 发布
最新推荐文章于 2023-01-07 23:58:10 发布
阅读量774 收藏
点赞数 1
分类专栏： C程序典型示例 C语言知识库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/quinn0918/article/details/72847052
版权

其实顺序表的静态实现以及动态实现和通讯录的实现原理基本上是一致的，在这里就不做过多的解释，直接贴代码。
静态通讯录：http://blog.csdn.net/quinn0918/article/details/71937767
动态通讯录：http://blog.csdn.net/quinn0918/article/details/72182598
文件流通讯录：http://blog.csdn.net/quinn0918/article/details/72526886

静态顺序表：

Seqlist.h头文件

#ifndef __SEQLIST_H__

#include<stdio.h>
#include<windows.h>
#include<assert.h>
#define MAX 100
typedef int DataType;

typedef struct Seqlist
{
    DataType Data[MAX];
    int sz;
}Seqlist,*pseqlist;

void InitSeqlist(pseqlist ps);//初始化顺序表
void PushBack(pseqlist ps,DataType num);//尾部压入
void PrintSeqlist(const pseqlist ps);//打印顺序表
void PopBack(pseqlist ps);//尾部删除
void PushFront(pseqlist ps, DataType num);//头部插入
void PopFront(pseqlist ps);//头部删除
void Insert(pseqlist ps, int pos, DataType num);//指定位置插入
int Find(pseqlist ps, DataType num);//查找下标
void Remove(pseqlist ps, DataType num);//删除所有指定元素
void ReverseSeqlist(pseqlist ps);//逆序
void SortSeqlist(pseqlist ps);//排序
int BinarySearch(pseqlist ps, DataType num);//二分查找
#endif //__SEQLIST_H__

Seqlist.h实现部分

#include "Seqlist.h"

void InitSeqlist(pseqlist ps)
{
    assert(ps);
    ps->sz = 0;
    memset(ps->Data, 0, sizeof(ps->Data));
}

void PushBack(pseqlist ps, DataType num)
{
    assert(ps);
    if (ps->sz == MAX)
    {
        return;
    }
    ps->Data[ps->sz] = num;
    ps->sz += 1;
}

void PrintSeqlist(const pseqlist ps)
{
    assert(ps);
    int i = 0;
    for (i = 0; i < ps->sz; i++)
    {
        printf("%d ",ps->Data[i]);
    }
    printf("\n");
}

void PopBack(pseqlist ps)
{
    assert(ps);
    if (ps->sz == 0)
    {
        return;
    }
    ps->sz--;
}

void PushFront(pseqlist ps, DataType num)
{
    assert(ps);
    int i = 0;
    if (ps->sz == MAX)
    {
        return;
    }
    for (i = ps->sz; i > 0; i--)
    {
        ps->Data[i] = ps->Data[i-1];
    }
    ps->Data[0] = num;
    ps->sz++;
}


void PopFront(pseqlist ps)
{
    assert(ps);

    if (ps->sz)
    {
        int i = 0;
        for (i = 0; i < ps->sz-1; i++)
        {
            ps->Data[i] = ps->Data[i + 1];
        }
        ps->sz--;
    }
}

void Insert(pseqlist ps, int pos, DataType num)
{
    assert(ps);
    int i = 0;
    if (ps->sz == MAX)
    {
        return;
    }
    for (i = ps->sz; i > pos; i--)
    { 
        ps->Data[i] = ps->Data[i - 1];
    }
    ps->Data[pos] = num;
    ps->sz++;
}

int Find(pseqlist ps, DataType num)
{
    assert(ps);
    int i = 0;
    for (i = 0; i < ps->sz; i++)
    {
        if (ps->Data[i] == num)
        {
            return i;
        }
    }
    return -1;
}


void Remove(pseqlist ps, DataType num)
{
    assert(ps);
    int i = 0;
    int ret = 0;
    if (ps->sz == 0)
    {
        return;
    }
    while ((ret = Find(ps, num))!=-1)
    {
        for (i = ret; i < ps->sz - 1; i++)
        {
            ps->Data[i] = ps->Data[i + 1];
        }
        ps->sz--;
    }
}

void ReverseSeqlist(pseqlist ps)
{
    assert(ps);
    int left = 0;
    int right = ps->sz - 1;
    while (left < right)
    {
        DataType tmp = ps->Data[left];
        ps->Data[left] = ps->Data[right];
        ps->Data[right] = tmp;
        left++;
        right--;
    }
}

void SortSeqlist(pseqlist ps)
{
    assert(ps);
    int i = 0;
    int j = 0;
    for (i = 0; i < ps->sz; i++)
    {
        for (j = 0; j < ps->sz-i-1; j++)
        {
            if (ps->Data[j] > ps->Data[j + 1])
            {
                DataType tmp = ps->Data[j+1];
                ps->Data[j+1] = ps->Data[j];
                ps->Data[j] = tmp;
            }
        }
    }
}

int BinarySearch(pseqlist ps, DataType num)
{
    assert(ps);
    int left = 0;
    int right = ps->sz - 1;
    while (left <= right)
    {
        int mid = left - (left - right);
        if (ps->Data[mid] < num)
        {
            left = mid + 1;
        }
        else if (ps->Data[mid] > num)
        {
            right = mid + 1;
        }
        else
        {
            return mid;
        }
    }
    return -1;
}

test.c测试部分

#include "Seqlist.h"

void test()
{
    Seqlist mylist;
    InitSeqlist(&mylist);//初始化顺序表
    PushBack(&mylist, 1);//尾部插入元素
    PushBack(&mylist, 2);
    PushBack(&mylist, 3);
    PushBack(&mylist, 4);
    PushBack(&mylist, 5);
    PrintSeqlist(&mylist);
    PopBack(&mylist);//尾部删除
    PrintSeqlist(&mylist);
}

void test1()
{
    Seqlist mylist;
    InitSeqlist(&mylist);//初始化顺序表
    PushFront(&mylist, 6);//头部插入
    PushFront(&mylist, 7);
    PushFront(&mylist, 8);
    PushFront(&mylist, 9);
    PushFront(&mylist, 10);
    PrintSeqlist(&mylist);
    PopFront(&mylist);//头部删除
    PrintSeqlist(&mylist);
}

void  test2()
{
    Seqlist mylist;
    InitSeqlist(&mylist);//初始化顺序表
    PushFront(&mylist, 6);//头部插入
    PushFront(&mylist, 7);
    PushFront(&mylist, 8);
    PushFront(&mylist, 9);
    PushFront(&mylist, 10);
    int num = Find(&mylist, 10);//查找
    if (num !=-1)
        Insert(&mylist, num, 11);//指定位置插入
    PrintSeqlist(&mylist);
}

void test3()
{
    Seqlist mylist;
    InitSeqlist(&mylist);//初始化顺序表
    PushFront(&mylist, 11);//头部插入
    PushFront(&mylist, 7);
    PushFront(&mylist, 8);
    PushFront(&mylist, 10);
    PushFront(&mylist, 9);
    PushFront(&mylist, 10);
    PrintSeqlist(&mylist);
    Remove(&mylist, 10);//删除所有指定元素
    PrintSeqlist(&mylist);
    ReverseSeqlist(&mylist);//逆序
    PrintSeqlist(&mylist);
    SortSeqlist(&mylist);//排序
    PrintSeqlist(&mylist);
    int num = BinarySearch(&mylist,11);//二分查找
    if (num != -1)
        Insert(&mylist, num, 2);
    PrintSeqlist(&mylist);
}

int main()
{
    //test();
    //test1();
    //test2();
    test3();
    system("pause");
    return 0;
}

本人亲测，一点问题也没有！！！动态顺序表马上就来！！！！

动态顺序表

Seqlist_D.h头文件

#ifndef __SEQLIST_D_H__


#include<stdio.h>
#include<windows.h>
#include<assert.h>
#define INIT 2
#define INIC 3
typedef int DataType;
typedef struct Seqlist
{
    DataType *Data;
    int sz;
    int capa;
}Seqlist,*pseqlist;

void InitSeqlist(pseqlist ps);//初始化
void DestorySeqlist(pseqlist ps);//释放内存
void PushBack(pseqlist ps, DataType num);//尾部压入
void PrintSeqlist(const pseqlist ps);//打印顺序表
void PopBack(pseqlist ps);//尾部删除
void PushFront(pseqlist ps, DataType num);//头部插入
void PopFront(pseqlist ps);//头部删除
void Insert(pseqlist ps, int pos, DataType num);//指定位置插入
int Find(pseqlist ps, DataType num);//查找下标
void Remove(pseqlist ps, DataType num);//删除所有指定元素
void ReverseSeqlist(pseqlist ps);//逆序
void SortSeqlist(pseqlist ps);//排序
int BinarySearch(pseqlist ps, DataType num);//二分查找
#endif  //__SEQLIST_D_H__

Seqlist_D.c实现部分

#include "Seqlist_D.h"

void InitSeqlist(pseqlist ps)
{
    assert(ps);
    ps->Data = (DataType*)malloc(sizeof(DataType)*INIT);
    ps->sz = 0;
    ps->capa = INIT;
}

void DestorySeqlist(pseqlist ps)
{
    assert(ps);
    if (ps->Data != NULL)
    {
        free(ps->Data);
        ps->Data = NULL;
    }
}

void check(pseqlist ps)//检测动态内存分配
{
    if (ps->sz == ps->capa)
    {
        DataType *tmp = (DataType *)realloc(ps->Data, (ps->capa + INIC)*sizeof(DataType));
        //当实际个数和初始化的容量相等时用realloc增容  
        if (tmp == NULL)
        {
            printf("out of menory\n");
            exit(1);
        }
        else
        {
            ps->Data = tmp;
            ps->capa += INIC;
        }
    }
}

void PushBack(pseqlist ps, DataType num)
{
    assert(ps);
    check(ps);
    ps->Data[ps->sz] = num;
    ps->sz += 1;
}

void PrintSeqlist(const pseqlist ps)
{
    assert(ps);
    int i = 0;
    for (i = 0; i < ps->sz; i++)
    {
        printf("%d ", ps->Data[i]);
    }
    printf("\n");
}

void PopBack(pseqlist ps)
{
    assert(ps);
    if (ps->sz == 0)
    {
        return;
    }
    ps->sz--;
}

void PushFront(pseqlist ps, DataType num)
{
    assert(ps);
    check(ps);
    int i = 0;
    for (i = ps->sz; i > 0; i--)
    {
        ps->Data[i] = ps->Data[i - 1];
    }
    ps->Data[0] = num;
    ps->sz++;
}


void PopFront(pseqlist ps)
{
    assert(ps);

    if (ps->sz)
    {
        int i = 0;
        for (i = 0; i < ps->sz - 1; i++)
        {
            ps->Data[i] = ps->Data[i + 1];
        }
        ps->sz--;
    }
}

void Insert(pseqlist ps, int pos, DataType num)
{
    assert(ps);
    check(ps);
    int i = 0;
    for (i = ps->sz; i > pos; i--)
    {
        ps->Data[i] = ps->Data[i - 1];
    }
    ps->Data[pos] = num;
    ps->sz++;
}

int Find(pseqlist ps, DataType num)
{
    assert(ps);
    int i = 0;
    for (i = 0; i < ps->sz; i++)
    {
        if (ps->Data[i] == num)
        {
            return i;
        }
    }
    return -1;
}


void Remove(pseqlist ps, DataType num)
{
    assert(ps);
    int i = 0;
    int ret = 0;
    if (ps->sz == 0)
    {
        return;
    }
    while ((ret = Find(ps, num)) != -1)
    {
        for (i = ret; i < ps->sz - 1; i++)
        {
            ps->Data[i] = ps->Data[i + 1];
        }
        ps->sz--;
    }
}

void ReverseSeqlist(pseqlist ps)
{
    assert(ps);
    int left = 0;
    int right = ps->sz - 1;
    while (left < right)
    {
        DataType tmp = ps->Data[left];
        ps->Data[left] = ps->Data[right];
        ps->Data[right] = tmp;
        left++;
        right--;
    }
}

void SortSeqlist(pseqlist ps)
{
    assert(ps);
    int i = 0;
    int j = 0;
    for (i = 0; i < ps->sz; i++)
    {
        for (j = 0; j < ps->sz - i - 1; j++)
        {
            if (ps->Data[j] > ps->Data[j + 1])
            {
                DataType tmp = ps->Data[j + 1];
                ps->Data[j + 1] = ps->Data[j];
                ps->Data[j] = tmp;
            }
        }
    }
}

int BinarySearch(pseqlist ps, DataType num)
{
    assert(ps);
    int left = 0;
    int right = ps->sz - 1;
    while (left <= right)
    {
        int mid = left - (left - right);
        if (ps->Data[mid] < num)
        {
            left = mid + 1;
        }
        else if (ps->Data[mid] > num)
        {
            right = mid + 1;
        }
        else
        {
            return mid;
        }
    }
    return -1;
}

test.c测试部分

#include "Seqlist_D.h"

void test()
{
    Seqlist mylist;
    InitSeqlist(&mylist);//初始化顺序表
    PushBack(&mylist, 1);//尾部插入元素
    PushBack(&mylist, 2);
    PushBack(&mylist, 3);
    PushBack(&mylist, 4);
    PushBack(&mylist, 5);
    PrintSeqlist(&mylist);
    PopBack(&mylist);//尾部删除
    PrintSeqlist(&mylist);
    DestorySeqlist(&mylist);//释放内存
}

void test1()
{
    Seqlist mylist;
    InitSeqlist(&mylist);//初始化顺序表
    PushFront(&mylist, 6);//头部插入
    PushFront(&mylist, 7);
    PushFront(&mylist, 8);
    PushFront(&mylist, 9);
    PushFront(&mylist, 10);
    PrintSeqlist(&mylist);
    PopFront(&mylist);//头部删除
    PrintSeqlist(&mylist);
    DestorySeqlist(&mylist);//释放内存
}

void  test2()
{
    Seqlist mylist;
    InitSeqlist(&mylist);//初始化顺序表
    PushFront(&mylist, 6);//头部插入
    PushFront(&mylist, 7);
    PushFront(&mylist, 8);
    PushFront(&mylist, 9);
    PushFront(&mylist, 10);
    int num = Find(&mylist, 10);//查找
    if (num != -1)
        Insert(&mylist, num, 11);//指定位置插入
    PrintSeqlist(&mylist);
    DestorySeqlist(&mylist);//释放内存
}

void test3()
{
    Seqlist mylist;
    InitSeqlist(&mylist);//初始化顺序表
    PushFront(&mylist, 11);//头部插入
    PushFront(&mylist, 7);
    PushFront(&mylist, 8);
    PushFront(&mylist, 10);
    PushFront(&mylist, 9);
    PushFront(&mylist, 10);
    PrintSeqlist(&mylist);
    Remove(&mylist, 10);//删除所有指定元素
    PrintSeqlist(&mylist);
    ReverseSeqlist(&mylist);//逆序
    PrintSeqlist(&mylist);
    SortSeqlist(&mylist);//排序
    PrintSeqlist(&mylist);
    int num = BinarySearch(&mylist, 11);//二分查找
    if (num != -1)
        Insert(&mylist, num, 2);
    PrintSeqlist(&mylist);
    DestorySeqlist(&mylist);//释放内存
}

int main()
{
    //test();
    //test1();
    //test2();
    test3();
    system("pause");
    return 0;
}

到这里静态和动态的顺序表就结束了，在代码中我都加入了好几个测试环节，贴测试结果的话图会很多，又由于代码有点长，程序测试结果就不往上贴了，读者要是不放心的话尽管测一下。

Quinn0918
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
创建一个静态的顺序表存放整数
04-17
创建一个静态的顺序表存放整数。大小为10.完成以下的操作输入6个整数，1.打 印出顺序表中的内容，并显示表中剩余的空间个数。在顺序表中的第3个位置插入元素O.2.打印出顺序表中的内容，并显示表中剩余的空间个数。再试图向表中第11个位置插入整数0,3.程序提示超出范围。4.删除表中第6个元素，打印出顺序表中的内容，并显示表中剩余的空间个数。 二：编写一程序，动态地创建一个顺序表。要求顺序表初始长度为20,向顺序表中输 入15个整数，并打印出来: 再删除顺序表中的第5个元素。打印出删除后的结果。
顺序表的静态实现
weixin_46059682的博客
09-01 132
1.相关头文件 #pragma once #define _CRT_SECURE_NO_WARNINGS //*************************顺序表的实现---静态分配******************************* //*************************相关头文件的声明************************************* #include <stdio.h> //*************************相关
【数据结构】顺序表的静态实现
某薛的黑猫
09-26 207
头文件 #ifndef __SEQLIST_H__ #define __SEQLIST_H__ #include&amp;amp;amp;lt;stdio.h&amp;amp;amp;gt; #include&amp;amp;amp;lt;assert.h&amp;amp;amp;gt; #include&amp;amp;amp;lt;stdlib.h&amp;amp;amp;gt; #include&amp;amp;amp
顺序表的实现：静态和动态
Liaiblog
02-28 203
顺序表的实现 1.静态实现 #include<stdio.h> #define MaxSize 10 typedef struct { int data[MaxSize]; int lenght; }SqList; //顺序表的初始化 void InitList(SqList &L){ for (int i = 0; i < MaxSize; i++) { L.data[i]=0; } L.lenght=0; }
顺序表的静态建立
weixin_34072458的博客
12-24 124
1 #include<stdio.h> 2 #define MaxSize 100 3 typedef int Elemtype; 4 typedef struct{ 5 Elemtype data[MaxSize]; 6 int length; 7 }SqList; 8 9 /*插入元素操作*/ 10 bool ListIns...
C语言实现静态顺序表的实例详解
08-29
主要介绍了C语言实现静态顺序表的实例详解的相关资料,这里提供是帮助大家学习理解这部分内容，需要的朋友可以参考下
C语言实现动态顺序表的实现代码
12-31
C语言实现动态顺序表的实现代码 顺序表是在计算机内存中以数组的形式保存的线性表，是指用一组地址连续的存储单元依次存储数据元素的线性结构。线性表采用顺序存储的方式存储就称之为顺序表。顺序表是将表中的结点...
数据结构c++代码（顺序表的代码，包括静态顺序表和动态顺序表）
07-13
数据结构c++代码（顺序表的代码，包括静态顺序表和动态顺序表），由devc++软件编写
C++实现基于静态数组的顺序表
08-19
主要介绍了C++实现基于静态数组的顺序表，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
顺序表的静态和动态实现
Maple的博客
03-11 686
静态顺序表：所谓静态顺序表就是把空间的大小给定结构体的定义：typedef struct SeqList { DataType array[MaxSize]; int size; }SeqList; 基本操作的实现：void InitSeqList(SeqList* pSeq) { assert(pSeq); memset(pSeq->array, 0, MaxSiz
静态顺序表、动态顺序表的操作实现
zhangm2020的博客
06-12 260
代码实现顺序表的操作函数头文件实现：//值类型typedef int DataType;typedef struct SeqList { DataType data; // 值 int size; // 数量} SeqList;源文件实现：// 1、初始化void SeqListInit(SeqList *pSL);// 2、尾部插入void SeqListPushBack(SeqList *...
静态顺序表和动态顺序表
weixin_34406086的博客
04-10 87
实现一个静态顺序表，首先，要定义一个保存数据的数组，保存在结构体中，用size来存储数组中的元素个数，typedefstructSeqList { DataTypearray[MAX_SIZE]; size_tsize; }SeqList;首先来实现一下静态顺序表的初始化函数，可以借用系统的memset函数来实现，开辟一块空间全部初始化为0，没有存入数据所以size也...
静态顺序表的实现
apt1203JN的博客
07-28 356
什么是顺序表？ 顺序表是在计算机内存中以数组的形式保存的线性表，是指用一组地址连续的存储单元依次存储数据元素的线性结构。
C语言 顺序表的实现（静态）
xy913741894的博客
09-11 873
最近复习到C语言的顺序表，把它实现一遍。 给出顺序表的定义#define MAX_SIZE 100 typedef int DataType; typedef struct SeqList { DataType array[MAX_SIZE]; int size; // 记录有效元素的个数 }SeqList, *PSeqList; void InitSeqList(PSeqLi
动态顺序表的代码实现以及与静态代码的区别
baidu_37963760的博客
07-28 505
 //动态顺序表 #define _CRT_SECURE_NO_WARNINGS #include #include #include #include #define MAX 1 typedef int DataType; typedef struct SeqList {  DataType *data;  int sz;  int Capacity; }
1-数据结构-线性结构之顺序表的静态实现
奔心小韩的博客
01-07 90
线性表-顺序表的静态分配
静态顺序表的实现（C）
erwuhuoche的博客
03-29 465
引言 要实现静态顺序表，我们首先需要知道什么是顺序表。 顺序表是指用一段地址连续的存储单元依次存取数据元素的线性结构。 顺序表采用的是连续的地址空间，这是与链表的本质区别。对于连续的地址空间，我们一般采用数组，而数组又分为静态数组和动态数组。我们本次要实现的就是采用静态数组的顺序表。 实现静态顺序表的操作 静态顺序表的结构体 typedef char SeqListType; ...
C语言-静态实现顺序表
Demons的博客
04-19 337
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;
顺序表和链表各自的优缺点
最新发布
07-15
顺序表和链表是两种常见的线性数据结构，它们各自具有一些优缺点。 顺序表的优点： 1. 存储结构简单，容易实现； 2. 存取速度快，因为数据在内存中是连续存储的，可以直接通过下标访问； 3. 在实现静态查找和排序...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值