数据结构—动态顺序表的实现

最新推荐文章于 2022-11-05 17:12:07 发布
最新推荐文章于 2022-11-05 17:12:07 发布
阅读量3.3k 收藏 1
点赞数 1
分类专栏： 数据结构 一起学习C/C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_26768741/article/details/51558274
版权

前面我们实现了顺序表，但是我们应该会考虑到一个问题，顺序表一次性创建那么大空间造成的浪费很多，所以在这里，我们需要一个可以动态增长的顺序表来满足我们的需求！

实现中需要注意的是：在这里我们要注意的是首先你应该给顺序表一个容量，当每次满了的时候，进行扩容！

另外，在这里我分别使用了三种的排序算法：插入排序，选择排序，冒泡排序。

dynamic_seqlist.h

#define _CRT_SECURE_NO_WARNINGS 1
#ifndef __DYNAMIC_SEQLIST_H__
#include<stdlib.h>
#include<stdio.h>
#include<assert.h>


#define INIT_SIZE 3
#define CAPACITY_SIZE 3
typedef int datatype;

typedef struct seqlist
{
    datatype *data;
    int size;
    int capacity;
}Seqlist,*pSeqlist;


static enum seq
{
    EXIT,
    INIT,
    PUSHBACK,
    POPBACK,
    PUSHFRONT,
    POPFRONT,
    INSERT,
    REMOVE,
    REMOVEALL,
    BUBBLESORT,
    SELECTSORT,
    INSERTIONSORT,
    ERASE,
    BINARYSEARCH,
    PRINTFSEQLIST

};

void PrintSeqlist(pSeqlist pSeq);
void InitSqlist(pSeqlist pSeq);
void DestorySeqlist(pSeqlist pSeq);
void PushBack(pSeqlist pSeq, datatype x);
void PopBack(pSeqlist pSeq);
void PushFront(pSeqlist pSeq, datatype x);
void PopFront(pSeqlist pSeq);
void Insert(pSeqlist pSeq, int pos, datatype x);
void Remove(pSeqlist pSeq, datatype x);
void RemoveAll(pSeqlist pSeq, datatype x);
void BubbleSort(pSeqlist pSeq);
void SelectSort(pSeqlist pSeq);
void InsertionSort(pSeqlist pSeq);
void Erase(pSeqlist pSeq, int pos);
int BinarySearch(pSeqlist pSeq, datatype x);


void meau();


#endif // !__DYNAMIC_SEQLIST_H__

dynamic_seqlist.c

#define _CRT_SECURE_NO_WARNINGS 1

#include"dynamic_seqlist.h"

void meau()
{
    printf("$$$$$$$$$$$$$$    SEQLIST    $$$$$$$$$$$$$$$$\n");
	printf("$$$$$$$$$$$$$$$$$$$$$$￥$$$$$$$$$$$$$$$$$$$$$\n");
    printf("$$$  1.init              2.push_back      $$$\n");
    printf("$$$  3.pop_back          4.push_front     $$$\n");
    printf("$$$  5.pop_front         6.insert         $$$\n");
    printf("$$$  7.remove            8.removeall      $$$\n");
    printf("$$$  9.bubblesort        10.selectsort    $$$\n");
    printf("$$$  11.insertionsort    12.earse         $$$\n");
    printf("$$$  13.binarysearch     14.printseqlist  $$$\n");
    printf("$$$                       0.EXIT          $$$\n");
    printf("$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$\n");

}

void InitSqlist(pSeqlist pseq)
{
    pseq->data = (datatype *)malloc(sizeof(datatype)*INIT_SIZE);
    if (NULL == pseq->data)
    {
        perror("out of memory");
        exit(-1);
    }
    pseq->size = 0;
    pseq->capacity = INIT_SIZE;
}

void DestorySeqlist(pSeqlist pSeq)
{
    free(pSeq->data);
    pSeq->data = NULL;
    pSeq->size = 0;
    pSeq->capacity = 0;
}

void PrintSeqlist(pSeqlist pSeq)
{
    int i = 0;
    for (i = 0; i < pSeq->size; i++)
    {
        printf("%3d", pSeq->data[i]);
    }
    printf("\n");
}
void check(pSeqlist pSeq)
{
    datatype *tmp = NULL;
    if (pSeq->size == pSeq->capacity)
    {
        tmp = (datatype *)realloc(pSeq->data, sizeof(datatype)*(pSeq->size + CAPACITY_SIZE));
        if (tmp == NULL)
        {
            perror("out of memory");
            exit(-1);
        }
        else
        {
            pSeq->data = tmp;
            pSeq->capacity += CAPACITY_SIZE;
        }
    }
}
void PushBack(pSeqlist pSeq, datatype x)
{
    check(pSeq);
    pSeq->data[pSeq->size] = x;
    pSeq->size++;
}

