顺序表静态与动态实现及基本的操作（增删查改等）

最新推荐文章于 2022-10-26 20:35:06 发布
最新推荐文章于 2022-10-26 20:35:06 发布
阅读量658 收藏
点赞数
分类专栏： c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xs_520/article/details/53586898
版权 
//seqlist.h
#define _CRT_SECURE_NO_WARNINGS 1
#ifndef _SEQLIST_
#define _SEQLIST_
#define MAX_SIZE 8
typedef  int Datatype;
typedef struct seqlist//静态顺序表的声明
{
    Datatype array[MAX_SIZE];
    unsigned int size;//记录当前顺序表的有效长度

}seqlist;
void Initseqlist(seqlist* s);
void Printseqlist(seqlist* s);
void Pushback(seqlist* s, Datatype a);
void Popback(seqlist* s);
void Pushfront(seqlist* s, Datatype a);
void Popfront(seqlist* s);
void Insert(seqlist* s, unsigned int pos, Datatype a);
void Erase(seqlist* s, unsigned int pos);
int find(seqlist* s, Datatype a);
void Remove(seqlist* s, Datatype a);
void RemoveAll(seqlist* s, Datatype a);
void Bubblesort(seqlist* s);
void Selectesort(seqlist* s);
void Insertsort(seqlist* s);
int Binarysearch(seqlist* s,Datatype a);
#endif
//seqlist.c
#define _CRT_SECURE_NO_WARNINGS 1
#include "Seqlist.h"
#include <assert.h>
#include <string.h>
#include <stdio.h>
void Initseqlist(seqlist* s)//初始化顺序表
{
    assert(s);
    memset(s, 0, MAX_SIZE*sizeof(Datatype));
    s->size = 0;
}
void Printseqlist(seqlist* s)//打印顺序表
{
    assert(s);
    int i = 0;
    for (i = 0; i < (int)(s->size); i++)
    {
        printf("%d ", s->array[i]);
    }
    printf("\n");
}

