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

最新推荐文章于 2024-05-12 22:38:02 发布
最新推荐文章于 2024-05-12 22:38:02 发布
阅读量183 收藏 1
点赞数
文章标签： c/c++
原文链接：http://www.cnblogs.com/Lynn-Zhang/p/5385600.html
版权

顺序表是在计算机内存中以数组的形式保存的线性表，是指用一组地址连续的存储单元依次存储数据元素的线性结构。

 1.顺序表的结构体声明

#define MAX_SIZE 5       //定义数组的大小
typedef int DataType;
typedef struct SeqList
{
    DataType array[MAX_SIZE];
    size_t size;
}SeqList;

2.顺序表的初始化

void InitSeqList(SeqList* pSeq)         //址传递要用到指针
{
    assert(pSeq);
    memset(pSeq->array, 0, sizeof(DataType)*MAX_SIZE);    //初始化数组
    pSeq->size = 0;
}

3.顺序表 尾插、尾删、打印

//1.检查参数
//2.边界条件的检查
//3.完成功能函数
 
//尾插
void PushBack(SeqList* pSeq, DataType x)
{
    assert(pSeq);        //检查参数
    if (pSeq->size >= MAX_SIZE)      //边界条件检查
    {
        printf("SeqList is Full !");
        printf("\n");
        return;
    }
    pSeq->array[pSeq->size++] = x;
}
//尾删
void PopBack(SeqList* pSeq)
{
    assert(pSeq);      //检查参数
    if (pSeq->size <=0)           //边界条件检查
    {
        printf("SeqList is empty !");
        printf("\n");
        return;
    }
    //pSeq->array[--pSeq->size] = 0;
    --pSeq->size;
}
//打印
void PrintSeqList(SeqList* pSeq)
{
    assert(pSeq);         //检查参数
    int i = 0;
    for (; i < pSeq->size; i++)         
    {
        printf("%d ", pSeq->array[i]);
    }
    printf("\n");
}

 

4.头插

void PushFront(SeqList* pSeq, DataType x)        
{
    assert(pSeq);      //检查参数
    int begin = pSeq->size - 1;
    if (pSeq->size >= MAX_SIZE)      //边界条件检查
    {
        printf("SeqList is Full !");
        printf("\n");
        return;
    }
    //把已经存好的数据依次向后挪动一位后，在顺序表的首位置插入x
    for (; begin >= 0; --begin)
    {
        pSeq->array[begin + 1] = pSeq->array[begin];
    }
    pSeq->array[0] = x;
    ++pSeq->size;
}

 5.头删

void PopFront(SeqList* pSeq)            
{
    assert(pSeq);       //检查参数
    int begin = 0;
    if (pSeq->size <= 0)          //检查边界条件，顺序表可能为空
    {
        printf("SeqList is empty !\n");
    }
    //把顺序表的数据依次向前挪一位
    for (; begin <pSeq->size-1; begin++)
    {
        pSeq->array[begin] = pSeq->array[begin + 1];
    }
    --pSeq->size;
}

 6.固定位置插入数据和删除数据

//固定位置插入数据
void Insert(SeqList* pSeq, size_t pos, DataType x)    
{
    assert(pSeq);         //检查参数
    assert(pos<=pSeq->size);       //检查位置的有效性
    int begin = pSeq->size - 1;
    if (pSeq->size >= MAX_SIZE)     //检查边界条件，如果顺序表已满则无法插入
    {
        printf("SeqList is Full !");
        printf("\n");
        return;
    }
    //把从pos开始后面的数据依次向后挪，再在pos位置处添加数据x
    for (; begin >=(int) pos; begin--)       //begin和pos的数据类型要相同再比较
    {
        pSeq->array[begin+1] = pSeq->array[begin];
    }
    pSeq->array[pos] = x;
    ++pSeq->size;        //添加数据后size自增一
}
//固定位置删除数据
void Erase(SeqList* pSeq, size_t pos)
{
    assert(pSeq);      //检查参数的有效性
    assert(pos < pSeq->size);     //检查位置的有效性  
    int begin = pos;
    if (pSeq->size <= 0)            //检查边界条件
    {
        printf("SeqList is empty !");
        printf("\n");
        return;
    }
    //把pos后的数据依次向前挪一位
    for (; begin <= pSeq->size - 1; begin++)
    {
        pSeq->array[begin] = pSeq->array[begin + 1];
    }
    --pSeq->size;
}