void PopBack(pSeqlist pSeq)
{
    if (pSeq->size <= 0)
    {
        printf("顺序表已空\n");
        return;
    }
    pSeq->size--;
}
void PushFront(pSeqlist pSeq, datatype x)
{
    check(pSeq);
    for (int i = pSeq->size; i >= 0; i--)
    {
        pSeq->data[i + 1] = pSeq->data[i];
    }
    pSeq->data[0] = x;
    pSeq->size++;
}

void PopFront(pSeqlist pSeq)
{
    if (pSeq->size <= 0)
    {
        printf("顺序表已空\n");
        return;
    }
    for (int i = 0; i < pSeq->size; i++)
    {
        pSeq->data[i] = pSeq->data[i + 1];
    }
    pSeq->size--;
}
void Insert(pSeqlist pSeq, int pos, datatype x)
{
    check(pSeq);
    for (int i = pSeq->size; i >= pos; i--)
    {
        pSeq->data[i + 1] = pSeq->data[i];
    }
    pSeq->data[pos] = x;
    pSeq->size++;

}
void Remove(pSeqlist pSeq, datatype x)
{
    if (pSeq->size <= 0)
    {
        printf("顺序表已空,无法删除\n");
        return;
    }
    for (int i = 0; i < pSeq->size; i++)
    {
        if (pSeq->data[i] == x)
        {
            for (int j = i; j < pSeq->size - i; j++)
            {
                pSeq->data[j] = pSeq->data[j + 1];
            }
            pSeq->size--;
            return;
        }
    }
}
void RemoveAll(pSeqlist pSeq, datatype x)
{
    if (pSeq->size <= 0)
    {
        printf("顺序表已空,无法删除\n");
        return;
    }
    for (int i = 0; i < pSeq->size; i++)
    {
        if (pSeq->data[i] == x)
        {
            for (int j = i; j <pSeq->size; j++)
            {
                pSeq->data[j] = pSeq->data[j + 1];
            }
            pSeq->size--;
        }
    }
}
void BubbleSort(pSeqlist pSeq)
{

    char ch = 0;
    int i = 0;
    int j = 0;
    if (pSeq->size <= 0)
    {
        printf("顺序表已空,无法排序\n");
        return;
    }
    printf("请选择排序类型（>:从大到小），（<:从小到大）：\n");
    fflush(stdin);
    scanf("%c", &ch);

    switch (ch)
    {
    case'>':
        for (i = 0; i < pSeq->size - 1; i++)
        {
            for (j = 0; j < pSeq->size - i - 1; j++)
            {
                if (pSeq->data[j] < pSeq->data[j + 1])
                {
                    int tmp = pSeq->data[j];
                    pSeq->data[j] = pSeq->data[j + 1];
                    pSeq->data[j + 1] = tmp;
                }
            }
        }
        break;
    case'<':
        for (i = 0; i < pSeq->size - 1; i++)
        {
            for (j = i; j < pSeq->size - i - 1; j++)
            {
                if (pSeq->data[j] > pSeq->data[j + 1])
                {
                    int tmp = pSeq->data[j];
                    pSeq->data[j] = pSeq->data[j + 1];
                    pSeq->data[j + 1] = tmp;
                }
            }
        }
        break;
    default:
        printf("所给出排序类型有问题！\n");
        break;
    };
}
void SelectSort(pSeqlist pSeq)
{
    datatype min = 0;
    int i = 0;
    int j = 0;
    if (pSeq->size <= 0)
    {
        printf("顺序表已空,无法排序\n");
        return;
    }
    for (i = 0; i < pSeq->size - 1; i++)
    {
        min = i ;
        for (j = i + 1; j < pSeq->size; j++)
        {
            if (pSeq->data[min]>pSeq->data[j])
            {
                min = j;
            }
        }
        if (min != i)
        {
            datatype tmp = pSeq->data[i];
            pSeq->data[i] = pSeq->data[min];
            pSeq->data[min] = tmp;
        }
    }
}
void InsertionSort(pSeqlist pSeq)
{
    int i = 0;
    int j = 0;
    if (pSeq->size <= 0)
    {
        printf("顺序表已空,无法排序\n");
        return;
    }
    for (i = 1; i < pSeq->size; i++)
    {
        datatype tmp = pSeq->data[i];
        for (j = i - 1; j >= 0; j--)
        {
            if (pSeq->data[j]>tmp)
            {
                pSeq->data[j + 1] = pSeq->data[j];
            }
            else
            {
                break;
            }
        }
        pSeq->data[j + 1] = tmp;
    }

}
void Erase(pSeqlist pSeq, int pos)
{
    int i = 0;
    if (pSeq->size <= 0)
    {
        printf("顺序表已空,无法删除\n");
        return;
    }
    else if (pos<0 || pos>=pSeq->size)
    {
        printf("输入位置不合法");
        return;
    }
    for (i = pos; i <pSeq->size-1; i++)
    {
        pSeq->data[i] = pSeq->data[i + 1];
    }
    pSeq->size--;
}
int BinarySearch(pSeqlist pSeq, datatype x)
{
    int left = 0;
    int right = pSeq->size - 1;
    int mid = 0;
    while (left <= right)
    {
        mid = (left + right) >> 1;
        if (pSeq->data[mid] < x)
        {
            left = mid + 1;
        }
        else if (pSeq->data[mid]>x)
        {
            right = mid - 1;
        }
        else
            return mid;
    }
    return -1;;
}

