顺序表

最新推荐文章于 2024-04-17 17:49:05 发布
最新推荐文章于 2024-04-17 17:49:05 发布
阅读量174 收藏
点赞数
分类专栏： 学习 经验 文章标签： 数据结构 C语言 顺序表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Logicr/article/details/79851578
版权
学习 同时被 2 个专栏收录
120 篇文章 0 订阅
订阅专栏
经验
109 篇文章 0 订阅
订阅专栏

头文件 order.h

# ifndef __ORDER_H__
# define __ORDER_H__




typedef int DataType;
#define MAX_SIZE 10 


//++++++++++++++++++++++++++++++++++++++++++++++++++++++=
//head
# include <stdio.h>
# include <assert.h>
# include <memory.h>


//++++++++++++++++++++++++++++++++++++++++++++++++++++++++=
//结构
typedef struct SeqList
{
    DataType _array[MAX_SIZE];
    int _size; // 表示顺序表中有效元素的个数 
}SeqList, *PSeqList;

typedef struct SeqList* PSeqList;
typedef struct SeqList SeqList;
SeqList s;

///////////////////////////////////////////////////////////////////// 
// 函数声明

//测试函数
void test();
// 顺序表的初始化 
void SeqListInit(PSeqList ps);

// 顺序表的尾插 
void SeqListPushBack(PSeqList ps, DataType data);

// 顺序表的尾删 
void SeqListPopBack(PSeqList ps);

// 顺序表的头插 
void SeqListPushFront(PSeqList ps, DataType data);

// 顺序表的头删 
void SeqListPopFront(PSeqList ps);

// 顺序表pos位置插入元素data 
void SeqListInsert(PSeqList ps, int pos, DataType data);

// 删除顺序表pos位置元素 
void SeqListErase(PSeqList ps, int pos);

// 移除顺序表中第一个值为data的元素 
void Remove(PSeqList ps, DataType data);

// 移除顺序表中所有值为data的元素 
void RemoveAll(PSeqList ps, DataType data);

// 在顺序表中查找值为data的元素，找到返回该元素在顺序表中的位置，否则返回-1 
int SeqListFind(PSeqList ps, DataType data);

// 获取顺序表中元素的个数 
int SeqListSize(PSeqList ps);



////////////////////////////////////////////////// 
//辅助操作 
// 打印顺序表 
void PrintSeqList(PSeqList ps);

// 使用冒泡排序对顺序表中的元素进行排序 
void BubbleSort(PSeqList ps);
void swap(int *po, int *pt);

// 使用选择排序堆顺序表中的元素进行排序 
void SelectSort(PSeqList ps);





# endif //__ORDER_H__

代码

#pragma warning(disable:4996)
# include "order.h"
void test()//测试函数
{
    SeqListInit(&s);//初始化
    SeqListPushBack(&s, 1);//尾插入
    SeqListPushBack(&s, 5);
    SeqListPushBack(&s, 4);
    SeqListPushBack(&s, 3);
    SeqListPushBack(&s, 5);
    SeqListPushBack(&s, 6);
    SeqListPushBack(&s, 6);
    SeqListPopBack(&s);//尾删
    SeqListPushFront(&s, 100);//头插
    SeqListPopFront(&s);//头删
    SeqListInsert(&s, 5, 20);//任意插入
    SeqListErase(&s, 5);//任意删
    //Remove(&s, 5);//删除第一个出现的
    SeqListPushBack(&s, 5);
    SeqListPushBack(&s, 5);
    SeqListPushBack(&s, 6);
    SeqListPushBack(&s, 5);
    RemoveAll(&s, 5);//删除出现的5
    int a = SeqListFind(&s,1);
    SeqListPushBack(&s, 11);
    SeqListPushBack(&s, 13);
    SeqListPushBack(&s, 12);
    PrintSeqList(&s);//打印函数
    SelectSort(&s);//选择排序
    //BubbleSort(&s);//冒泡排序
    PrintSeqList(&s);

}
//顺序表初始化
void SeqListInit(PSeqList ps)
{
    if (NULL == ps)//判断指针是否空
    {
        printf("空指针\n");
        return ;
    }
    ps->_size = 0;
}
// 顺序表的尾插 
void SeqListPushBack(PSeqList ps, DataType data)
{
    if (NULL == ps)
    {
        printf("空指针\n");
        assert(0);
    }
    if (MAX_SIZE == ps->_size)//判断数组是否满
    {
        printf("空间已满，无法写入\n");
        return;
    }
    ps->_array[ps->_size] = data;//尾部插入
    ps->_size++;//长度加一
}

