顺序表的增、删、查、改、排序等各项操作

最新推荐文章于 2022-09-10 16:50:35 发布
最新推荐文章于 2022-09-10 16:50:35 发布
阅读量675 收藏 3
点赞数
分类专栏： 数据结构练习题 文章标签： 数据结构 顺序表 顺序表-c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Tianzez/article/details/78765785
版权

实现功能：
1.打印顺序表
2.初始化顺序表
3.销毁顺序表
4.判满+扩容
5.尾部插入
6.尾部删除
7.头部插入
8.头部删除
9.指定位置插入
10.指定位置删除
11.查找指定元素
12.替换指定位置元素
13.冒泡排序
14.选择排序
15.二分查找

(1)SeqList.h（头文件）

#ifndef __SEQLIST_H__
#define __SEQLIST_H__

#include <stdio.h>
#include <windows.h>
#include <assert.h>
#include <string.h>
#include <stdlib.h>

#define MAX 10

typedef int DataType; //类型重定义

typedef struct SeqList
{
    DataType* _a;
    size_t _size;
    size_t _capicity;
}SeqList;


void SeqPrint(SeqList* pSeq);  //打印
void SeqInit(SeqList* pSeq);   //初始化
void SeqDestory(SeqList* pSeq); //释放
SeqList* SeqCheckFull(SeqList* pSeq);//判满＋扩容

void SeqPushBack(SeqList* pSeq, DataType x); //尾插
void SeqPopBack(SeqList* pSeq);   //尾删
void SeqPushFront(SeqList* pSeq, DataType x); //头插
void SeqPopFront(SeqList* pSeq);  //头删

void SeqInsert(SeqList* pSeq, size_t pos, DataType x);//指定位置插入
void SeqErase(SeqList* pSeq, size_t pos);  //指定位置删除

int SeqFind(SeqList* pSeq, DataType x);   //查找指定元素
void SeqAt(SeqList* pSeq, size_t pos, DataType x); //替换指定位置元素

void BubbleSort(SeqList* pSeq); //冒泡排序
void SelectSort(SeqList* pSeq); //选择排序
int BinarySearch(SeqList* pSeq, DataType x); //二分查找

#endif

(2)SeqList.c（功能实现部分）

#include "SeqList.h"

void SeqPrint(SeqList* pSeq) //打印顺序表
{
    size_t i = 0;
    for (i = 0; i < pSeq->_size; i++)
    {
        printf("%-2d", pSeq->_a[i]);
    }
    printf("\n");
}

void SeqInit(SeqList* pSeq) //初始化顺序表
{
    pSeq->_size = 0;
    pSeq->_capicity = MAX;
    pSeq->_a = (DataType*)malloc(sizeof(DataType)*pSeq->_capicity);

    memset(pSeq->_a, 0, sizeof(DataType)*pSeq->_capicity);
}

void SeqDestory(SeqList* pSeq) //释放
{
    free(pSeq->_a);
    pSeq->_size = 0;
}

SeqList* SeqCheckFull(SeqList* pSeq)   //判满+扩容
{
    if (pSeq->_size == pSeq->_capicity)
    {
        DataType* tem = (DataType*)realloc(pSeq->_a, sizeof(DataType)*pSeq->_capicity * 2);

        if (NULL == tem)
        {
            printf("扩容失败！\n");
            return NULL;
        }
        pSeq->_capicity *= 2 ;
        pSeq->_a = tem;
    }
    return pSeq;
}

void SeqPushBack(SeqList* pSeq, DataType x) //尾插
{
    assert(pSeq != NULL);

    SeqInsert(pSeq, pSeq->_size, x);
}

void SeqPopBack(SeqList* pSeq) //尾删
{
    assert(pSeq != NULL);

    //if (0 == pSeq)
    //{
    //  printf("SeqLisr is Emtpy!\n");
    //  return;
    //}
    //else
    //{
    //  --pSeq->_size;
    //}
    SeqErase(pSeq, pSeq->_size - 1);
}

void SeqPushFront(SeqList* pSeq, DataType x)//头插
{
    assert(pSeq != NULL);

    SeqInsert(pSeq, 0, x);
}

void SeqPopFront(SeqList* pSeq)//头删
{
    assert(pSeq != NULL);

    SeqErase(pSeq, 0);
}

void SeqInsert(SeqList* pSeq, size_t pos, DataType x)//随机位置插入
{
    assert(pSeq != NULL);
    pSeq = SeqCheckFull(pSeq);
    if (pSeq != NULL)
    {
        if (0 == pSeq->_size)
        {
            pSeq->_a[pSeq->_size] = x;
            pSeq->_size++;
        }
        else
        {
            int end = pSeq->_size - 1;
            while (end >= (int)pos)
            {
                pSeq->_a[end + 1] = pSeq->_a[end];
                end--;
            }
            pSeq->_a[end + 1] = x;

            ++pSeq->_size;
        }
    }
}