test.c

#define _CRT_SECURE_NO_WARNINGS 1

#include"dynamic_seqlist.h"
void Test()
{
    Seqlist seq;
    int input = 1;
    int x = 0;
    int pos = 0;
    int search = 0;
    InitSqlist(&seq);
    while (input)
    {
        meau();
        printf("请选择:");
        scanf("%d", &input);
        fflush(stdin);
        switch (input)
        {
        case INIT:
            InitSqlist(&seq);
            break;
        case PUSHBACK:
            fflush(stdin);
            printf("请输入你所要尾部push的元素：\n");
            scanf("%d", &x);
            PushBack(&seq, x);
            break;
        case POPBACK:
            PopBack(&seq);
            break;
        case PUSHFRONT:
            fflush(stdin);
            printf("请输入你所要头部push的元素：\n");
            scanf("%d", &x);
            PushFront(&seq, x);
            break;
        case POPFRONT:
            PopFront(&seq);
            break;
        case INSERT:
            fflush(stdin);
            printf("请输入你所要插入的元素：\n");
            scanf("%d", &x);
            fflush(stdin);
            printf("请输入你所要插入的位置：\n");
            scanf("%d", &pos);
            Insert(&seq, pos, x);
            break;
        case REMOVE:
            fflush(stdin);
            printf("请输入要删除的元素\n");
            scanf("%d", &x);
            Remove(&seq, x);
            break;
        case REMOVEALL:
            fflush(stdin);
            printf("请输入要删除的元素\n");
            scanf("%d", &x);
            RemoveAll(&seq, x);
            break;
        case BUBBLESORT:
            BubbleSort(&seq);
            break;
        case SELECTSORT:
            SelectSort(&seq);
            break;
        case INSERTIONSORT:
            InsertionSort(&seq);
            break;
        case ERASE:
            fflush(stdin);
            printf("请输入你所要删除元素的位置");
            scanf("%d", &pos);
            Erase(&seq,pos);
            break;
        case BINARYSEARCH:
            printf("请输入要二分查找的元素\n");
            fflush(stdin);
            scanf("%d", &x);
            search = BinarySearch(&seq, x);
            printf("%d所在的位置是：%d", x, search);
            break;
        case EXIT:
            DestorySeqlist(&seq);
            input = 0;
            break;
        case PRINTFSEQLIST:
            PrintSeqlist(&seq);
            break;
        default:
            break;
        }
    }

}