// 顺序表的尾删 
void SeqListPopBack(PSeqList ps)
{
    if (NULL == ps)
    {
        printf("空指针\n");
        assert(0);
    }
    ps->_size--;//长度减一，后面的内容丢弃
}

// 顺序表的头插 
void SeqListPushFront(PSeqList ps, DataType data)
{
    int i = 0;
    if (NULL == ps)
    {
        printf("空指针\n");
        assert(0);
    }
    if (MAX_SIZE == ps->_size)
    {
        printf("空间已满，无法写入\n");
        return;
    }
    for (i = ps->_size; i > 0; --i)//往后挪，挪出第一个用来装入数据
    {
        ps->_array[i] = ps->_array[i - 1];
    }
    ps->_array[0] = data;
    ps->_size++;
}

// 顺序表的头删 
void SeqListPopFront(PSeqList ps)
{
    int i = 0;
    if (NULL == ps)
    {
        printf("空指针\n");
        assert(0);
    }
    if (MAX_SIZE == ps->_size)
    {
        printf("空间已满，无法写入\n");
        return;
    }
    for (i = 0; i < ps->_size - 1; ++i)//直接往前挪覆盖
    {
        ps->_array[i] = ps->_array[i + 1];
    }
    ps->_size--;
}

// 顺序表pos位置插入元素data 
void SeqListInsert(PSeqList ps, int pos, DataType data)
{
    int i = 0;
    if (NULL == ps || pos < 0 || pos > ps->_size)
    {
        printf("指针或插入位置有误\n");
        assert(0);
    }
    if (MAX_SIZE == ps->_size)
    {
        printf("空间已满，无法写入\n");
        return;
    }
    for (i =ps->_size ; i >pos ; i --)
    {
        ps->_array[i] = ps->_array[i-1];
    }
    ps->_array[pos] = data;
    ps->_size++;
}

// 删除顺序表pos位置元素 
void SeqListErase(PSeqList ps, int pos)
{
    int i = 0;
    if (NULL == ps ||pos < 0 || pos > ps->_size)//位置必须在_size范围内
    {
        printf("指针或插入位置有误\n");
        return ;
    }
    for (i = pos; i < ps->_size; i++)//挪挪挪
    {
        ps->_array[i] = ps->_array[i + 1];
    }
    ps->_size--;
}

// 移除顺序表中第一个值为data的元素 
void Remove(PSeqList ps, DataType data)
{
    int i = 0;
    if (NULL == ps)
    {
        printf("空指针\n");
        return ;
    }
    for (i = 0; i < ps->_size; i++)//挨个遍历
    {
        if (data == ps->_array[i])
        {
            int j = 0;
            for (j = i; j < ps->_size ; j++)
            {
                ps->_array[j] = ps->_array[j + 1];
            }
            ps->_size--;
            return;
        }
    }

}

// 移除顺序表中所有值为data的元素 
void RemoveAll(PSeqList ps, DataType data)
{
    int i = 0;
    if (NULL == ps)
    {
        printf("空指针\n");
        return;
    }
    //++++++++++++++++++++++++++++++++++
    //1.0
    /*
    for (i = 0; i < ps->_size; i++)
    {
        if (data == ps->_array[i])
        {
            int j = 0;
            for (j = i; j < ps->_size; j++)
            {
                ps->_array[j] = ps->_array[j + 1];
            }
            ps->_size--;
            i--;//i回退一次，就不会跳过当前元素了，因为挪上来的元素有可能也是要找的
        }
    }
    //++++++++++++++++++++++++++++++++++++
    */
    //++++++++++++++++++++++++++++++++++++
    //2.0
    /*
    int temp[MAX_SIZE] = { 0 };
    int count = 0;
    for (i = 0; i < ps->_size; i++)
    {
        if (data == ps->_array[i])
        {
            count++;
        }
        else
        {
            temp[i - count] = ps->_array[i];
        }
    }
    memcpy(ps->_array,temp,sizeof(ps->_array));
    ps->_size -= count;
    //++++++++++++++++++++++++++++++++++++++++
    */
    //++++++++++++++++++++++++++++++++++++++++
    //3.0，时间复杂度O(1)
    int count = 0;
    for (i = 0; i < ps->_size; i++)
    {
        if (data == ps->_array[i])
        {
            count++;
        }
        else
        {
            ps->_array[i - count] = ps->_array[i];
        }
    }
    ps->_size -= count;
}