void SeqErase(SeqList* pSeq, size_t pos)//随机位置删除
{
    assert(pSeq != NULL);
    assert(pos < pSeq->_size); //删除的位置必须在[0, pSeq->_size-1]

    if (0 == pSeq->_size)
    {
        printf("SeqList is empty!\n");
        return;
    }

    size_t start = pos;
    while (start < pSeq->_size - 1)
    {
        pSeq->_a[start] = pSeq->_a[start + 1];
        start++;
    }
    --pSeq->_size;
}

int SeqFind(SeqList* pSeq, DataType x) //查找
{
    assert(pSeq != NULL);

    size_t i = 0;
    for (i = 0; i < pSeq->_size; i++)
    {
        if (x == pSeq->_a[i])
        {
            return i;
        }
    }
    return -1;
}


void SeqAt(SeqList* pSeq, size_t pos, DataType x)//替换
{
    assert(pSeq != NULL);
    assert(pos < pSeq->_size);
    pSeq->_a[pos] = x;
}


void Swap(DataType* x, DataType* y)
{
    DataType tem = *x;
    *x = *y;
    *y = tem;
}


void BubbleSort(SeqList* pSeq) //冒泡排序
{
    size_t i = 0;
    size_t j = 0;

    for (i = 0; i < pSeq->_size - 1; i++)
    {
        int flag = 0;
        for (j = 0; j < pSeq->_size - i - 1; j++)
        {
            if (pSeq->_a[j] > pSeq->_a[j + 1])
            {
                Swap(&(pSeq->_a[j]), &(pSeq->_a[j + 1]));
                flag = 1;
            }
        }
        if (0 == flag)
        {
            return;
        }
    }
}

void SelectSort(SeqList* pSeq)//选择排序
{
    size_t left = 0;
    size_t right = pSeq->_size - 1;
    size_t min = left;//存储最小值的下标
    size_t max = left;//存储最大值的下标
    while (left <= right)
    {
        min = left;
        max = left;
        for (size_t i = left; i <= right; ++i)
        {
            if (pSeq->_a[i] < pSeq->_a[min])
            {
                min = i;
            }
            if (pSeq->_a[i] > pSeq->_a[max])
            {
                max = i;
            }
        }
        Swap(&(pSeq->_a[left]), &(pSeq->_a[min]));

        if (left == max)
            max = min;
        Swap(&(pSeq->_a[right]), &(pSeq->_a[max]));

        ++left;
        --right;
    }
}


int BinarySearch(SeqList* pSeq, DataType x)//二分查找
{
    int left = 0;
    int right = pSeq->_size - 1;
    int mid = 0;

    while (left <= right)
    {
        mid = left + ((right - left) >> 1);
        if (x > pSeq->_a[mid])
        {
            left = mid + 1;
        }
        else if (x < pSeq->_a[mid])
        {
            right = mid - 1;
        }
        else
        {
            return mid;
        }
    }
    return -1;
}

(3) test.c（测试用例）

#include "SeqList.h"

SeqList list;

void testSeqPushFront() //测试头插
{
    SeqInit(&list);
    SeqPushFront(&list, 0);
    SeqPushFront(&list, 1);
    SeqPushFront(&list, 2);
    SeqPushFront(&list, 3);
    SeqPushFront(&list, 4);

    SeqPrint(&list);
}

void testSeqPopFront() //测试头删
{
    SeqInit(&list);
    SeqPushFront(&list, 0);
    SeqPushFront(&list, 1);
    SeqPushFront(&list, 2);
    SeqPushFront(&list, 3);
    SeqPrint(&list);

    SeqPopFront(&list);
    SeqPrint(&list);

    SeqPopFront(&list);
    SeqPrint(&list);

    SeqPopFront(&list);
    SeqPrint(&list);

    SeqPopFront(&list);
    SeqPrint(&list);

    SeqPopFront(&list);
    SeqPrint(&list);
}

void testSeqPushBack()//测试尾插
{
    SeqInit(&list);
    SeqPushBack(&list, 0);
    SeqPushBack(&list, 1);
    SeqPushBack(&list, 2);
    SeqPushBack(&list, 3);
    SeqPushBack(&list, 4);

    SeqPrint(&list);
}

void testSeqPopBack()//测试尾删
{
    SeqInit(&list);
    SeqPushBack(&list, 0);
    SeqPushBack(&list, 1);
    SeqPushBack(&list, 2);
    SeqPushBack(&list, 3);
    SeqPrint(&list);

    SeqPopBack(&list);
    SeqPrint(&list);

    SeqPopBack(&list);
    SeqPrint(&list);

    SeqPopBack(&list);
    SeqPrint(&list);

    SeqPopBack(&list);
    SeqPrint(&list);

    SeqPopBack(&list);
    SeqPrint(&list);
}

