数据结构-顺序表的基本操作

于 2018-03-29 09:36:09 发布
阅读量287 收藏 1
点赞数
文章标签： 数据结构顺序表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/y6_xiamo/article/details/79737709
版权

对顺序表做尾插、尾删、头插、头删、任意位置插入、删除元素、获取指定位置的值、给指定位置设置值、找某个元素的下标、移除某个元素、判断顺序表是否为空、求大小和冒泡排序等 操作

seqlist.h
#pragma once 

#include<stddef.h>

#define SeqListMaxSize 1000

typedef char SeqListType;

typedef struct SeqList{
    SeqListType data[SeqListMaxSize];
    size_t size;
}SeqList;

void SeqListInit(SeqList *seqlist);//初始化

SeqList seqlist;

void SeqListPushBack(SeqList * seqlist,SeqListType value);//往顺序表尾部插入元素

void SeqListPopBack(SeqList *seqlist);//将顺序表表尾的元素删除

void SeqListPushFront(SeqList *seqlist,SeqListType value);//往顺序表表头插入元素

void SeqListPopFront(SeqList *seqlist);//将顺序表表头的元素删除

void SeqListInsert(SeqList *seqlist,size_t pos,SeqListType value);//往顺序表插入元素

void SeqListErase(SeqList *seqlsit,size_t pos);//删除顺序表中的元素

int SeqListGet(SeqList *seqlist,size_t pos,SeqListType* value);//获取指定位置元素的值

void SeqListSet(SeqList *seqlist,size_t pos,SeqListType value);//给指定位置设置值


int SeqListFind(SeqList *seqlist,SeqListType value);//找到某个元素的下标

void SeqListRemove(SeqList *seqlist,SeqListType to_remove);//移除顺序表中的某个元素
void SeqListRemoveAll(SeqList *seqlist,SeqListType to_remove);//移除顺序表中的所有元素

void SeqListBubbleSort(SeqList *seqlist);// 冒泡排序

/**
 *   对Cmp比较函数作以下约定
 *   如果 a 和 b 满足比较规则，返回1，否则返回0
 *   满足比较规则具体值：
 *   如果是升序排序，a < b则称为满足比较规则
 */
typedef int (*Cmp)(SeqListType a,SeqListType b);
 void SeqListBubbleSortEx(SeqList *seqlist,Cmp cmp);//可以指定升序或降序的冒泡排序

 size_t SeqListSize(SeqList * seqlist);//获取顺序表中的元素个数

 int SeqListEmpty(SeqList *seqlist);//判断顺序表是否为空，如果为空，返回1，否则返回0
seqlist.c
#include"seqlist.h"

void swap(SeqListType *a,SeqListType *b)/交换函数
{
    SeqListType tmp = *a;
    *a = *b;
    *b = tmp;
}

void SeqListInit(SeqList * seqlist)//初始化
{
    if(seqlist == NULL)
        return;
    seqlist->size = 0;
}

void SeqListPushBack(SeqList *seqlist,SeqListType value)//尾插
{
    if(seqlist == NULL)
        return;                     //非法输入

    if(seqlist->size == SeqListMaxSize)
        return;                     //顺序表已满

    seqlist->data[seqlist->size] = value;
    seqlist->size++;
}

void SeqListPopBack(SeqList *seqlist)//尾删
{
    if(seqlist == NULL)
        return;                //非法输入

    if(seqlist->size == 0)
        return;                //顺序表为空
    --seqlist->size;
    return;
}

void SeqListPushFront(SeqList *seqlist,SeqListType value)//头插
{
    if(seqlist == NULL)
        return;                //非法输入

    if(seqlist->size == SeqListMaxSize)
        return;                //顺序表已满

    ++seqlist->size;
    size_t i = seqlist->size -1;
    for( ;i > 0;i--)
    {
        seqlist->data[i] = seqlist->data[i-1];//先把所有元素整体右移
    }
    seqlist->data[0] = value;
    return;
}

void SeqListPopFront(SeqList *seqlist)//头删
{
    if(seqlist == NULL)
        return;                //非法输入

    if(seqlist->size == 0)
        return;                //顺序表为空

    size_t i = 0;
    for( ;i < seqlist->size;i++)
    {
        seqlist->data[i] = seqlist->data[i+1];//整体左移
    }
    --seqlist->size;
    return;
}

