SeqList 顺序表的实现

最新推荐文章于 2024-08-15 14:35:42 发布
最新推荐文章于 2024-08-15 14:35:42 发布
阅读量1.5k 收藏 5
点赞数 1
分类专栏： Data Structure 文章标签： 数据结构-顺序表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fuemocheng/article/details/52036131
版权

SeqList.h 

#include "stdio.h"
#include "math.h"

//#define LISTSIZE 100
//typedef int DataType;

typedef struct {
    DataType list[LISTSIZE];
    int length;
}SeqList;

/******************************************************
C 语言中
结构体变量用         .   运算符来访问结构体的成员
指向结构体的指针用   ->  来访问其指向的结构体的成员
*******************************************************/


// 1  初始化顺序表，将顺序表的长度置为0
void InitList(SeqList *L) {
    L->length = 0;
}


// 2  判断顺序表是否为空，为空返回1，不空返回0
int ListEmpty(SeqList L) {
    if (L.length == 0)
        return 1;
    else
        return 0;
}


// 3  按序号查找操作
int GetElem(SeqList L,int i,DataType *e) {
    /*查找顺序表中第 i 个元素
      查找成功将该值返回给 e ,并返回 1 ；否则返回 -1 ，表示失败*/

    if (i<1 || i>L.length)   //查找之前判断序号是否合法
        return -1;
    *e = L.list[i - 1];      //将第 i 个元素赋值给 e
    return 1;
}


// 4  按内容查找操作
int LocateElem(SeqList L, DataType e) {
    /*查找顺序表中元素值为 e 的元素
      查找成功，将对应元素的序号返回；否则返回0，表示失败*/
    int i;
    for (i = 0; i < L.length; i++) 
    {
        if (L.list[i] == e)
            return i;           //返回的序号要搞清楚，从0开始
    }
    return 0;
}


// 5  插入操作
/*
插入                  i                  长度j     
序号  1   2   3   4   5   6   7   8   9   10

                   list[i-1]            list[j-1]   list[j]
list  0   1   2   3   4   5   6   7   8   9
*/
int InsertList(SeqList *L, int i, DataType e) 
{
    /*在顺序表的第 i 个位置插入 元素 e ，插入成功返回 1；
      插入位置不和法，返回 -1；
      顺序表满返回  0 */

    int j;
    if (i<1 || i > L->length + 1)   
    {
        printf("插入位置不合法 ！");
        return -1;
    }
    else if (L->length >= LISTSIZE) 
    {
        printf("顺序表已满不能插入 ！");
        return 0;
    }
    else
    {
        for (j = L->length; j >= i; j--)
            L->list[j] = L->list[j - 1];
        L->list[i - 1] = e;          //插入元素到底 i 个位置 
        L->length =L->length + 1;              //顺序表长度 +1
        return 1;
    }
}

// 6 删除操作
/*
删除                   i                  长度j
序号   1   2   3   4   5   6   7   8   9   10

                    list[i-1]            list[j-1] 
list   0   1   2   3   4   5   6   7   8   9
*/
int DeleteList(SeqList *L, int i, DataType *e) 
{
    int j;
    if (i<1 || i>L->length)      
    {
        printf("删除位置不合法！");
        return -1;
    }
    else if (L->length <= 0) {
        printf("顺序表已空，不能进行删除操作！");
        return 0;
    }
    else
    {
        *e = L->list[i - 1];          //删除的值保存到 e 中，以防要用
        for (j = i; j <= L->length - 1; j++)
            L->list[j - 1] = L->list[j];
        L->length = L->length - 1;
        return 1;
    }

}

// 7 获取长度
int ListLength(SeqList L) {
    return L.length;
}

//清空操作
void ClearList(SeqList *L) {
    L->length = 0;
}

例1：
利用顺序表的基本运算，实现如果在顺序表A中出现的元素，在顺序表B中也出现，则将A中该元素删除

#include <stdio.h>               /*包含输入输出头文件*/
#include <stdlib.h>              /* system("pause") VS编译调试 */
#define LISTSIZE  100
typedef int DataType;

