顺序表的增删查改（二）

顺序表的增删查改（一）
http://blog.csdn.net/qq_40927789/article/details/79565678
这里放上《顺序表的增删查改（一）》的原文链接，以便了解顺序表的相关知识点，以下是关于顺序表操作的所有代码内容，与上文有重复，本文中对上文提到的代码有些微的更改，但整体内容不变。
seqlist.h文件

#pragma once  

#include<stddef.h>  

#define seqlistMaxNum 10  

typedef int seqlistType;  
typedef struct SeqList   
{  
    seqlistType data[seqlistMaxNum];  
    size_t size;//size_t是长整型，需要引用“stddef.h”头文件。此处定义一个size_t型的size为该数组中有效元素的个数  
}SeqList;  

SeqList seqlist;  

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

void ifFull(SeqList *seqlist);//判断顺序表是否满了，每一次对顺序表进行插入操作之前都需要判断  
void ifEmpty(SeqList *seqlist);//判断顺序表是否为空，每一次对顺序表进行删除或打印操作时都需要判断  
void seqlistPrint(SeqList *seqlist);//打印顺序表中的元素  

void seqlistPushBack(SeqList *seqlist,int data);//尾插  
void seqlistPopBack(SeqList *seqlist);//尾删  

void seqlistPushFront(SeqList *seqlist,int data);//头插  
void seqlistPopFront(SeqList *seqlist);//头删  
//其中的pos代表'第几个元素' 或 '第几个位置'，对应的下标均需要使用（pos-1）  
void seqlistInsert(SeqList *seqlist,int pos,int data);//任意位置插入元素  
void seqlistErase(SeqList *seqlist,int pos);//任意位置删除元素  
void seqlistSet(SeqList *seqlist,int pos,int data);//修改任意位置元素  
void seqlistGet(SeqList *seqlist,int pos);//获取任意位置元素  
void seqlistFind(SeqList *seqlist,int data);//查找任意元素的下标  
void seqlistRemove(SeqList *seqlist,int to_delete);//删除指定的顺序表中的元素，如果有则只删除第一个该元素
void seqlistRemoveAll(SeqList *seqlist,int to_delete);//删除指定的顺序表中的元素

size_t seqlistSize(SeqList *seqlist);//求顺序表的元素个数

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

seqlist.c文件