void SeqListInsert(SeqList *seqlist,size_t pos,SeqListType value)//插入
{
    if(seqlist == NULL)
        return;              //非法输入

    if(seqlist->size == SeqListMaxSize)
        return;             //顺序表已满

   ++seqlist->size;
   size_t i = seqlist->size - 1;
   for( ;i > pos;i--)
   {
       seqlist->data[i] = seqlist->data[i-1];
   }
   seqlist->data[pos] = value;
   return;
}

void SeqListErase(SeqList *seqlist,size_t pos)//删除
{

    if(seqlist == NULL)
        return;                //非法输入

    if(seqlist->size == 0)
        return;                //顺序表为空

    size_t i = pos;
    for( ;i < seqlist->size;i++)
    {
        seqlist->data[i] = seqlist->data[i+1];
    }
    --seqlist->size;
    return;
}

int SeqListGet(SeqList *seqlist,size_t pos,SeqListType *value)//获取某个位置的值
{
    if(seqlist == NULL)
        return 0;     //非法输入

    if(pos >= seqlist->size)
        return 0;    //非法输入

    *value = seqlist->data[pos];
    return 1;
}

void SeqListSet(SeqList *seqlist,size_t pos,SeqListType value)//设置某个位置的值
{
    if(seqlist == NULL)
        return;       //非法输入
    if(pos >= seqlist->size)
        return;       //pos越界


    seqlist->data[pos] = value;
        return;
 }

int SeqListFind(SeqList *seqlist,SeqListType value)//获取某个值的下标
{
    if(seqlist == NULL)
        return;          //非法输入

    size_t i = 0;
    for( ;i < seqlist->size;i++)
    {
        if(value == seqlist->data[i])
        {
            return i;
        }
    }
    return -1;     //没找到
}

void SeqListRemove(SeqList *seqlist,SeqListType to_remove)//移除某个元素
{
    if(seqlist == NULL)
        return;           //非法输入

    size_t pos = SeqListFind(seqlist,to_remove);//找到要移除的元素的下标
    if(pos == (size_t)-1)
        return;          //没找到

    SeqListErase(seqlist,pos);   
    return;
}

void SeqListRemoveAll(SeqList *seqlist,SeqListType to_remove)//移除所有元素
{
    if(seqlist == NULL)
        return;          //非法输入
   while(1)//找到顺序表中所有值为to_remove的元素，全部删除
   {
         size_t pos = SeqListFind(seqlist,to_remove);
         if(pos == (size_t)-1)
               break;

          SeqListErase(seqlist,pos);
   }
   return;
}

void SeqListBubbleSort(SeqList *seqlist)//冒泡排序
{
    if(seqlist == NULL)
        return;           //非法输入

    size_t count = 0;     //冒泡次数
    for( ;count < seqlist->size;++count)
    {
        size_t cur = 0;
        for( ;cur < seqlist->size-1-count;++cur)
        {
            if(seqlist->data[cur] > seqlist->data[cur+1])
                swap(&seqlist->data[cur],&seqlist->data[cur+1]);
        }
    }
    return;
}

void SeqListBubbleSortEx(SeqList *seqlist,Cmp cmp)//指定升序或降序的冒泡排序
{
    if(seqlist == NULL)
        return;

    size_t count = 0;     //冒泡次数
    for( ;count < seqlist->size;++count)
    {
        size_t cur = 0;
        for( ;cur < seqlist->size-1-count;++cur)
        {
            if(!cmp(seqlist->data[cur], seqlist->data[cur+1]))
                swap(&seqlist->data[cur],&seqlist->data[cur+1]);
        }
    }
    return;
}

size_t SeqListSize(SeqList *seqlist)//求顺序表的大小
{
    if(seqlist == NULL)
        return -1;      //非法输入

    return seqlist->size;
}

int SeqListEmpty(SeqList *seqlist)//判断顺序表是否为空
{
    if(seqlist == NULL)
        return -1;      //非法输入

    if(seqlist->size == 0)
    {
        return 1;
    }
    else
    {
        return 0;
    }
}
///////////////////////////////////
//测试代码
//////////////////////////////////