#include "SeqList.h"             /* 包含顺序表实现文件 */

void DelElem(SeqList *A, SeqList B);

void main() {
    int i, j, flag;
    SeqList A, B;
    DataType e;
    InitList(&A);
    InitList(&B);
    for (i = 1; i <= 10; i++) {
        if (InsertList(&A, i, i) == 0)
        {
            printf("插入Seq A出错！");
            return ;
        }
    }
    for (i = 1, j = 1; j <= 6; i = i + 2, j++) {
        if (InsertList(&B, j, i*2) == 0) {
            printf("插入Seq B出错！");
            return ;
        }
    }
    printf("顺序表A中元素的顺序：\n");
    for (i = 0; i <= A.length; i++) {
        flag = GetElem(A, i, &e);
        if (flag == 1)
            printf("%4d", e);
    }
    printf("\n");
    printf("顺序表B中元素的顺序：\n");
    for (i = 0; i <= B.length; i++) {
        flag = GetElem(B, i, &e);
        if (flag == 1)
            printf("%4d", e);
    }
    printf("\n");

    printf("将在A中出现的B的元素删除后A中的元素：\n");

    DelElem(&A,B);

    for (int i = 0; i <= A.length; i++) {
        flag = GetElem(A, i, &e);
        if (flag == 1)
        {
            printf("%4d", e);
        }
    }
    printf("\n");
    system("pause");
}
//删除A中出现的B的元素
void DelElem(SeqList *A ,SeqList B) 
{
    int i,flag,pos;
    DataType e;
    DataType t;
    for (i = 0; i <= B.length; i++) {
        flag = GetElem(B, i, &e);
        if (flag == 1) 
        {
            pos = LocateElem(*A, e);
            if (pos > 0) {
                DeleteList(A, pos+1, &e); //pos+1 容易出现错误的地方
            }
        }
    }
}

运行结果

例2
顺序表A和顺序表B的元素都是非递减排列，利用顺序表的基本运算，将它们合并成一个顺序表C，要求C也是非递减排列。例如，A=（6，11，11，23），B=（2，10，12，12，21），则C=（2，6，11，11，12，12，21，23）。

#include <stdio.h>
#include <stdlib.h>
#define LISTSIZE 100
typedef int DataType;
#include "SeqList.h"

/*合并顺序表 A 和 B 到 C 的函数声明*/
void MergeList(SeqList A, SeqList B, SeqList *C);

void main() {
    int i, flag;
    DataType a[] = { 6,11,11,23 };
    DataType b[] = { 2,10,12,12,21 };
    DataType e;
    SeqList A, B, C;
    InitList(&A);
    InitList(&B);
    InitList(&C);

    /* 数组 a 中的元素插入到顺序表 A 中 */
    for (i = 1; i <= (sizeof(a) / sizeof(a[0])); i++) {
        flag = InsertList(&A, i, a[i - 1]);
        if (flag == 0) {
            printf("插入位置非法！");
            return;
        }
    }
    /* 数组 b 中的元素插入到顺序表 B 中 */
    for (i = 1; i <= (sizeof(b) / sizeof(b[0])); i++) {
        flag = InsertList(&B, i, b[i - 1]);
        if (flag == 0) {
            printf("插入位置非法！");
            return;
        }
    }
    printf("顺序表A中的元素：\n");
    for (i = 1; i <= A.length; i++) {
        flag = GetElem(A, i, &e);
        if (flag == 1)
            printf("%4d", e);
    }
    printf("\n");
    printf("顺序表B中的元素：\n");
    for (i = 1; i <= B.length; i++) {
        flag = GetElem(B, i, &e);
        if (flag == 1)
            printf("%4d", e);
    }
    printf("\n");
    printf("将在A中出现B的元素合并后C中的元素：\n");
    MergeList(A, B, &C);

    for (i = 1; i <= C.length; i++) {
        flag = GetElem(C, i, &e);
        if (flag == 1) {
            printf("%4d", e);
        }
    }
    printf("\n");
    printf("   C.Length:%4d", C.length);
    printf("\n");
    system("pause");
}
void MergeList(SeqList A, SeqList B, SeqList *C) 
{
    int i, j, k;
    DataType e1, e2;
    i = 1; j = 1; k = 1;
    while (i <= A.length&&j <= B.length) { 
        GetElem(A, i, &e1);            //取出顺序表 A 中的元素
        GetElem(B, j, &e2);            //取出顺序表 B 中的元素
        if (e1 <= e2) {                
            InsertList(C, k, e1);      //将较小的插入 C 中
            i++;                       //往后移一个位置，准备比较下一个元素
            k++;                   
        }
        else
        {
            InsertList(C, k, e2);
            j++;
            k++;
        }
    }
    while (i <= A.length)       //如果A中元素还有剩余，这时B中已经没有元素
    {
        GetElem(A, i, &e1);
        InsertList(C, k, e1);   //将A中剩余元素插入到C中
        i++;
        k++;
    }
    while (j <= B.length)       //如果B中还有元素剩余，此时A中已经没有元素
    {
        GetElem(A, j, &e2);
        InsertList(C, k, e2);   //将B中剩余元素插入到C中
        j++;
        k++;
    }
}