#include<stdio.h>  
#include<stdlib.h>  
#include"seqlist.h"  
//测试函数运行会打印当前函数名，便于测试观察  
#define head__print printf("\n==========%s==========\n",__FUNCTION__);  
//初始化函数  
void seqlistInit(SeqList *seqlist)  
{  
    if(seqlist == NULL)  
    {  
        return;  
    }  
   //size是数组中有效元素的个数，因此可直接将size值设为0即可  
    seqlist->size = 0;  
}  
//判断顺序表是否满了  
void ifFull(SeqList *seqlist)  
{  
    if(seqlist == NULL)  
    {  
        return;  
    }  
    if(seqlist->size >= seqlistMaxNum)  
    {  
        printf("the seqlist is full\n");  
    }  
}  
//判断顺序表是否为空  
void ifEmpty(SeqList *seqlist)  
{  
    if(seqlist == NULL)  
    {  
        return;  
    }  
    if(seqlist->size == 0)  
    {  
        printf("the seqlist is empty\n");  
    }  
}  
//打印顺序表中的元素  
void seqlistPrint(SeqList *seqlist)  
{  
    int i = 0;  
    if(seqlist == NULL)  
    {  
        return;  
    }  
    //打印前需要先判断顺序表中是否存在元素  
    ifEmpty(seqlist);  
    for(;i < seqlist->size;i++)  
    {  
        printf("%d ",seqlist->data[i]);  
    }  
    printf("\n");  
}  
//尾插  
void seqlistPushBack(SeqList *seqlist,int data)  
{  
    if(seqlist == NULL)  
    {  
        return;  
    }  
    //每一次增加元素前需要判断顺序表是否还有可插入的空间,后面不再说明  
    ifFull(seqlist);  
    ++seqlist->size;  
    seqlist->data[seqlist->size-1] = data;  
}  
//尾删  
void seqlistPopBack(SeqList *seqlist)  
{  
    if(seqlist == NULL)  
    {  
        return;  
    }  
    //每一次删除前需要判断顺序表中是否存在元素，后面不再说明  
    ifEmpty(seqlist);  
    //size是数组中有效元素的个数，因此size-1即可达到尾删的目的  
    --seqlist->size;  
}  
//头插  
void seqlistPushFront(SeqList *seqlist,int data)  
{  
    int i = 0;  
    if(seqlist == NULL)  
    {  
        return;  
    }  
    ifFull(seqlist);  
    //将已有的元素后移一位  
    for(i = seqlist->size-1;i >= 0;i--)  
    {  
        seqlist->data[i+1] = seqlist->data[i];  
    }  
    ++seqlist->size;  
    //对0号下标位置赋值，完成头插  
    seqlist->data[0] = data;  
}  
//头删  
void seqlistPopFront(SeqList *seqlist)  
{  
    int i = 0;  
    if(seqlist == NULL)  
    {  
        return;  
    }  
    ifEmpty(seqlist);  
    //将0号下标位置（不包括0）往后的所有元素往前移动一位，将数组有效元素个数-1即可  
    for(;i < seqlist->size-1;i++)  
    {  
        seqlist->data[i] = seqlist->data[i+1];  
    }  
    --seqlist->size;  
}  
//任意位置插入元素  
void seqlistInsert(SeqList *seqlist,int pos,int data)  
{  
    int i = 0;  
    if(seqlist == NULL)  
    {  
        return;  
    }  
    ifFull(seqlist);  
    //判断目标位置是否合法  
    if(pos > seqlist->size)  
    {  
        //目标位置超出了数组有效元素个数的范围  
        return;  
    }  
    //pos为1时代表0号下标位置，后面不再说明  
    if(pos == 1)  
        seqlistPushFront(seqlist,data);  
    //pos为size大小时代表size-1号下标位置，后面不再说明  
    else if(pos == seqlist->size)  
        seqlistPushBack(seqlist,data);  
    else   
    {  
        //将pos位置（包括pos）往后的所有元素后移一位  
        for(i = seqlist->size;i >= pos;i--)  
        {  
            seqlist->data[i] = seqlist->data[i-1];  
        }  
        //有效元素个数+1  
        ++seqlist->size;  
        //对pos位置赋值  
        seqlist->data[pos-1] = data;  
    }  
}  
//任意位置删除元素  
void seqlistErase(SeqList *seqlist,int pos)  
{  
    int i = 0;  
    if(seqlist == NULL)  
    {  
        return;  
    }  
    ifEmpty(seqlist);  
    if(pos == seqlist->size)  
        seqlistPopBack(seqlist);  
    if(pos == 1)  
        seqlistPopFront(seqlist);  
    else  
    {  
        //将pos位置（不包括pos）往后的所有元素往前移动一位  
        for(i = pos-1;i < seqlist->size-1;i++)  
        {  
            seqlist->data[i] = seqlist->data[i+1];  
        }  
        //有效元素个数-1  
        --seqlist->size;  
    }  
}  
//修改任意位置元素  
void seqlistSet(SeqList *seqlist,int pos,int data)  
{  
    if(seqlist == NULL)  
    {  
        return;  
    }  
    seqlist->data[pos-1] = data;  
}  
//获取任意位置元素  
void seqlistGet(SeqList *seqlist,int pos)  
{  
    if(seqlist == NULL)  
    {  
        return;  
    }  
    printf("%d\n",seqlist->data[pos-1]);  
}  
//查找任意元素的下标  
void seqlistFind(SeqList *seqlist,int data)  
{  
    if(seqlist == NULL)  
    {  
        return;  
    }  
    int i = 0;  
    //count表示查找的目标元素有多少个  
    int count = 0;  
    for(;i < seqlist->size;i++)  
    {  
        if(seqlist->data[i] == data)  
        {  
            printf("%d \n",i);  
            ++count;  
        }  
    }  
    if(counot == 0)  
    {  
        //如果count=0说明循环结束没有找到该元素  
        printf("non-existent  ");  
    }  
} 
//删除指定的顺序表中的元素，如果有只删除第一个
void seqlistRemove(SeqList *seqlist,int to_delete)
{
    if(seqlist == NULL)
    {
        return;
    }
    ifEmpty(seqlist);
    int i = 0;
    int count = 0;
    for(;i < seqlist->size;i++)
    {
        //找到与指定元素相等的元素下标
        while(seqlist->data[i] == to_delete)
        {
            int j = 0;
            //将该元素（不包括该元素）往后的所有元素往前移动一位
            for(j = i;j < seqlist->size;j++)
            {
                seqlist->data[j] = seqlist->data[j+1];
            }
            //顺序表有效元素个数-1
            --seqlist->size;
            count++;
        }
        //如果count==1说明已经找到第一个该元素且经过删除
        if(count == 1)
            break;
    }
    if(count == 0)
    {
        printf("this value is non-existent  ");
    }
}
//删除指定的顺序表中的所有元素
void seqlistRemoveAll(SeqList *seqlist,int to_delete)
{
    if(seqlist == NULL)
    {
        return;
    }
    ifEmpty(seqlist);
    int i = 0;
    int count = 0;
    for(;i < seqlist->size;i++)
    {
        if(seqlist->data[i] == to_delete)
        {
            int j = 0;
            for(j = i;j < seqlist->size;j++)
            {
                seqlist->data[j] = seqlist->data[j+1];
            }
            --seqlist->size;
            count++;
        }
    }
    if(count == 0)
    {
        printf("this value is non-existent  ");
    }
}
//求顺序表有效元素个数
size_t seqlistSize(SeqList *seqlist)
{
    return seqlist->size;
}
//冒泡排序
void seqlistBubbleSort(SeqList *seqlist)
{
    if(seqlist == NULL)
    {
        return;
    }
    ifEmpty(seqlist);
    //若顺序表中只有一个元素则不需要排序
    if(seqlist->size == 1)
    {
        return;
    }
    else
    {
        int bound = 0;
        int flag = 1;
        for(;bound < seqlist->size-1;bound++)
        {
            //如果flag==0说明循环一趟没有经过值的交换说明该顺序表已经有序，就不需要在进行后面没有进行完的循环
            if(flag == 0)
                break;
            int cur = 0;
            for(cur = seqlist->size-1;cur > bound;cur--)
            {
                if(seqlist->data[cur-1] > seqlist->data[cur])
                {
                    int tmp = 0;
                    tmp = seqlist->data[cur-1];
                    seqlist->data[cur-1] = seqlist->data[cur];
                    seqlist->data[cur] = tmp;
                    flag = 1;
                }
            }
        }
    }
}