#include<stdio.h>
#include<stdint.h>

#define TEST_HEADER printf("\n=================%s=================\n",__FUNCTION__)

void SeqListPrintChar(SeqList *seqlist,const char *msg)
{
    if(seqlist == NULL)
    {
        printf("非法输入");
      return;
    }
    printf("[%s]\n",msg);

    size_t i = 0;
    for( ;i < seqlist->size;i++)
    {
        printf("[%c] ",seqlist->data[i]);
    }
}

void TestInit()
{
    SeqList seqlist;
    SeqListInit(&seqlist);
    printf("seqlist.size expect 0,actual %lu\n",seqlist.size);
}

void TestPushBack()
{
    TEST_HEADER;
    SeqList seqlist;
    SeqListInit(&seqlist);
    SeqListPushBack(&seqlist,'a');
    SeqListPushBack(&seqlist,'b');
    SeqListPushBack(&seqlist,'c');
    SeqListPushBack(&seqlist,'d');

    SeqListPrintChar(&seqlist,"对顺序表进行尾插");
}

void TestPopBack()
{

    TEST_HEADER;
    SeqList seqlist;
    SeqListInit(&seqlist);
    SeqListPushBack(&seqlist,'a');
    SeqListPushBack(&seqlist,'b');
    SeqListPushBack(&seqlist,'c');
    SeqListPushBack(&seqlist,'d');

    SeqListPopBack(&seqlist);
    SeqListPrintChar(&seqlist,"对顺序表进行尾删");
}

void TestPushFront()
{

    TEST_HEADER;
    SeqList seqlist;
    SeqListInit(&seqlist);
    SeqListPushBack(&seqlist,'a');
    SeqListPushBack(&seqlist,'b');
    SeqListPushBack(&seqlist,'c');
    SeqListPushBack(&seqlist,'d');

    SeqListPushFront(&seqlist,'z');
    SeqListPrintChar(&seqlist,"对顺序表进行头插");
}

void TestPopFront()
{

    TEST_HEADER;
    SeqList seqlist;
    SeqListInit(&seqlist);
    SeqListPushBack(&seqlist,'a');
    SeqListPushBack(&seqlist,'b');
    SeqListPushBack(&seqlist,'c');
    SeqListPushBack(&seqlist,'d');

    SeqListPushFront(&seqlist,'z');
    SeqListPopFront(&seqlist);
    SeqListPrintChar(&seqlist,"将顺序表头部元素删除");

}

void TestInsert()
{

    TEST_HEADER;
    SeqList seqlist;
    SeqListInit(&seqlist);
    SeqListPushBack(&seqlist,'a');
    SeqListPushBack(&seqlist,'b');
    SeqListPushBack(&seqlist,'c');
    SeqListPushBack(&seqlist,'d');

    SeqListInsert(&seqlist,2,'x');
    SeqListPrintChar(&seqlist,"给顺序表任意位置插入元素");
}

void TestErase()
{

    TEST_HEADER;
    SeqList seqlist;
    SeqListInit(&seqlist);
    SeqListPushBack(&seqlist,'a');
    SeqListPushBack(&seqlist,'b');
    SeqListPushBack(&seqlist,'c');
    SeqListPushBack(&seqlist,'d');

    SeqListInsert(&seqlist,2,'x');
    SeqListErase(&seqlist,2);
    SeqListPrintChar(&seqlist,"删除顺序表任意位置元素");
}

void TestGet()
{

    TEST_HEADER;
    SeqList seqlist;
    SeqListInit(&seqlist);
    SeqListPushBack(&seqlist,'a');
    SeqListPushBack(&seqlist,'b');
    SeqListPushBack(&seqlist,'c');
    SeqListPushBack(&seqlist,'d');

    SeqListType value;
    int ret= SeqListGet(&seqlist,2,&value);
    printf("value expected [c],actual [%c]",value);
}