void testSeqInsert()//测试随机插
{
    SeqInit(&list);
    SeqPushBack(&list, 0);
    SeqPushBack(&list, 1);
    SeqPushBack(&list, 2);
    SeqPrint(&list);
    SeqInsert(&list, 0, -1);
    SeqPrint(&list);
    SeqInsert(&list, 3, -1);
    SeqPrint(&list);
}

void testSeqErase()//测试随机删
{
    SeqInit(&list);
    SeqPushBack(&list, 0);
    SeqPushBack(&list, 1);
    SeqPushBack(&list, 2);
    SeqPushBack(&list, 3);
    SeqPushBack(&list, 4);
    SeqPrint(&list);

    SeqErase(&list, 0);
    SeqPrint(&list);
    SeqErase(&list, 0);
    SeqPrint(&list);
    SeqErase(&list, 3);
    SeqPrint(&list);
}

void testSeqFind()//查找
{
    SeqInit(&list);
    SeqPushBack(&list, 0);
    SeqPushBack(&list, 1);
    SeqPushBack(&list, 2);
    SeqPushBack(&list, 3);
    SeqPushBack(&list, 4);
    SeqPrint(&list);

    printf("%d\n", SeqFind(&list, 0));
    printf("%d\n", SeqFind(&list, 1));
    printf("%d\n", SeqFind(&list, 2));
    printf("%d\n", SeqFind(&list, 3));
    printf("%d\n", SeqFind(&list, 4));
    printf("%d\n", SeqFind(&list, 5));
}

void testSeqAt() //替换
{
    SeqInit(&list);
    SeqPushBack(&list, 0);
    SeqPushBack(&list, 1);
    SeqPushBack(&list, 5);
    SeqPushBack(&list, 3);
    SeqPushBack(&list, 4);
    SeqPrint(&list);

    SeqAt(&list, 2, 2);
    SeqPrint(&list);
    SeqAt(&list, 0, -1);
    SeqPrint(&list);
}

void testBubbleSort()//冒泡排序
{
    SeqInit(&list);
    SeqPushBack(&list, 8);
    SeqPushBack(&list, 1);
    SeqPushBack(&list, 5);
    SeqPushBack(&list, 0);
    SeqPushBack(&list, 4);
    SeqPrint(&list);

    BubbleSort(&list);
    SeqPrint(&list);
}

void testSelectSort() //选择排序
{
    SeqInit(&list);
    SeqPushBack(&list, 8);
    SeqPushBack(&list, 1);
    SeqPushBack(&list, 5);
    SeqPushBack(&list, 0);
    SeqPushBack(&list, 4);
    SeqPrint(&list);

    SelectSort(&list);
    SeqPrint(&list);
}

void testBinarySearch()//二分查找
{
    SeqInit(&list);
    SeqPushBack(&list, 1);
    SeqPushBack(&list, 2);
    SeqPushBack(&list, 3);
    SeqPushBack(&list, 4);
    SeqPushBack(&list, 5);
    SeqPrint(&list);

    int ret = BinarySearch(&list, 3);
    if (-1 == ret)
    {
        printf("没找到\n");
    }
    else
    {
        printf("下标是%d\n", ret);
    }
}