//初始化函数测试  
void seqlistTestInit()  
{  
    head__print;  
    printf("expect:0\n");  
    seqlistInit(&seqlist);  
    printf("%lu\n",seqlist.size);  
}  
//尾插函数测试  
void TestPushBack()  
{  
    head__print;  
    //期待输出值，后面不再说明  
    printf("expect:1 2 3 4\n");  
    //4次调用尾插函数，依次插入1,2,3,4  
    seqlistPushBack(&seqlist,1);  
    seqlistPushBack(&seqlist,2);  
    seqlistPushBack(&seqlist,3);  
    seqlistPushBack(&seqlist,4);  
    //打印顺序表，与期待值对比，后面不再说明  
    seqlistPrint(&seqlist);  
}  
//尾删函数测试  
void TestPopBack()  
{  
    head__print;  
    printf("expect:1 2\n");  
    int i = 0;  
    //循环调用2次尾删函数，依次删除4,3  
    for(i=1;i<=2;i++)  
    {  
        seqlistPopBack(&seqlist);  
    }  
    seqlistPrint(&seqlist);  
}  
//头插函数测试  
void TestPushFront()  
{  
    head__print;  
    printf("expect:8 7 6 5 1 2\n");  
    //4次调用头插函数，依次插入5,6,7,8  
    seqlistPushFront(&seqlist,5);  
    seqlistPushFront(&seqlist,6);  
    seqlistPushFront(&seqlist,7);  
    seqlistPushFront(&seqlist,8);  
    seqlistPrint(&seqlist);  
}  
//头删函数测试  
void TestPopFront()  
{  
    head__print;  
    printf("expect:6 5 1 2\n");  
    int i = 0;  
    //依次删除8,7  
    for(i = 1;i <= 2;i++)  
    {  
    seqlistPopFront(&seqlist);  
    }  
    seqlistPrint(&seqlist);  
}  
//任意位置插入元素函数测试  
void seqlistTestInsert()  
{  
    head__print;  
    printf("expect:0 6 4 5 1 2\n");  
    //1号位置插入0，3号位置插入4  
    seqlistInsert(&seqlist,1,0); 
    seqlistInsert(&seqlist,3,4); 
    seqlistPrint(&seqlist);  
}  
//任意位置删除元素函数测试  
void seqlistTestErase()  
{  
    head__print;  
    printf("expect:6 4 5 2\n");  
    //删除1号和4号位置元素  
    seqlistErase(&seqlist,1);  
    seqlistErase(&seqlist,4);  
    seqlistPrint(&seqlist);  
}  
//修改任意位置元素函数测试  
void seqlistTestSet()  
{  
    head__print;  
    printf("expect:6 3 5 2\n");  
    //将2号位置元素修改为3  
    seqlistSet(&seqlist,2,3);  
    seqlistPrint(&seqlist);  
}  
//获取任意位置元素函数测试  
void seqlistTestGet()  
{  
    head__print;  
    printf("expect:2\n");  
    //获取4号位置元素  
    seqlistGet(&seqlist,4);  
}  
//查找任意元素的下标函数测试  
void seqlistTestFind()  
{  
    head__print;  
    printf("expect:3 0 non-existent\n");  
    //查找元素为1和元素为5的元素下标  
    seqlistFind(&seqlist,2);  
    seqlistFind(&seqlist,6); 
    seqlistFind(&seqlist,4);  
}  
//删除顺序表中的指定元素，如果有只删除第一个该元素的函数测试 
void TestRemove()
{
    head;
    seqlistPushBack(&seqlist,3);//先尾插如一个3
    printf("expect: 5 2 3\n");
    //删除顺序表中的6和3
    seqlistRemove(&seqlist,6);
    seqlistRemove(&seqlist,3);
    seqlistPrint(&seqlist);
}
//删除顺序表中指定的所有元素的函数测试
void TestRemoveAll()
{
    head;
    seqlistPushBack(&seqlist,2);//尾插如一个2
    printf("expect:this value is non-existent  5 3\n");
    //删除顺序表中的1和2
    seqlistRemoveAll(&seqlist,1);
    seqlistRemoveAll(&seqlist,2);
    seqlistPrint(&seqlist);
}
//求顺序表有效元素个数的函数测试
void TestSize()
{
    head;
    printf("expect:2\n");
    size_t size = seqlistSize(&seqlist);
    printf("size:%d\n",size);
}
//顺序表冒泡排序函数测试
void TestBubbleSort()
{
    head;
    printf("expect:0 1 3 4 5 5\n");
    //先尾插入4 1 5和0
    seqlistPushBack(&seqlist,4);
    seqlistPushBack(&seqlist,1);
    seqlistPushBack(&seqlist,5);
    seqlistPushBack(&seqlist,0);
    //调用冒泡排序函数
    seqlistBubbleSort(&seqlist);
    seqlistPrint(&seqlist);
}  

int main()  
{  
    //以下为调用测试函数  
    TestInit();  
    TestPushBack();  
    TestPopBack();  
    TestPushFront();  
    TestPopFront();  
    TestInsert();  
    TestErase();  
    TestSet();  
    TestGet();  
    TestFind();  
    TestRemove();
    TestRemoveAll();
    TestSize();
    TestBubbleSort();
    return 0;  
}