// 在顺序表中查找值为data的元素，找到返回该元素在顺序表中的位置，否则返回-1 
int SeqListFind(PSeqList ps, DataType data)
{
    int i = 0;
    if (NULL == ps)
    {
        printf("空指针\n");
        return -1;
    }
    for (i = 0; i < ps->_size; i++)
    {
        if (data == ps->_array[i])
        {
            return i;
        }
    }
    return -1;
}

// 获取顺序表中元素的个数 
int SeqListSize(PSeqList ps)
{
    if (NULL == ps)
    {
        printf("空指针\n");
        return -1;
    }
    return ps->_size;
}



// 
//辅助操作 
// 打印顺序表 
void PrintSeqList(PSeqList ps)
{
    int i = 0;
    if (NULL == ps)
    {
        printf("空指针\n");
        return;
    }
    printf("当前元素个数为：%d\n", ps->_size);
    for (i = 0; i < ps->_size; i++)
    {
        printf("%d  ", ps->_array[i]);
    }
    printf("\n");
}

void swap(int *po, int *pt)
{
    /*
    int tmp = po;//这个之所以不行，因为这样交换的是指针地址，里面的内容并没有交换
    po = pt;
    pt = tmp;
    */
    int tmp = *po;
    *po = *pt;
    *pt = tmp;
}
// 使用冒泡排序对顺序表中的元素进行排序 
void BubbleSort(PSeqList ps)
{
    int i = 0;
    if (NULL == ps)
    {
        printf("空指针\n");
        return;
    }
    for (i = 0; i < ps->_size; i++)
    {
        int flog = 0;
        int j = 0;
        for (j = 0; j < ps->_size - i - 1; j++)
        {

            if (ps->_array[j] > ps->_array[j + 1])
            {
                flog = 1;
                swap(&ps->_array[j], &ps->_array[j + 1]);
            }
        }
        if (0 == flog)
        {
            return;
        }
    }
}

// 使用选择排序堆顺序表中的元素进行排序 
void SelectSort(PSeqList ps)
{
    int i = 0;
    if (NULL == ps)
    {
        printf("空指针\n");
        return;
    }
    for (i = 0; i < ps->_size; i ++)
    {
        int flog = 0;
        int j = 0;
        for (j = 0; j < ps->_size -i -1; j++)
        {

            if (ps->_array[j] > ps->_array[j + 1])
            {
                flog = j;
            }
            else
            {
                flog = j + 1;
            }
        }
        swap(&ps->_array[ps->_size - i - 1], &ps->_array[flog]);
    }
}

源文件已上传github，点我跳转