7.查找数据、找到数据并删除它

//查找
int Find(SeqList* pSeq, size_t pos, DataType x)
{
    assert(pSeq);       //检查参数
    int i= pos;
    for (;i < pSeq->size; i++)             
    {
        if (pSeq->array[i] == x)
            return i;
    }
    return -1;
}
//查找并删除
int Remove(SeqList* pSeq, DataType x)
{
    assert(pSeq);                //检查参数
    int pos = Find(pSeq, 0,x);   //先找到x并返回它的位置，如果找到就删了它
    if (pos != -1)                 
    {
        Erase(pSeq, pos);
    }
    return pos;
}

 8.删除顺序表中所有相同的x

//删除所有x
void RemoveAll(SeqList* pSeq, DataType x)
{
    //从第一个数开始找，找到就删除，删了后再从下一个位置接着找
    assert(pSeq);              //检查参数
    int pos = Find(pSeq, 0, x);       
    while (pos !=-1)
    {
        Erase(pSeq, pos);
        pos = Find(pSeq,pos, x);
    }
}

 优化（遍历一遍就把所有的x删除，并把后面的数据向前挪动相应个的位置）

void removeall(SeqList* pSeq, DataType x)          
{
    assert(pSeq);
    int i = 0;
    int count = 0;
    for (; i < pSeq->size; i++)
    {
        if (pSeq->array[i] == x)
        {
            count++;
        }
        else
        {
        pSeq->array[i-count] = pSeq->array[i];
        }
    }
    pSeq->size -= count;   //删完挪完后size要删多少就减多少
}

 9.顺序表的二分查找

int BinarySearch(SeqList* pSeq, DataType x)
{
    assert(pSeq);
    int left = 0;
    //int right = pSeq->size - 1;          //  [  ]  注意边界
    int right = pSeq->size;               //  [  )
    //while (left <= right)
    while (left<right)
    {
        int mid = left - (left - right) / 2;   //防止溢出
        if (pSeq->array[mid] == x)
        {
            return mid;
        }
        else if (pSeq->array[mid]>x)
        {
            right = mid - 1;
            //right = mid;
        }
        else if (pSeq->array[mid]<x)
        {
            left = mid + 1;
        }
    }
    return -1;
}

 10.冒泡排序

void BubbleSort(SeqList* pSeq)
{
    assert(pSeq);    //检查参数
    int i, j;
    int ret = 0;
    for (i = 0; i < pSeq->size - 1; i++)
    {
            int exchange=0;
        for (j = 0; j < pSeq->size - i - 1; j++)
        {
            if (pSeq->array[j]> pSeq->array[j + 1])
            {
                ret = pSeq->array[j];
                pSeq->array[j] = pSeq->array[j + 1];
                pSeq->array[j + 1] = ret;
                exchange=1;
            }
        }
        if(exchange==0)   //如果没有发生交换，说明次序已经排好
        {
           return ;
        }
    }
}

 11.选择排序

//一次选出最大最小的数据分别放在序列的两端
void Swap(DataType* left,DataType*right)
{
    DataType tmp = *left;
    *left = *right;
    *right = tmp;
}
void SeclectSort(SeqList* pSeq)
{
    assert(pSeq);
    int left = 0;
    int right = pSeq->size - 1;
    int ret ,min,max;
    while (left<right)
    {
        min = left;
        max = right;
        for (int i = left; i<right; ++i)
        {
            if (pSeq->array[min]>pSeq->array[i])
            {
                Swap(&pSeq->array[min], &pSeq->array[i]);
            }
            if (pSeq->array[max]<pSeq->array[i])
            {
                Swap(&pSeq->array[max], &pSeq->array[i]);
            }  
        }
        ++left;
        --right;
    }
}

 简单的测试与主函数

void Test()
{
    SeqList seq;
    InitSeqList(&seq);
 
    PushBack(&seq, 1);
    PushBack(&seq, 4);
    PushBack(&seq, 5);
    PushBack(&seq, 2);
    PushBack(&seq, 3);
 
    PrintSeqList(&seq);
     
    SeclectSort(&seq);
    PrintSeqList(&seq);
}
int main()
{
    Test();
    system("pause");
    return 0;
}

 

转载于:https://www.cnblogs.com/Lynn-Zhang/p/5385600.html

