静态顺序表基本操作

测试环境VS2013
seqlist.h

#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <malloc.h>

typedef int DataType;
typedef struct ListNode
{
    struct ListNode *_pNext;
    DataType _data;
}Node, *PNode;

void SListInit(PNode *pHead);   //初始化

PNode BuySListNode(DataType data);   //创建新链表

void SListPushBack(PNode *pHead, DataType data);   //尾插
void SListPopBack(PNode *pHead);   //尾删

void SListPushFront(PNode *pHead, DataType data);   //头插
void SListPopFront(PNode *pHead);   //头删

void FindList(PNode pHead, DataType data);  //在链表中查找值为data的元素，找到后返回值为data的结点

void ListPushInsert(PNode *pHead, PNode pos, DataType data);  //任意位置的插入
void ListPopErase(PNode *pHead, PNode pos); //任意位置的删除

int SListSize(PNode pHead,DataType data);   //获取链表中值为data的结点

int SListEmpty(PNode pHead);  //判断链表是否为空

void PrintList(PNode pHead);   //打印

void SListDestroy(PNode *pHead); //销毁链表

seqlist.c

//顺序表的初始化
void SeqListInit(PSeqList ps)
{
    if (NULL == ps)
        return;
    ps->_size = 0;
}

//顺序表的尾插
void SeqListPushBack(PSeqList ps, DataType data)
{
    if (NULL == ps)
        return;
    if (MAX_SIZE == ps->_size)
    {
        printf("顺序表已满!!!\n");
        return;
    }
    ps->_array[ps->_size] = data;
    ++ps->_size;
}

//顺序表的尾删
void SeqListPopBack(PSeqList ps)
{
    if (NULL == ps)
        return;
    if (0 == ps->_size)
    {
        printf("顺序表已空!!!\n");
        return;
    }
    --ps->_size;
}

//顺序表的头插
void SeqListPushFront(PSeqList ps, DataType data)
{
    int i = 0;
    if (NULL == ps)
        return;
    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)
        return;
    if (0 == ps->_size)
    {
        printf("顺序表已空!!!\n");
        return;
    }
    for (i = 0; i < ps->_size; 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))
        return;
    if (MAX_SIZE == ps->_size)
    {
        printf("顺序表已满!!!\n");
        return;
    }
    for (i = ps->_size - 1; i >= pos; i--)
        ps->_array[i + 1] = ps->_array[i];
    ps->_array[pos] = data;
    ps->_size++;
}

//删除顺序表pos位置元素
void SeqListEraser(PSeqList ps, int pos)
{
    int i = pos;
    if (NULL == ps || !(pos >= 0 && pos <= ps->_size))
        return;
    if (0 == ps->_size)
    {
        printf("顺序表已空!!!\n");
        return;
    }
    for (i = pos; i < ps->_size; i++)
        ps->_array[i] = ps->_array[i+1];
    --ps->_size;
}

//移除顺序表中第一个值为data的元素
void SeqListRemove(PSeqList ps, DataType data)
{
    if (NULL == ps)
        return;
    int ret = SeqListFind(ps, data);
    int i = ret;

    if (data == -1)
    {
        printf("该数据不存在!\n");
        return;
    }
    for (i = ret; i < ps->_size - 1; i++)
        ps->_array[i] = ps->_array[i + 1];
    --ps->_size;
}

//移除顺序表中所有值为data的元素
void SeqListRemoveAll(PSeqList ps, DataType data)
{
    if (NULL == ps)
        return;
    int ret = SeqListFind(ps, data);
    int i = ret;
    int count = 0;

    if (data == -1)
    {
        printf("该数据不存在!\n");
        return;
    }
    for (i = ret; i < ps->_size - 1; 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;
    int j = 0;
    if (NULL == ps)
        return -1;
    for (i = 0; i < ps->_size; i++)
    {
        if (ps->_array[i] == data)
            return i;
    }
}

//获取顺序表中元素的个数
int SeqListSize(PSeqList ps)
{
    printf("有效元素的个数为%d\n", ps->_size);
    return 0;
}



//打印顺序表
void PrintSeqList(PSeqList ps)
{
    int i = 0;
    if (NULL == ps)
        return;
    if (0 == ps->_size)
        printf("顺序表为空!!!\n");
    printf("size:%d\n", ps->_size);
    for (i = 0; i < ps->_size; i++)
        printf("%d ", ps->_array[i]);
    printf("\n");
}

//使用冒泡排序对顺序表中的元素进行排序
void BubbleSort(PSeqList ps)
{
    int i = 0;
    if (NULL == ps)
        return;
    for (i = 0; i < ps->_size - 1; i++)
    {
        int j = 0;
        for (j = 0; j < ps->_size - 1 - i; j++)
        {
            if (ps->_array[j] > ps->_array[j + 1])
            {
                int tmp = ps->_array[j];
                ps->_array[j] = ps->_array[j + 1];
                ps->_array[j + 1] = tmp;
            }
        }
    }
}

//使用选择排序对顺序表中的元素进行排序
void SelectSort(PSeqList ps)
{
    int i = 0;
    int j = 0;
    int max = 0;
    if (NULL == ps)
        return;
    for (i = 0; i < ps->_size; i++)
    {
        max = 0;
        for (j = 1; j < ps->_size - i; j++)
        {
            if (ps->_array[max] < ps->_array[j])
                max = j;
        }
        Swap(&ps->_array[max], &ps->_array[ps->_size - i - 1]);
    }
}

//交换
void Swap(int *p, int *q)
{
    if (NULL == p)
        return;
    if (NULL == q)
        return;
    int tmp = *p;
         *p = *q;
         *q = tmp;
}

测试 test.c

#include "seqlist.h"

int main()
{
    SeqList s;

    SeqListInit(&s);

    //插入数据
    SeqListPushBack(&s, 1);
    SeqListPushBack(&s, 2);
    SeqListPushBack(&s, 3);
    SeqListPushBack(&s, 4);
    SeqListPushBack(&s, 5);
    SeqListSize(&s);  //计数
    PrintSeqList(&s); //打印数据

    SeqListPushBack(&s, 6);  //尾插
    SeqListSize(&s);  //计数
    PrintSeqList(&s); //打印数据

    SeqListPopBack(&s);  //尾删
    SeqListSize(&s);  //计数
    PrintSeqList(&s); //打印数据

    SeqListPushFront(&s, 0);  //头插
    SeqListSize(&s);  //计数
    PrintSeqList(&s); //打印数据

    SeqListPopFront(&s);  //头删
    SeqListSize(&s);  //计数
    PrintSeqList(&s); //打印数据

    SeqListInsert(&s, 3, 8);  //任意位置的插入
    SeqListSize(&s);  //计数
    PrintSeqList(&s); //打印数据

    SeqListEraser(&s, 3);  //任意位置的删除
    SeqListSize(&s);  //计数
    PrintSeqList(&s); //打印数据

    SeqListRemove(&s, 2);  //移除顺序表中第一个值为data的元素
    PrintSeqList(&s);

    SeqListRemoveAll(&s, 1);  //移除顺序表中所有值为data的元素
    PrintSeqList(&s);

    system("pause");
    return 0;
}