void Pushback(seqlist* s, Datatype a)//尾插
{
    assert(s);
    if (s->size >= MAX_SIZE)
    {
        printf("the seqlist is full\n");
        return;
    }
    s->array[s->size] = a;
    s->size++;
}
void Popback(seqlist* s)//尾删
{
    assert(s);
    if (s->size == 0)
    {
        printf("the seqlist is empty\n");
        return;
    }
    s->size--;
}
void Pushfront(seqlist* s, Datatype a)
{
    assert(s);
    if (s->size >= MAX_SIZE)
    {
        printf("the seqlist is full\n");
        return;
    }
    int end = s->size - 1;
    while (end>=0)
    {
        s->array[end + 1] = s->array[end];
        end--;
    }
    s->array[0] = a;
    s->size++;
}
void Popfront(seqlist* s)
{
    assert(s);
    if (s->size == 0)
    {
        printf("list is empty!\n");
        return;
    }
    else
    {
        int i = 0;
        for (i = 0; i < (int)s->size-1; i++)
        {
            s->array[i] = s->array[i+1];
        }
        s->size--;
    }
}
void Insert(seqlist* s, unsigned int pos, Datatype a)//在指定位置插入数据
{
    assert(s);
    if (s->size >= MAX_SIZE)
    {
        printf("list is full\n");
        return;
    }
    unsigned int i = 0;
    for (i = (int)s->size-1; i>=pos-1; i--)
    {
        s->array[i + 1] = s->array[i];
    }
    s->array[pos-1] = a;
    s->size++;
}
int find(seqlist* s, Datatype a)
{
    assert(s);
    unsigned int i = 0;
    for (i = 0; i < s->size; i++)
    {
        if (s->array[i] == a)
        {
            return i;
        }
    }
    return -1;
}
void Erase(seqlist* s, unsigned int pos)
{
    assert(s);
    assert(pos < s->size);
    if (s->size== 0)
    {
        printf("list is empty!\n");
        return;
    }
    unsigned int i = 0;
    for (i = pos-1; i < s->size-1; i++)
    {
        s->array[i] = s->array[i + 1];
    }
    s->size--;
}
void Remove(seqlist* s, Datatype a)
{
    assert(s);
    int pos = find(s, a);
    if (s->size == 0)
    {
        printf("list is empty!\n");
        return;
    }
    if ( pos == -1)
    {
        printf("not exist the data\n");
        return;

    }
    int i = 0;
    for (i = pos ; i < (int)s->size - 1; i++)
    {
        s->array[i] = s->array[i + 1];
    }
    s->size--;
}
void RemoveAll(seqlist* s, Datatype a)
{
    assert(s);
    unsigned i = 0;
    unsigned count = 0;
    for (i = 0; i < s->size; i++)
    {
        if (s->array[i] == a)
        {
            count++;
        }
        else
        {
            s->array[i - count] = s->array[i];

        }
    }
    s->size -= count;
}
void Bubblesort(seqlist* s)
{
    assert(s);
    unsigned int i = 0;
    int flag = 0;
    for (i = 0; i < s->size-1; i++)
    {
        unsigned int j = 0;
        flag = 0;
        for (j = 0; j < s->size - i - 1; j++)
        {
            if (s->array[j]>s->array[j + 1])
            {
                Datatype temp = s->array[j];
                s->array[j] = s->array[j + 1];
                s->array[j + 1] = temp;
                flag = 1;
            }

        }
        if (!flag)
        {
            return;
        }
    }

}
void Selectesort(seqlist* s)
{
    assert(s);
    int min_index = 0;
    int max_index = 0;
    int i = 0;
    int start = 0;
    int end = (int)s->size - 1;
    while (start < end)
    {
        min_index = start;
        max_index = end;
        for (i = start; i<=end; i++)
        {
            if (s->array[i]<s->array[min_index])
            {
                min_index = i;
            }
            if (s->array[i]>s->array[max_index])
            {
                max_index = i;
            }
        }
        Datatype temp1 = s->array[start];
        s->array[start] = s->array [min_index];
        s->array[min_index] = temp1;
        if (max_index == start)
        {
            max_index = min_index;
        }
        Datatype temp2 = s->array[end];
        s->array[end] = s->array[max_index];
        s->array[max_index] = temp2;
        end--;
        start++;

    }
}
void Insertsort(seqlist* s)
{
    assert(s);
    unsigned int i = 0;
    unsigned int end = 0;
    for (i = 0; i < s->size-1; i++)
    {
         end = i;
        Datatype temp = s->array[end + 1];
        while (end >= 0 && s->array[end]>temp)
        {
            s->array[end + 1] = s->array[end];
            end--;
        }
        s->array[end+1] = temp;
    }
}
int Binarysearch(seqlist* s,Datatype a)
{
    assert(s);
    int left = 0;
    int right = (int)s->size-1;
    int mid = 0;
    while (left <= right)
    {
        mid = left + ((right - left) >> 1);
        if (s->array[mid] > a)
        {
            right = mid - 1;
        }
        else if (s->array[mid] < a)
        {
            left = mid + 1;
        }
        else
        {
            return mid;
        }
    }
    return -1;
}
//test.c
#include "Seqlist.h"
#include <stdio.h>
#include <Windows.h>
//void test1()//pushback,popback
//{
//  seqlist seq;
//  Initseqlist(&seq);
//  Pushback(&seq, 1);
//  Pushback(&seq, 2);
//  Pushback(&seq, 3);
//  Pushback(&seq, 4);
//  Pushback(&seq, 5);
//  Pushback(&seq, 6);
//  Printseqlist(&seq);
//  Popback(&seq);
//  Popback(&seq);
//  Popback(&seq);
//  Popback(&seq);
//  Popback(&seq);
//  Printseqlist(&seq);
//  Popback(&seq);
//  Printseqlist(&seq);
//}
void test2()//pushfront popfront
{
    seqlist seq;
    Initseqlist(&seq);
    Pushfront(&seq, 1);
    Pushfront(&seq, 2);
    Pushfront(&seq, 3);
    Pushfront(&seq, 4);
    Pushfront(&seq, 5);
    Pushfront(&seq, 6);
    Printseqlist(&seq);
    Popfront(&seq);
    Popfront(&seq);
    Popfront(&seq);
    Popfront(&seq);
    Popfront(&seq);
    Popfront(&seq);
    Printseqlist(&seq);
}
void test3()
{
    seqlist seq;
    Initseqlist(&seq);
    Pushfront(&seq, 3);
    Pushfront(&seq, 2);
    Pushfront(&seq, 3);
    Pushfront(&seq, 5);
    Pushfront(&seq, 5);
    Pushfront(&seq, 3);

    Printseqlist(&seq);
    //Insert(&seq, 3, 0);
    //Printseqlist(&seq);
    //Erase(&seq, 2);
    //Printseqlist(&seq);
    //Remove(&seq, 0);
    //Remove(&seq, 1);
    //Remove(&seq, 6);
    RemoveAll(&seq, 3);
    Printseqlist(&seq);
}
void test4()//sort
{
    seqlist seq;
    Initseqlist(&seq);
    Pushback(&seq, 1);
    Pushback(&seq, 2);
    Pushback(&seq, 4);
    Pushback(&seq, 4);
    Pushback(&seq, 7);
    Pushback(&seq, 8);
    Bubblesort(&seq);
    //Selectesort(&seq);
    //Insertsort(&seq);
    Printseqlist(&seq);

    int pos = Binarysearch(&seq, 7);
    if (pos == -1)
    {
        printf("not exists\n");
    }
    else
    {
        printf("%d\n", pos);
    }


}
int main()
{
    //test1();
    //test2();
    //test3();
    test4();
    system("pause");
    return 0;
}
//实现顺序表的动态增长
Dseqlist.h
#pragma once
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#include <Windows.h>
typedef int Datatype;
typedef struct Dseqlist
{
    Datatype *array;
    size_t size;//有效长度
    size_t capacity;//顺序表的当前容量
}Dseqlist;
void InitDseqlist(Dseqlist* seq);
void Checkcapacity(Dseqlist* seq);
void Printseqlist(Dseqlist* seq);//打印顺序表
void Pushback(Dseqlist* seq, Datatype a);//尾插
void Pushfront(Dseqlist* seq, Datatype a);
void Destory(Dseqlist* seq);
//Dseqlist.c
#define _CRT_SECURE_NO_WARNINGS 1
#include "Dseqlist.h"
void InitDseqlist(Dseqlist* seq)
{
    assert(seq);
    seq->array = (Datatype*)malloc(sizeof(Datatype)* 3);
    assert(seq->array);
    seq->size = 0;
    seq->capacity = 3;
//刚开始初始化容量为3
}
void Checkcapacity(Dseqlist* seq)
//检查顺序表是否溢出，并扩容
{
    if (seq->size >= seq->capacity)
    {
        seq->array = (Datatype*)realloc(seq->array,sizeof(Datatype)* seq->capacity*2);
        assert(seq->array);
        seq->capacity *= 2;
    }
}
void Printseqlist(Dseqlist* seq)//打印顺序表
{
    assert(seq);
    int i = 0;
    for (i = 0; i < (int)(seq->size); i++)
    {
        printf("%d ", seq->array[i]);
    }
    printf("\n");
}
void Pushback(Dseqlist* seq, Datatype a)//尾插
{
    assert(seq);
    Checkcapacity(seq);
    seq->array[seq->size] = a;
    seq->size++;
}
void Pushfront(Dseqlist* seq, Datatype a)
{
    assert(seq);
    Checkcapacity(seq);
    int end = seq->size - 1;
    while (end >= 0)
    {
        seq->array[end + 1] = seq->array[end];
        end--;
    }
    seq->array[0] = a;
    seq->size++;
}
void Destory(Dseqlist* seq)
{
    assert(seq);
    if (seq->array)
    {
        free(seq->array);
    }
    seq->array = NULL;
    seq->size = 0;
    seq->capacity = 0;
}
鱼忆七秒呐
关注
专栏目录
数据结构之静态顺序表和动态顺序表
Sock的博客
12-02 1356
@Sock对静态顺序表和动态顺序表的总结 简单概括他们的异同点 相同点:内存空间连续, 数据顺序存储 不同点:它们所占内存空间的位置不同, 静态定义一个顺序表, 顺序表所占的内存空间开辟在内存的静态区, 即所谓的函数栈上, 随着函数调用的结束, 这块内存区域会被系统自动回收; 而动态生成一个顺序表, 顺序表所占的内存空间开辟在内存的动态区, 即所谓的堆内存上, 这块区域不会随着函数调用的结束被...
顺序表和链表的增删查改操作
aaaaauaan的博客
05-27 848
1. 线性表 线性表(linear list)是n个具有相同特色的数据元素的有限序列。线性表是一种在实际中广泛使用的数据结构，常用的线性表：顺序表、链表、栈、队列、字符串… 线性表在逻辑上是线性结构，也就是说是连续的一条直线。但在物理结构上并不是连续的，线性表在物理上存储时，通常以数组和链表结构的形式存储。 **2.顺序表 2.1概念及结构 顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。 顺序表一般分为： 1.静态顺序表：使用定长数组存
C++实现静态顺序表的增删查改以及初始化
weixin_33730836的博客
03-21 147
C++实现静态顺序表的增删查改顺序表：用一段地址连续的存储单元依s次存储数据元素的线性结构，是线性表的一种。//SeqList.h #pragmaonce #include<assert.h> #include<string.h> #defineMAX_SIZE5 typedefintDataType; //定义顺序表结构体 ty...
静态顺序表、动态顺序表的操作实现
zhangm2020的博客
06-12 288
代码实现顺序表的操作函数头文件实现：//值类型typedef int DataType;typedef struct SeqList { DataType data; // 值 int size; // 数量} SeqList;源文件实现：// 1、初始化void SeqListInit(SeqList *pSL);// 2、尾部插入void SeqListPushBack(SeqList *...
顺序表的相关操作（静态&动态）
The Laughing Uncle的博客
09-09 489
静态顺序表 定义 定义结构体 初始化顺序表 销毁顺序表 打印顺序表 插入元素 尾插 头插 任意位置插入元素 删除元素 尾删 头删 任意位置删除 删除遇见的第一个指定元素 删除所有的指定元素 查找指定元素 排序 冒泡排序 选择排序 测试函数 动态顺序表 定义结构体 初始化 销毁 插入 尾插 头插 任意位置插入元素 一般情...
c语言：【顺序表】静态顺序表的删除指定位置元素Erase、删除指定元素Remove
weixin_33895475的博客
02-18 241
#define_CRT_SECURE_NO_WARNINGS1 #include<stdio.h> #include<stdlib.h> #include<assert.h> #include<string.h> #defineMAXSIZE1000 typedefintDateType; typedefstr...
数据结构之线性表重点记录2、静态链表增删查改
qq_44623261的博客
10-26 171
2、找到表中第 2 个节点（添加位置的前一个节点，这里是数据元素 2），将元素 2 的游标赋值给新元素 4；3、将元素 4 所在数组中的下标赋值给元素 2 的游标；1、从备用链表中摘除一个节点，用于存储元素 4；
数据结构学习笔记（数据结构概念、顺序表的增删查改等）详细整理
weixin_44814867的博客
08-11 494
数据结构学习笔记（数据结构概念、顺序表的增删查改等）详细整理数据结构概念顺序表和链表顺序表动态顺序表接口实现 数据结构概念 1.什么是数据结构？ 数据结构(Data Structure)是计算机存储、组织数据的方式，指相互之间存在一种或多种特定关系的数据元素的集合。 2.什么是算法？ 算法(Algorithm):就是定义良好的计算过程，他取一个或一组的值为输入，并产生出一个或一组值作为输出。简单来说算法就是一系列的计算步骤，用来将输入数据转化成输出结果。 3.算法效率 算法效率分析分为两种：第一种是时间效率
学生信息管理系统（实现增删改查操作）Java+Servlet+HTML+CSS+数据库
最新发布
12-09
数据库部分：创建表、增删改查语句的书写等。 前端部分：HTML、CSS、jQuery、JavaScript等。 编码顺序 添加项目需要使用的各种jar包 HTML 页面表单的编写 Apache方法的DBUtils编写 实体类的数据初始化（添加私有...
顺序表的增删查改&&各类排序问题
zjx624bjh的博客
12-23 426
一，静态顺序表增删查改#define MAX_SIZE 10 typedef int DataType; typedef struct SeqList { DataType array[MAX_SIZE]; size_t size; }SeqList; void Print(SeqList* seq) { assert(seq); f
顺序表的增删改查，顺序表
10-10
本程序的顺序表是利用数组实现的，能对数组元素进行增删改查的基本操作
数据结构 顺序表 （c++实现）代码讲解
09-27
这是讲解代码中函数关系的Keynote 为了大家方便，已转换为ppt 博客地址blog.csdn.net/u012350104
顺序表定义 动态分配 插入 删除 查找 妙的算法 C语言实现
加油高同志
04-07 405
线性表的定义 #include <stdio.h> #define MaxSize 10//定义最大长度 typedef struct{ int data[MaxSize];//用静态的“数组”存放数据元素 int length;//当前长度 }SqList;//类型定义，别名 //初始化一个顺序表 void InitSqList(SqList &L){ for(int i=0;i<L.length;i++){ L.data[i]=0;//分配的空间会有一些脏数据，所
静态顺序表的实现（C）
erwuhuoche的博客
03-29 494
引言 要实现静态顺序表，我们首先需要知道什么是顺序表。 顺序表是指用一段地址连续的存储单元依次存取数据元素的线性结构。 顺序表采用的是连续的地址空间，这是与链表的本质区别。对于连续的地址空间，我们一般采用数组，而数组又分为静态数组和动态数组。我们本次要实现的就是采用静态数组的顺序表。 实现静态顺序表的操作 静态顺序表的结构体 typedef char SeqListType; ...
串的静态顺序存储基本操作
物极必反否极泰来
08-31 937
在C语言中没有专门的字符串变量，通常用一个字符数组来存放一个字符串。字符串总是以'\0'作为串的结束符。因此当把一个字符串存入一个数组时，也把结束符 '\0'存入数组，并以此作为该字符串是否结束的标志。有了'\0'标志后，就不能再用字符数组的长度来判断字符串的长度了。 #include #include #define MAXSIZE 225 using namespace std; t
静态顺序表增删查找操作
小白元的博客
11-22 241
    #pragma once #include &lt;stdio.h&gt; #include &lt;assert.h&gt; #include &lt;string.h&gt; #include &lt;windows.h&gt; //#ifndef __SeqList_H__ //#define __SeqList_H__ // //#endif //__SeqList_H...
C++实现静态顺序表与动态顺序表
weixin_44915226的博客
06-16 264
基本功能 静态顺序表用数组实现，需要注意的是，顺序表的第一个元素在数组的第0位。 1.初始化顺序表 2.插入元素（越界处理） 3.按位查找 4.按值查找 5.输出顺序表 6.删除元素 其实无论是C还是C++实现，二者都相似，只是函数传参时不太一样。C++使用“&”，在C中采用指针也可以达到同样的效果。   代码 基本功能已实现，考虑到了插入删除越界问题！ #include <iostream> #include <stdio.h> #define MaxSize
顺序表的创建，插入，修改，删除，查询代码
落花凋心的嵌入式学习过程
07-20 866
#include<stdio.h> #include<stdlib.h>int num[100];#define MAX 100 typedef int DATATYPE;typedef struct { DATATYPE buf[MAX]; int n;//代表了数组下标 }seqlist; seqlist *create_empty_seqlist() { seqlis
C++静态数组顺序表详解与操作实现
本文将深入探讨如何在C++中使用基于静态数组实现顺序表（Sequential List）。顺序表是一种线性数据结构，其中元素存储在连续的内存空间中，支持高效的随机访问。本文的核心知识点包括顺序表在C++中的基础操作： 1. ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值