int main()
{
    testSeqPushFront();//测试头插
    //testSeqPopFront(); //测试头删
    //testSeqPushBack(); //测试尾插
    //testSeqPopBack();  //测试尾删
    //testSeqInsert();   //测试随机插
    //testSeqErase();    //测试随机删
    //testSeqFind();     //查找
    //testSeqAt();       //替换
    //testBubbleSort();  //冒泡排序
    //testSelectSort();  //选择排序
    //testBinarySearch();//二分查找

    system("pause");
    return 0;
}
Tianzez
关注
专栏目录
实现基于MySQL的图书增删改查Web应用
black
09-30 2559
1、目的：学习Servlet、面向接口编程、工厂模式2、开发环境：Ecplise（Java SE）、SQLyog数据库管理工具、Tomcat服务器3、Tomcat安装要注意环境变量的设置4、Ecplise项目中导入jar包：Window->Preferences->Java->Build Path->User Libraries->new->命名，如MyWebLib->点击MyWebLib,点击Ad
数据结构（Java）联系人通讯率
12-03
本项目“数据结构（Java）联系人通讯录”关注的是利用Java编程语言实现一个现实生活中的通讯录系统，这个系统利用排序顺序表作为底层数据结构，支持联系人的增删改查功能，并能保持联系人信息的有序性。 首先，我们...
顺序表的增删改查，顺序表
10-10
本程序的顺序表是利用数组实现的，能对数组元素进行增删改查的基本操作
顺序表的增删改查(包括顺序表的冒泡排序,顺序表的二分查找)
gp1330782530的博客
08-15 216
顺序表的增删改查(包括顺序表的冒泡排序,顺序表的二分查找) seqlist.h #ifndef _SEQLIST_H_ #define _SEQLIST_H_ #define _CRT_SECURE_NO_WARNINGS #include <stdio.h> #include <stdlib.h> #include <string.h> #include...
【静态顺序表】的增删查改排序
spaceman_c的博客
06-07 192
定义： 用一段地址连续的存储单元依次存储数据元素的线性结构 地址连续的空间：一般情况下采用数组，数组有静态数组和动态数组之分，所以顺序表分为静态顺序表和动态顺序表 静态顺序表： #pragma once #pragma once #define MAX 10 // 值类型 typedef int DataType; typedef struct SeqList { Da...
顺序表的增删改查
Monster的博客
03-29 246
#include<stdio.h> #include<stdlib.h> #include<assert.h> typedef int DataType; typedef struct SqList { DataType* arr; int size; int capacity; }SqList; //顺序表初始化 void SqListInit(S...
顺序表的增删查改
zhengyawen666的博客
06-09 378
顺序表的增删查改
模拟通讯录-数据结构（顺序表实现基本功能）.doc
04-25
顺序表可以是一个简单的数组，每个元素代表一个联系人，包含其各项属性。 2. 功能菜单层次调用关系：设计一个主菜单，展示上述的基本操作选项。用户的选择会触发相应的函数调用，比如选择“插入联系人”则调用插入...
WEB前端高级开发-详解VUE表格的增删改查功能及其技术实现
VUE是一套用于构建用户界面的渐进式框架，具有简单易学、响应式、组件化等特点。通过VUE，开发人员可以更高效地构建交互式的WEB界面。 ## 1.2 VUE框架在前端开发中的优势 VUE框架具有以下几个优势： - **响应式...
课程设计--学生成绩管理系统顺序表—查找、插入.doc
07-04
学生信息管理系统是一个对学生的各项信息进行管理的软件，它涵盖了学生的基本信息，如姓名、学号、成绩等，以及对这些信息的增删改查操作。 **1. 需求分析** 在系统设计初期，首要任务是对需求进行分析。这包括两...
数据结构1——顺序表的增删改查排序
weixin_43864170的博客
12-10 579
数据结构1——顺序表的增删改查排序 数据结构的第一课就是顺序表的增删改查排序问题。顺序表相对于链表来说是一种相对简单的线性结构，其中涉及到了数据的添加，删除，查找，排序，遍历，和销毁。 #include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; #include&lt;string.h&gt; #define Max 1024 typedef int elem...
顺序表(增删改查 )
qq_44740753的博客
09-10 172
【代码】顺序表(增删改查 )
【数据结构】顺序表的增删改查
haonanren2bu2的专栏
02-13 1665
简单顺序表的增删改查实例： #include #define MAX 100typedef struct {int length;int data[MAX];}Sqlist,*PSqlist;void initList(PSqlist p);void insertList(PSqlist p,int elem);void deleteList(PSqlist p,int locate);void
顺序表增，删，改，查，排序的时间复杂度
最新发布
06-23
顺序表是一种简单的线性数据结构，操作其元素通常涉及到数组的索引访问，以下是顺序表在增、删、改、查和排序操作中的时间复杂度： 1. **插入（增）**： - 在表尾添加元素（即追加）：时间复杂度为 O(1)，因为不需要移动其他元素。 - 在任意位置插入元素（如在特定索引处）：时间复杂度为 O(n)，需要将后面的 n-1 个元素依次后移一位。 2. **删除（删）**： - 删除表尾元素：时间复杂度为 O(1)，因为不需要移动其他元素。 - 删除指定索引的元素：时间复杂度为 O(n)，同样需要将后面的 n-1 个元素前移一位。 3. **修改（改）**： - 修改任意位置的元素：时间复杂度为 O(1)，因为直接访问到该元素。 4. **查找（查）**： - 查找指定索引的元素：时间复杂度为 O(1)，通过索引可以直接获取。 - 查找特定值：线性查找，时间复杂度为 O(n)，在最坏情况下需要检查每个元素。 5. **排序**： - 内部排序（如冒泡排序、插入排序）：时间复杂度为 O(n^2)。 - 外部排序或使用更高效的算法（如快速排序、归并排序）：时间复杂度为 O(n log n)，但可能涉及额外的内存交换操作。 **
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值