动态顺序表部分接口的简单实现_include包含动态接口的执行顺序-优快云博客

本文介绍了一种动态顺序表的数据结构实现方法，包括初始化、销毁、插入、删除等基本操作，并提供了完整的C语言代码示例。文章还展示了如何通过动态调整内存来高效管理数据。

我们的动态顺序表指的依旧是能动态开辟内存，需要用多少内存就开辟多少，从而合理的利用内存资源。
Seqlist_D.h

#ifndef __SEQLIST_D_H__
#define __SEQLIST_D_H__

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

#define SZ 2 //初始化内存的大小
#define INC 1 //动态开辟的大小
#define MAX 100 //顺序表的长度

typedef int DataType;

typedef struct myseqlist 
{
    DataType *data;
    int sz;
    int capacity;
}seqlist, *pseqlist;

void InitSeqlist(pseqlist ps); //初始化
void DestorySeqlist(pseqlist ps); //销毁
void CheckSeqlist(pseqlist ps); //检查内存
void PushBack(pseqlist ps, DataType d);//尾部插入元素
void PrintSeqlist(const pseqlist ps);//打印
void PopBack(pseqlist ps);//尾删
void PushFront(pseqlist ps, DataType d); //头部插入元素
void PopFrint(pseqlist ps); //头部删除元素
void Insert(pseqlist ps, int pos, DataType d); //在pos前面插入目标元素
int Find(pseqlist ps, DataType d); //查找目标元素并返回下标
void Remove(pseqlist ps, DataType d); //删除目标元素
void RemoveAll(pseqlist ps, DataType d); //删除所有元素d
void ReverseSeqlist(pseqlist ps); //逆序
void SortSeqlist(pseqlist ps); //冒泡排序
int BinarySearch(pseqlist ps, DataType d); //二分查找目标元素

#endif

Seqlist_D.c

#include "Seqlist_D.h"

void InitSeqlist(pseqlist ps)
{
    assert(ps);
    ps->data = (DataType*)malloc(sizeof(seqlist)*SZ);
    if (ps->data != NULL)
    {
        ps->sz = 0;
        ps->capacity = SZ; 
    }
}

void DestorySeqlist(pseqlist ps)
{
    assert(ps);
    if(ps->data != NULL)
    {
        free(ps->data);
        ps->data = NULL;
    }
}

void CheckSeqlist(pseqlist ps)
{
    assert(ps);
    if (ps->sz == ps->capacity)
    {
        DataType *str = (DataType*)realloc(ps->data,sizeof(seqlist)*(ps->capacity+INC));
        if(str != NULL)
        {
            ps->data = str;
            ps->capacity += INC;
            return;
        }
        exit(EXIT_FAILURE);
    } 
}

void PushBack(pseqlist ps, DataType d)
{
    assert(ps);
    CheckSeqlist(ps); //先检查内存容量，不够进行扩充
    if(ps->sz != MAX) //MAX为最大容量
    {
        ps->data[ps->sz] = d;
        ps->sz++;
        return;
    }
    exit(EXIT_FAILURE);
}

void PrintSeqlist(const pseqlist ps)  //打印
{
    int i = 0;
    assert(ps);
    for(i=0; i<ps->sz; i++)
    {
        printf("%d ", ps->data[i]);
    }
    printf("\n");
}

void PopBack(pseqlist ps)//尾删
{
    assert(ps);
    if(ps->sz == 0)
    {
        return;
    }
    ps->sz--;
}

void PushFront(pseqlist ps, DataType d) //头部插入元素
{
    int i = 0;
    assert(ps);
    CheckSeqlist(ps);
    if(ps->sz != MAX)
    {
        for(i=ps->sz; i>0; i--)
        {
            ps->data[i] = ps->data[i-1];
        }
        ps->data[0] = d;
        ps->sz ++;
    }
    return;
}

void PopFront(pseqlist ps) //头部删除元素
{
    assert(ps);
    if(ps->sz != 0)
    {
        int i = 0;
        for(i=0; i<ps->sz-1; i++)
        {
            ps->data[i] = ps->data[i+1];
        }
    }
    ps->sz--;
}

void Insert(pseqlist ps, int pos, DataType d) //在pos前面插入目标元素
{
    int i = 0;
    assert(ps);
    CheckSeqlist(ps);
    if(ps->sz == MAX)
    {
        return;
    }
    for(i=ps->sz; i>pos; i--)
    {   
        ps->data[i] = ps->data[i-1];
    }
    ps->data[pos] = d;
    ps->sz++;
}

int Find(pseqlist ps, DataType d) //查找目标元素并返回下标
{
    int i = 0;
    assert(ps);
    for(i=0; i<ps->sz; i++)
    {
        if(ps->data[i] == d)
        {
            return i;
        }
    }
    return -1;
}

void Remove(pseqlist ps, DataType d) //删除目标元素
{
    int i = 0;
    int j = 0;
    assert(ps);
    i = Find(ps, d);
    if(ps->sz == 0)
    {
        return ;
    }
    if(i != -1)
    {
        for(;i<ps->sz-1;i++ )
        {
            ps->data[i] = ps->data[i+1];
        }
        ps->sz--;
    }
}
void RemoveAll(pseqlist ps,DataType d) //删除所有元素d   
{
    int i = 0;
    assert(ps);
    while(1)
    {
        int ret = 0;
        ret = Find(ps, d);
        if (ret != -1)
        {
            Remove(ps,d);
            i++;
        }
        else
        {
            return;
        }
    }
    ps->sz-=i;
}

void ReverseSeqlist(pseqlist ps) //逆序
{
    int left = 0;
    int right = ps->sz-1;
    assert(ps);

    while(left<right)
    {
        DataType n = ps->data[left]; 
        ps->data[left] = ps->data[right];
        ps->data[right] = n;
        left++;
        right--;
    }
}

void SortSeqlist(pseqlist ps) //冒泡排序
{
    int i = 0;
    int j = 0;
    assert(ps);
    for(i=0; i<ps->sz-1; i++)
    {
        for(j=0; j<ps->sz-i-1; j++)
        {
            if(ps->data[j] < ps->data[j+1])
            {
                DataType n = ps->data[j];
                ps->data[j] = ps->data[j+1];
                ps->data[j+1] = n;
            }
        }
    }   
}

int BinarySearch(pseqlist ps, DataType d) //二分查找目标元素
{
    int left = 0;
    int mid = 0;
    int right = 0;
    assert(ps);
    right = ps->sz-1;
    SortSeqlist(ps); //先进行冒泡排序，保证二分查找的有效性
    while(left <= right)
    {
        int mid = (left - (left - right)/2);

        if(ps->data[mid] > d)
        {
            left = mid-1;
        }
        else if(ps->data[mid] < d)
        {
            right = mid+1;
        }
        else
        {
            return mid;
        }
    }
    return -1;
}

test.c

#include "Seqlist_D.h"

seqlist mylist;

void test1()
{
    int tmp = 0;
    InitSeqlist(&mylist);
    PushBack(&mylist, 1);
    PushBack(&mylist, 2);
    PushBack(&mylist, 4);   
    PushBack(&mylist, 9);   
    PushBack(&mylist, 8);   
    PushBack(&mylist, 3);
    PrintSeqlist(&mylist);
    SortSeqlist(&mylist);
    PrintSeqlist(&mylist);
    tmp =BinarySearch(&mylist, 8);
    printf("%d\n", tmp);
}

int main()
{
    test1();
    return 0;
}

经验证无误，哈哈又是一个练手的小项目。