运行结果

以上内容来自《跟我学数据结构》陈锐 葛丽萍编著，尊重作者，购买图书。

Spades_J
关注
专栏目录
顺序表Seqlist的基本操作的实现
Lebron
04-11 2173
顺序表基本操作的代码如下： #include<stdio.h> #include<iostream> #include<string> #include<malloc.h> #define LIST_INIT_SIZE 10 #define LIST_INC_SIZE 2 typedef enum { OK = 1, ERROR = -1, POS...
《数据结构》线性表-顺序表
qq_43246915的博客
09-15 310
线性表的顺序存储结构称为顺序表，其基本思想就是用一段地址连续的存储单元依次存储线性表的数据元素。 如何来实现 通常用一维数组来实现顺序表，也就是把线性表中相邻的元素储存在数组中相邻的位置，从而形成一一对应的关系。 需要注意的一点是：C++语言中数组下标是从0开始的，而线性表中元素的序号是从1开始的，也就是说线性表中的第i个元素存储在数组下标为i-1的位置上。 代码实现 #include...
顺序表(SeqList)的理解以及实现
最新发布
Small_entreprene的博客
08-15 1023
SeqList的底层实现（C++），通讯录的实现：模板的好处
Seqlist顺序表的实现
anyway33的博客
04-25 361
Seqlist.h #pragma once #include <stdio.h> #include <stdlib.h> #include <assert.h> typedef int SLDataType; //创立动态顺序表 typedef struct SeqList { SLDataType* a;//指向动态数组的指针 int sz;//数据个数 int capacity;//容量 }SL; void IntiSeqList(SL*
数据结构SeqList.h头文件
03-07
包含数据结构顺序表的基本操作函数（初始化，插入，删除，查找等）
SeqList——顺序表
ChinaPoison
03-25 213
/* ** File name: SeqList.h ** Author: ZhouFeng ** Date: 2012/03/25 */ #ifndef SEQ_LIST_H #define SEQ_LIST_H #define MAX_SIZE 100 #define ERROR 0 #define SUCCESS 1 typedef int EleType; t...
C语言实现动态顺序表的实现代码
08-29
C语言实现动态顺序表的实现代码 本文主要介绍了C语言实现动态顺序表的实现代码，动态顺序表是指在内存中开辟一块空间，可以随我们数据数量的增多来扩容的线性表。下面将详细介绍动态顺序表的实现代码。 一、顺序表...
C#数据结构之顺序表(SeqList)实例详解
09-03
在C#中，顺序表通常通过数组来实现，因为数组在内存中是连续分配的，这使得我们可以快速地访问任意位置的元素，实现所谓的“随机存取”。 顺序表(SeqList)的基本概念是将元素存储在一个连续的内存空间中，每个元素...
C语言顺序表的实现代码
08-29
同时，我们还定义了一些基本操作，例如初始化顺序表、在顺序表的末尾插入元素、在顺序表的头部插入元素、显示顺序表中的元素、删除顺序表最后一个元素、删除顺序表第一个元素、在顺序表的选定位置上插入数据、在顺序...
SeqList
weixin_34352449的博客
03-09 118
为什么80%的码农都做不了架构师？>>> ...
数据结构入门——顺序表（SeqList）详解（初始化、增、删、查、改）
ZHA_123的博客
11-01 3616
线性表（linear list）是n个具有相同特性的数据元素的有限序列。线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串…线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。本篇博客我们主要介绍一下顺序表的内容，最后会给出顺序表的应用，也就是之前拖了大家很久的通讯录动态版。
数据结构--------线性表的相关操作
wazhza的博客
05-01 875
这是第一次在论坛上码文章，可能会有许多错误，希望那个大家多多包涵。大二刚开始接触学习数据结构，回顾了一下之前线性结构中线性表的基本操作 ...
1.1顺序表(SeqList)的实现
engreal的博客
09-19 1424
用C语言实现的顺序表
顺序表
weixin_37616150的博客
04-06 463
顺序表1、抽象集合类AbstractCCollection//import java.util.Iterator; //Java迭代器接口 //抽象集合类，实现java.lang.Iterable可迭代接口，为所有集合提供迭代方式的遍历算法 public abstract class AbstractCCollection&lt;T&gt; imple...
求解篇： 顺序表类SeqList的验证与实现 （用模板类改写并增加对类类型的支持）
Z_yu_cc的博客
10-09 1348
（本人代码小白，大学才开始接触编程，这也是我的第一篇博客文章，就贡献给数据结构吧(ง •_•)ง，但数据结构看着简单，写起来对我来说好难X﹏X ） 顺序表用模板类改写，只要加个template，注意格式即可。 但增加对类类型的支持我就不ok了，请看： #include <iostream> //引用输入输出流库函数的头文件 using namespace std; class B { public: B(int i=0):data(i) {} private: int d
顺序表(SeqList) Java实现
离殇丶的博客
01-30 2582
实现的操作包括： 向顺序表末尾添加数据 ( addData( Data))； 向顺序表指定位置添加数据( insertDataByLoc( Location))； 删除顺序表中指定的数据( deleteDataByData( Data))； 删除顺序表中指定位置的数据( deleteDataByLoc( Location))； 查找指定位置的数据( findDataByLoc( Loca...
顺序表(SequenceList)数据结构的基本操作实现详解
HenryBlog
08-17 4492
目录一、前言二、整体设计框架三、函数实现四、完整代码 一、前言 数据结构非常之多，后续小编会逐个更新，简单的存储数据一般有顺序表，链表（单链表和双链表），串等 创建完数据结构后不仅要存储数据，以后还需要查找数据，如果高效的进行查找也需要搜索树，哈希表等这样的结构来实现 有很多人有这样一个疑问：是先学数据结构还是先学算法？ 其实数据结构和算法是不分家的，数据结构中包含一些算法，有些算法的解决又离不开数据结构，比如实现Dijkstra最短路径问题是基于Graph的数据结构实现的 二、整体设计框架 实现顺序表，
线性表的顺序表示和实现：MergeList
lzdelphi的专栏
02-15 1021
//已知线性表La和Lb中的数据元素按值非递减排列 //归并La和Lb得到新的线性表Lc，Lc的数据元素也按值非递减排列 void MergeList(SqList La,SqList Lb,SqList *Lc){ InitList(Lc); int alen=La.length; int blen=Lb.length; int i=1,j=1,k=0; ...
关于初始化顺序表，程序崩溃问题
我是小码搬运工
08-17 776
初始化(*PL) = Init_SeqList(); 出现程序崩溃现象
C语言动态顺序表实现详解
"这篇资源是关于C语言实现动态顺序表的代码示例，动态顺序表是一种根据需要在内存中动态扩展存储容量的数据结构。代码包括了动态顺序表的基本操作，如初始化、添加元素（PushBack和PushFront）、删除元素（PopBack和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值