void TestSet()
{

    TEST_HEADER;
    SeqList seqlist;
    SeqListInit(&seqlist);
    SeqListPushBack(&seqlist,'a');
    SeqListPushBack(&seqlist,'b');
    SeqListPushBack(&seqlist,'c');
    SeqListPushBack(&seqlist,'d');

    SeqListSet(&seqlist,0,'x');
    SeqListPrintChar(&seqlist,"将0位置的[a]改成[x]");    
}

void TestFind()
{

    TEST_HEADER;
    SeqList seqlist;
    SeqListInit(&seqlist);
    SeqListPushBack(&seqlist,'a');
    SeqListPushBack(&seqlist,'b');
    SeqListPushBack(&seqlist,'c');
    SeqListPushBack(&seqlist,'d');

    size_t pos = SeqListFind(&seqlist,'b');
    printf("pos expected 1,actual %ld",(int64_t)pos);

}

void TestRemove()
{

    TEST_HEADER;
    SeqList seqlist;
    SeqListInit(&seqlist);
    SeqListPushBack(&seqlist,'a');
    SeqListPushBack(&seqlist,'b');
    SeqListPushBack(&seqlist,'c');
    SeqListPushBack(&seqlist,'d');

    SeqListRemove(&seqlist,'d');
    SeqListPrintChar(&seqlist,"移除顺序表中的元素");
}

void TestRemoveAll()
{

    TEST_HEADER;
    SeqList seqlist;
    SeqListInit(&seqlist);
    SeqListPushBack(&seqlist,'b');
    SeqListPushBack(&seqlist,'a');
    SeqListPushBack(&seqlist,'b');
    SeqListPushBack(&seqlist,'c');
    SeqListPushBack(&seqlist,'d');
    SeqListPushBack(&seqlist,'b');

    SeqListRemoveAll(&seqlist,'b');
    SeqListPrintChar(&seqlist,"移除顺序表中的元素'b'");
}

void TestBubbleSort()
{

    TEST_HEADER;
    SeqList seqlist;
    SeqListInit(&seqlist);
    SeqListPushBack(&seqlist,'e');
    SeqListPushBack(&seqlist,'b');
    SeqListPushBack(&seqlist,'c');
    SeqListPushBack(&seqlist,'a');
    SeqListPushBack(&seqlist,'d');

    SeqListBubbleSort(&seqlist);
    SeqListPrintChar(&seqlist,"冒泡排序");
}

int Greater(SeqListType a,SeqListType b)
{
    return a > b? 1:0;       //降序
}

int Less(SeqListType a,SeqListType b)
{
    return a < b? 1:0;      //升序
}
void TestBubbleSortEx()
{

    TEST_HEADER;
    SeqList seqlist;
    SeqListInit(&seqlist);
    SeqListPushBack(&seqlist,'e');
    SeqListPushBack(&seqlist,'b');
    SeqListPushBack(&seqlist,'c');
    SeqListPushBack(&seqlist,'a');
    SeqListPushBack(&seqlist,'d');

    SeqListBubbleSortEx(&seqlist,Less);
    SeqListPrintChar(&seqlist,"升序");
}

void TestSize()
{

    TEST_HEADER;
    SeqList seqlist;
    SeqListInit(&seqlist);
    SeqListPushBack(&seqlist,'e');
    SeqListPushBack(&seqlist,'b');
    SeqListPushBack(&seqlist,'c');
    SeqListPushBack(&seqlist,'a');

    size_t count = SeqListSize(&seqlist);
    printf("count expected 4,actual %d",count);
}
void TestEmpty()
{
    TEST_HEADER;
    SeqList seqlist;
    SeqListInit(&seqlist); 
    SeqListPushBack(&seqlist,'e');
    SeqListPushBack(&seqlist,'b');
    SeqListPushBack(&seqlist,'c');

    size_t ret = SeqListEmpty(&seqlist);
    printf("ret expected 0,actual %d",ret);
}
int main()
{
    TestInit();
    TestPushBack();       
    TestPopBack();
    TestPushFront();
    TestPopFront();
    TestInsert();
    TestErase();
    TestGet();
    TestSet();
    TestFind();
    TestRemove();
    TestRemoveAll();
    TestBubbleSort();
    TestBubbleSortEx();
    TestSize();
    TestEmpty();
    printf("\n");
    return 0;
}
y6_xiamo
关注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值