int main()
{
    Test();


    system("pause");
    return 0;
}
宇哲_安菲尔德
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
动态顺序表
melody_1016的博客
11-12 381
我们对静态顺序表可能比较熟悉，它的定义方式是 struct SeqList { int arr[100]; int _size;//当前存放数据的个数 }; 主要思想就是利用数组可以一次性开辟一整块空间，存放我们想要的数据。从这个结构体的定义，我们可以获得如下信息： 开辟的空间大小为100，（即可以存放100个整型数据），_size记录了当前数组中有效元素的个数，为什么要有这一...
数据结构c++实现（动态表）
weixin_45951867的博客
02-17 477
动态表 动态表是在静态表上的一个扩充， 可以理解为静态表这个数组的大小固定，无法对新增的数据进行传入， 但是动态表可以将原数组的固定容量增加IncreaseSize个单元。 由于动态表本身也是一张线性表，所以和静态表的操作大致相似，只不过是增加了一个扩充表的大小的函数。 函数： 函数： void Init_List(SqList &L) //初始化 void Scanf_List(SqList &L, int d) //输入值 void Print_List(SqList L) //
数据结构-考研-第八章——排序（各种算法总结 + 动态演示）
m0_46638350的博客
11-05 768
数据结构、23考研、第八章、排序、动图演示、总结
【数据结构初阶】：动态顺序表的功能实现（用C语言实现，附图分析）
平凡的指针的博客
10-16 1079
文章目录一、动态版本顺序表二、动态顺序表的实现思路三、动态顺序表内存布局图四、初始化顺序表和内存释放五、顺序表接口实现：1.尾部插入数据2.头部插入数据3.尾部删除数据4.头部删除数据5.显示数据6.查找数据7.在某个位置插入数据8.在某个位置删除数据六、对头插 尾插 头删 尾删 的改造七、总结 一、动态版本顺序表 在实现顺序表之前，我们要知道顺序表按照能不能扩容可以分为两种版本，静态版本和动态版本。 静态版本就是把内容存到数组中，一旦数组在内存栈上开辟了，当数据存满的时候就不能再继续存储了。所以针对这个.
（数据结构）动态顺序表的实现
liu15389274611的博客
05-17 883
#pragma once #include&lt;malloc.h&gt; #include&lt;stdio.h&gt; typedef int DataType; typedef struct SeqListD { Datatype* _array; int _size;//有效元素的个数 int _capacity;//空间的总大小 }SeqListD, *PSeqListD;_ar...
数据结构顺序表，c语言简单实现
01-12
数据结构顺序表，c语言简单实现
【数据结构实现】C语言实现顺序表
03-06
本次试验用C语言实现顺序表，实现 Init 初始化线性表 Destory 销毁线性表 Clear 清空线性表 IsEmpty 判断线性表是否为空 Length 获取线性表的长度 GetElem 获取线性表中某个元素的值 Locate 在线性表中查找指定元素 ...
C语言实现动态顺序表的实现代码
12-31
C语言实现动态顺序表的实现代码 顺序表是在计算机内存中以数组的形式保存的线性表，是指用一组地址连续的存储单元依次存储数据...来看看动态的顺序表实现： 1.seqlist.h #define _CRT_SECURE_NO_WARNINGS 1 #ifnd
数据结构-顺序表C++实现
03-30
本学期数据结构第一次实验-顺序表C++实现
数据结构—顺序表实现(C语言版本)
08-04
顺序表的增删查改功能全实现(C语言版本)。 可以作为模板实现高校要求的各种程序设计。
数据结构SeqList.h头文件
03-07
包含数据结构顺序表的基本操作函数（初始化，插入，删除，查找等）
数据结构实验一（顺序表基本操作）题目和源程序
04-02
实验内容： 1．编写程序实现顺序表的下列基本操作： (1)初始化顺序表La。 (2)将La置为空表。 (3)销毁La。 (4)在La中插入一个新的元素。 (5)删除La中的某一元素。 (6)在La中查找某元素，若找到，则返回它在La中第一次出现的位置，否则返回0。 (7)打印输出La中的元素值。 2．编写程序完成下面的操作： (1)构造两个顺序线性表La和Lb，其元素都按值非递减顺序排列。 (2)实现归并La和Lb得到新的顺序表Lc，Lc的元素也按值非递减顺序排列。 (3)假设两个顺序线性表La和Lb分别表示两个集合A和B，利用 union_Sq操作实现A=A∪B。
顺序表的实现（数据结构）
04-22
数据结构（c语言版）关于顺序表的实现
数据结构之动态顺序表
qq_56012214的博客
04-18 1446
数据结构——动态顺序表
c语言实现顺序表（动态）
冷山不生云
01-15 5162
代码如下，代码的解析附于代码中： #include&amp;lt;stdio.h&amp;gt; #include&amp;lt;stdlib.h&amp;gt; #include&amp;lt;assert.h&amp;gt; #define Init_size 5//使顺序表更加灵活 typedef int DataType;//使顺序表具有通用性 typedef struct SeqListD { DataType *_pDa...
数据结构——顺序表（动态）
z_freedom的博客
03-14 1017
本文是对静态顺序表的理解 （这只是在下的粗浅理解，不足的地方还请谅解，欢迎留言提出，后期理解深入后会加以改进） 上一篇对静态顺序表的理解，这一篇是对动态顺序表的理解，相对于静态属性表，动态的顺序表就是能够开辟内存， 静态的是一开始就开辟一个固定容量的数组，满了就不能在装了，而动态的在满了之后还可以进行扩容。 静态顺序表链接： http://blog.csdn.net/
【数据结构】动态顺序表
Victor.Chang
12-13 1733
SeqList.h #ifndef _SEQLISTH_H_ #define _SEQLISTH_H_ #include #include #include typedef int Datatype; typedef struct SeqList { Datatype* _a; size_t _size; // 有效数据个数 size_t _capacity; // 容量
数据结构顺序表的实现
最新发布
06-02
顺序表是一种简单的数据结构，它可以用一块连续的内存空间存储具有相同类型的数据元素。下面是顺序表的实现： ```c++ #define MaxSize 100 // 定义最大长度 typedef struct { int data[MaxSize]; // 用数组存储...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值