Logicr
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
顺序表实现
11-05
Java顺序表的学习实现代码，支持多种数据类型的临时存储
小白算法积累——顺序表6#有序顺序表 +删除重复元素
01-07
题目：从有序顺序表中删除所有其值重复的元素，使表中所有元素的值均不同。 关键字：有序顺序表 删除重复元素 思路 关注：因为是有序表，所以值相同的元素一定在连续的位置上， 用类似于直接插入排序的思想 1.初始时...
数据结构- 顺序表的实现
曾铎的博客
08-29 708
在计算机内部存储一张线性表（线性结构的数表），最为方便简单的就是用一组连续的地址的内存单元来存储整张线性表。这种存储结构称为顺序存储结构。这种存储结构下的线性表就称为顺序表。一张顺序表包括这几个特征：有一个唯一的表名来标识该顺序表；内存单元连续存储，也就是说一张顺序表必须要占据一块连续的内存空间；数据顺序存放，元素之间有先后关系；定义一张顺序表也就是在内存中开辟一段连续的存储空间，同时我们定义的顺序表也应该实现增删查改这四个功能。......
线性表——顺序表
m0_55993923的博客
11-10 597
代码如下： 头文件： #include<stdio.h> #define MaxSize 100 typedef int ElemType; typedef struct { ElemType data[MaxSize]; int length; }SqList; //初始化线性表 void InitList(SqList& s) { s.length = 0; } //销毁线性表 void DestoryList(SqList& s) { ...
数据结构——顺序表（Ｃ语言版）
weixin_53811859的博客
03-30 5948
室友一把王者的时间，手把手带你拿捏严奶奶数据结构里面的动态顺序表实现（C语言版），纯手工绘画，保证让初学者的xdm也一目了然，精简易懂
【数据结构Note1】- 顺序表
weixin_63267854的博客
04-27 1948
线性表得顺序存储实现，动态分配空间实现顺序表，顺序表实现雷区
顺序表概述
橘猫吃不胖的博客
11-13 719
顺序表概述1 顺序表的概念2 顺序表的存储结构3 示例 1 顺序表的概念 顺序表示线性表的顺序存储结构，即按顺序存储方式构造的线性表的存储结构。 对于有n个元素的顺序表A，可以表示为A[0…n-1]，其下标从0到n-1，A[0]称为第1个元素，A[1]称为第2个元素，…A[n-1]称为第n个元素。 2 顺序表的存储结构 #define MaxLen 50 typedef int elemtype; // 定义elemtype为int类型 typedef elemtype sqlist[MaxLen]; //
1_顺序表_
10-02
基于顺序存储结构的图书信息表的创建和输出描述定义一个包含图书信息（书号、书名、价格）的顺序表，读入相应的图书数据来完成图书信息表的创建，然后统计图书表中的图书个数，同时逐行输出每本图书的信息。...
2_顺序表_
10-01
基于顺序存储结构的图书信息表的修改描述定义一个包含图书信息（书号、书名、价格）的顺序表，读入相应的图书数据完成图书信息表的创建，然后计算所有图书的平均价格，将所有低于平均价格的图书价格提高20%，所有...
顺序表+菜单
06-18
里面包括顺序表的创建，更改，添加，删除元素，遍历顺序表包括菜单功能，代码清晰，结构简单
顺序表头文件
09-18
数据结构第一章 顺序表部分头文件 包括创建 删除节点等
顺序表代码
10-24
顺序表的创建，插入，修改，查找以及删除。
顺序表头文件顺序表头文件
12-04
顺序表头文件顺序表头文件顺序表头文件顺序表头文件
顺序表的C语言实现
Time_Chaser的博客
09-12 510
头文件：SeqList.h 源文件：SeqList.c
数据结构——顺序表
qq_45166999的博客
08-04 2354
顺序表： 这个是头文件，和#include<stdio.h>差不多，主要在头文件中定义了一个结构体，包括一个int类型指针和int类型的length长度单位，用来记录顺序表的长度。18到27行是函数文件中的函数名，包括他的返回值类型和形参，注意，函数后面要加分号。 在main函数文件中,申明一个list的结构体。 Initlist函数的主要作用就是初始化，申请空间，然后将结构体中...
顺序表的创建、插入、更新、删除、显示、销毁
weixin_46729987的博客
02-23 1267
顺序表的创建、插入、更新、删除、显示、销毁 今天是第一次写博客，打算从数据结构最基础的顺序表做起，如有错误，忘多多批评指正。 本人写代码有个习惯就是把代码分模块来写，分为头文件和源文件。首先介绍顺序表头文件的书写： 1、创建顺序表节点； 2、枚举错误类型； 3、顺序表的增删改查； 首先第一步，创建顺序表节点，节点包括顺序表存储数据和数量： typedef struct List { data_t data[SIZE]; int count; }List; 第二部，枚举错误类型：
【 数据结构 】顺序表的实现 - 详解（C语言版）
上上谦. 的博客
03-13 7767
目录 前言 线性表： ​ 顺序表： 概念及结构： 顺序表的实现： 头文件：SeqList.h realloc函数讲解： 具体函数的实现：SeqList.c 顺序表的初始化： 顺序表的打印： 容量的检查： 顺序表的尾插： 顺序表的尾删： 顺序表的头插： 顺序表的头删： 在顺序表的指定位置插入数据： 在顺序表的指定位置删除数据： 顺序表的查找： 顺序表的修改： 顺序表的销毁： 数组越界的检查： 前言 简单用C语言来描述数据结构中的顺序表......
常用的数据结构及算法
modi000的博客
04-17 446
优化方式二：将每个结点的孩子结点排列起来，以单链表作存储结构，则n个结点有n个孩子链表，如果是叶子结点则此单链表为,空。3）孩子兄弟表示法：任意一棵树，它的结点的第一个孩子如果存在就是唯一的，它的右兄弟如果存在也是唯一的。1）双亲表示法：通过静态数组的方式，存储当前结点的数据、双亲的位置（根节点的双亲结点设置为-1）。该方法的优点是容易找到结点的双亲结点，但是找结点的孩子结点就需要遍历。优化方式：除双亲的位置外，再增加一个长子域（最左孩子的位置），如结点无孩子结点，长子域设置为-1。链表常用的是单链表。
【数据结构】红黑树
最新发布
m0_58963318的博客
04-17 1083
深度剖析红黑树的插入与检测
顺序表 displist
03-09
顺序表（displist）是一种线性表的存储结构，它通过一段连续的存储空间来存储元素，元素之间的逻辑关系由下标来表示。顺序表的特点是可以随机访问元素，时间复杂度为O(1)。 顺序表的实现方式有多种，其中一种常见的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值