weixin_30940783
关注
顺序表的静态存储c语言实现
ssopp24的博客
12-05 1514
顺序表的静态存储： 通过数组保存数据，程序分2个源文件和一个头文件： sxb.h包含程序需要用到的函数原型和结构声明，一般类型定义 test.c用来测试程序 sxb.c包含用到的函数实现 test.c: /* 顺序表 */ #include #include #include "sxb.h" //定义SeqList，DataType void Men
C语言实现顺序表（静态实现）
近未来
09-22 2049
顺序表：用一段地址连续的存储地址单元一次存储数据元素的线性结构。 实现一个具有增、删、查、改、初始化、输入、打印等简单功能的顺序表。 实现代码如下： #include <stdio.h> #include <stdlib.h> #include <assert.h> typedef int DataType; #define MAX_SIZE (...
顺序表-静态存储（C语言）
qq_41607217的博客
03-14 454
线性表数组实现（C语言） 线性表是最基本、最简单、也是最常用的一种数据结构。线性表（linear list）是数据结构的一种，一个线性表是n个具有相同特性的数据元素的有限序列。 线性表中数据元素之间的关系是一对一的关系，即除了第一个和最后一个数据元素之外，其它数据元素都是首尾相接的（注意，这句话只适用大部分线性表，而不是全部。比如，循环链表逻辑层次上也是一种线性表（存储层次上属于链式存储，但是把最后一个数据元素的尾指针指向了首位结点）。 线性表的相邻元素之间存在着序偶关系。如用（a1，…，ai-1，ai，a
顺序表的静态存储
weixin_34138056的博客
01-03 174
顺序表是在计算机内存中以数组的形式保存的线性表，是指用一组地址连续的存储单元依次存储数据元素的线性结构。1.顺序表的结构体声明#defineMAX_SIZE5//定义数组的大小 typedefintDataType; typedefstructSeqList { DataTypearray[MAX_SIZE]; size_tsize; }Se...
数据结构-顺序表的静态存储
tzy134679的博客
11-04 626
线性表是具有相同数据类型(每个数据元素所占空间一样大)的n个数据元素的有限序列（有次序），其中n为表长，当n=0时线性表是一个空表。若用L命名线性表，则其一般表示为L=（ a1 , a2 ,...., ai ,...., an ） 常见的线性结构有：线性表，栈，队列，双队列，数组，串。 下面我们来实现一下静态顺序表的创建、初始化、尾插法 //创建一个SeqList头文件 #pragma once #define MAX_SIZE 100 #include <stdio.h> .
数据结构与算法学习笔记一---顺序表的静态存储表示和实现(C++)
最新发布
我叫柱子哥
05-12 244
这篇文章讲的是顺序表的静态存储表示。
C语言实现静态顺序表的实例详解
01-01
C语言实现静态顺序表的实例详解 线性表 定义一张顺序表也就是在内存中开辟一段连续的存储空间，并给它一个名字进行标识。只有定义了一个顺序表，才能利用该顺序表存放数据元素，也才能对该顺序表进行各种操作。 接...
C语言实现动态顺序表的实现代码
12-31
C语言实现动态顺序表的实现代码 顺序表是在计算机内存中以数组的形式保存的线性表，是指用一组地址连续的存储单元依次存储数据元素的线性结构。线性表采用顺序存储的方式存储就称之为顺序表。顺序表是将表中的结点...
数据结构-顺序表（静态分配存储空间）
快乐的小小程序猿
09-21 3424
#include <stdio.h> /** * 数组空间静态分配 */ #define MaxSize 100 //表示有MaxSize个位置 typedef struct { int data[MaxSize]; //定义一个数组空间，用于存储数据 int length; //记录线性表当前的长度，即已有多少个数据 }SeqList; //自定义的顺序表类型为S...
创建一个静态的顺序表存放整数
04-17
创建一个静态的顺序表存放整数。大小为10.完成以下的操作输入6个整数，1.打 印出顺序表中的内容，并显示表中剩余的空间个数。在顺序表中的第3个位置插入元素O.2.打印出顺序表中的内容，并显示表中剩余的空间个数。再试图向表中第11个位置插入整数0,3.程序提示超出范围。4.删除表中第6个元素，打印出顺序表中的内容，并显示表中剩余的空间个数。 二：编写一程序，动态地创建一个顺序表。要求顺序表初始长度为20,向顺序表中输 入15个整数，并打印出来: 再删除顺序表中的第5个元素。打印出删除后的结果。
顺序表静态结构结构
To be a better man
08-10 823
//顺序映像的C语言描述 #define LIST_SIZE 100 //存储 //线性表静态分配顺序存储结构 typedef struct{ ElemType elem[LIST_SIZE]; int length; //当前长度 }Sqlist; /* 在线性表的静态分配存储结构中,线性表中的最多元素个数为LIST_SIZE, 元素数量不能随意增加,这是以数组方式描述线性表的缺点 ...
C语言实现静态顺序表
five_year的博客
09-16 360
SepList.h文件 #ifndef __TEST_H__ #define __TEST_H__ #include #include #include #include #define N 100 typedef int DataType; typedef struct SepList                      
数据结构——线性表的顺序存储（静态分配）
jasmoyn的博客
04-04 469
数据结构 线性表的顺序存储（静态分配） 跟着王道学习数据结构，边学边打代码。 //顺序表的静态分配 #include<stdio.h> #define maxsize 50 //定义顺序表的最大数据存储量 //创建表 typedef struct{ int x[maxsize];// int length;//记录表长 }sqlist; //初始化 void initlist(sqlist &L){ L.length=0; printf("初始化成功\n"); }
数据结构之静态顺序表的实现
曾经
06-18 630
静态顺序表 特点： 静态数据表的增改删查   //静态顺序表的增改删查 #include&lt;stdio.h&gt; #include&lt;assert.h&gt; #include&lt;memory.h&gt; #include &lt;stdlib.h&gt; typedef int DataType;//顺序表元素类型 #define MAX 100//顺序表的数组的大小 ...
C语言顺序表的静态建立
m0_51894865的博客
09-17 487
2. 除最后一个元素以外，每个元素都有一个后继；1. 除第一个元素以外，每个元素都有一个前驱；定义：n个相同数据元素组成的有限的序列；3. 一对一的关系；
顺序表的基本建立，以及增删改查的相关操作（c语言描述之顺序表）
jgdabc的博客
12-05 1725
c语言描述之顺序表一: 顺序表是什么二：顺序表与链表的区别三： 顺序表的代码实现操作 一: 顺序表是什么 在c语言描述的数据结构里，顺序表是一种线性存储结构。线性存取结构又是什么？ 我们可以这样理解，线性存取就是将一串具有相同特征的数据用一根线串接起来，然后再放到我们的存储之中。当然，数据结构都是抽象出来的概念，但是这种抽象的理解方式也就掩盖了底层的复杂，也就方便我们去操作内存。 二：顺序表与链表的区别 顺序表是将元素放到一块连续的内存存取空间的。在存取元素数据之前，需要申请一块足够大的内存空间，数据
数据结构复习笔记（一）——静态顺序表（C语言）
Lazyyben
09-20 343
定义结构体 typedef struct{ int data[MAXSIZE]; //MAXSIZE为最大容量 int length; //当前长度 } Array; 创建顺序表 /* 需要接受一个已知的数组，以及该数组的长度 按顺序将数组内的值，赋给顺序表结构体中的数组 返回一个顺序表的结构体 */ Array array_create(int a[],int leng...
静态分配内存的顺序表的定义及基本操作（C语言版） 超详细！！
qq_42890853的博客
06-16 599
#include<stdio.h> #define maxsize 100 struct sqlist {//采用固定长度的静态顺序表 int length; int data[maxsize]; }; //struct sqlist list; ////这样就定义好了一个顺序表,名字为list //struct sqlist *plist; ////这样就定义好了一个可以指向顺序表的指针,名字为plist //顺序表的初始化 void initialize_list(
数据结构中静态顺序表的实现和增删查改。。。
GangStudyIT的博客
12-08 450
静态顺序表是把大小已经分配好，顺序表是利用数组，实现增删查改。 首先我们要声明一个结构体，定义一个数组，它的总大小 ，还有一个用来计数它实际的大小。 我们来看代码。 先看头文件的声明： #pragma once #include #define sequence_table_max_length 100 #define TYPECHAR char #define SHOWTYPE "%c"
C语言实现静态顺序表操作的代码详解
"C语言实现静态顺序表的实例详解" 在计算机科学中，数据结构是组织和存储数据的方式，而线性表是其中最基本且常用的一种。线性表是由n（n>=0）个相同类型元素构成的有限序列，其中每个元素都有一个前驱和后继（除了...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值