动态顺序表

动态顺序表：

SeqlistD.h

#ifndef _SeqlistD__H_
#define _SeqlistD__h_
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<string.h>


typedef int DataType;

typedef struct SeqlistD {
    DataType *arr; // 值 
    int size; // 数量 
    int capacity;
} SeqlistD, *pSeqlistD;

#define CAPACITY (4)

void TestSeqlist();
void SeqlistInit(SeqlistD *pSlD);
void ExpandIfRequired(SeqlistD *pSlD);
void SeqlistPushBack(SeqlistD *pSlD, DataType data);
void SeqlistPushFront(SeqlistD *pSlD, DataType data);
void SeqlistPopBack(SeqlistD *pSlD);
void SeqlistPopFront(SeqlistD *pSlD);
void SeqlistInsert(SeqlistD *pSlD, int pos, DataType data);
void SeqlistErase(SeqlistD *pSlD, int pos);
void SeqlistRemove(SeqlistD *pSlD, DataType data);
void SeqlistRemoveAll(SeqlistD *pSlD, DataType data);
void SeqlistClear(SeqlistD *pSlD);
int SeqlistFind(SeqlistD *pSlD, DataType data);
void SeqlistBubbleSort(SeqlistD *pSlD);
void SeqListSelectSort(SeqlistD *pSlD);
int SeqlistEmpty(SeqlistD *pSlD);
int SeqlistSize(SeqlistD *pSlD);
void SeqlistDestroy(SeqlistD *pSlD);
void Seqlistprint(SeqlistD *pSlD);

#endif

main.c

#include"SeqlistD.h"


int main()
{
    TestSeqlist();
    system("pause");
    return 0;
}

SeqlistD.c

#include"SeqlistD.h"



void SeqlistInit(SeqlistD *pSlD)
{
    assert(pSlD != NULL);
    //pSlD->arr = (DataType *)malloc(sizeof(DataType)* CAPACITY);
    pSlD->arr = (DataType *)calloc(sizeof(DataType), CAPACITY);
    assert(pSlD);
    pSlD->size = 0;
    pSlD->capacity = CAPACITY;



}


void ExpandIfRequired(SeqlistD *pSlD)
{
    if (pSlD->size < pSlD->capacity)
    {
        return;
    }
    //伙伴算法
    pSlD->capacity *= 2;
    //创建新的大空间
    //把数据拷贝过去
    //把新空间给到结构体里;
    //把capacity更新
    //把原来的空间释放掉

    DataType *newArr = (DataType *)malloc(sizeof(DataType)*pSlD->capacity);
    assert(newArr);


    int i;
    for (i = 0; i < pSlD->size; i++)
    {
        newArr[i] = pSlD->arr[i];
    }
    pSlD->arr = newArr;
    //free(pSlD->arr);
}

void SeqlistPushBack(SeqlistD *pSlD, DataType data)
{
    assert(pSlD != NULL);
    ExpandIfRequired(pSlD);
    pSlD->arr[pSlD->size] = data;
    pSlD->size++;
}
void SeqlistPushFront(SeqlistD *pSlD, DataType data)
{
    assert(pSlD != NULL);
    ExpandIfRequired(pSlD);
    int i = 0;
    for (i = pSlD->size-1; i >=0; i--)
    {
        pSlD->arr[i + 1] = pSlD->arr[i];
    }
    pSlD->arr[0] = data;
    pSlD->size++;
}
void SeqlistPopBack(SeqlistD *pSlD)
{

    assert(pSlD != NULL);
    assert(pSlD->size > 0);
    if (pSlD->size == 0)
    {
        printf("顺序表为空\n");
        return;
    }
    pSlD->size--;
}

void SeqlistPopFront(SeqlistD *pSlD)
{
    assert(pSlD != NULL);
    if (pSlD->size == 0)
    {
        printf("顺序表为空\n");
        return;
    }
    int i = 0;
    for (i = 1; i<pSlD->size; i++)
    {
        pSlD->arr[i - 1] = pSlD->arr[i];
    }

    pSlD->size--;
}
void SeqlistInsert(SeqlistD *pSlD, int pos, DataType data)
{
    assert(pSlD);
    ExpandIfRequired(pSlD);
    int i = 0;
    for (i = pSlD->size - 1; i >= pos; i--)
    {
        pSlD->arr[i + 1] = pSlD->arr[i];
    }
    pSlD->arr[pos] = data;
    pSlD->size++;
}
void SeqlistErase(SeqlistD *pSlD, int pos)
{
    assert(pSlD != NULL);
    if (pSlD->size == 0)
    {
        printf("顺序表为空\n");
        return;
    }
    assert(pos >= 0 && pos < pSlD->size);
    int i = 0;
    for (i = pos; i < pSlD->size - 1; i++)
    {
        pSlD->arr[i] = pSlD->arr[i + 1];
    }
    pSlD->size--;
}
int SeqlistFind(SeqlistD *pSlD, DataType data)//查找数
{
    assert(pSlD != NULL);
    int i = 0;
    for (i = 0; i < pSlD->size; i++)
    {
        if (pSlD->arr[i] == data)
        {
            return i;
        }
    }
    return -1;
}


void SeqlistRemove(SeqlistD *pSlD, DataType data)
{
    int pos = SeqlistFind(pSlD, data);
    if (pos != -1)
    {
        SeqlistErase(pSlD, pos);
    }
}

void SeqlistRemoveAll(SeqlistD *pSlD, DataType data)//删除所有出现的数
{
    /*int pos;
    while ((pos = SeqlistFind(pSlD, data)) != -1)
    {
    SeqlistErase(pSlD, pos);
    }*/
    //1.重新申请空间，遍历原来的数组，如果不是要删除的，就copy
    //到新的空间
    //2.把新空间的数据copy回原来的数组。
    //3.要把copy的数量就是新的size。
    //4.free新空间。


    //俩个下标，空间下标，遍历下标。
    //逢要删的，跳过遍历下标，计数器++。
    //不是要删的，就把遍历对应的值copy到空间
    //Unitl ,遍历结束
    //size-计数器。
    int spacel = 0;
    int count = 0;
    int i = 0;
    for (i = 0; i < pSlD->size; i++)
    {
        if (pSlD->arr[i] == data)
        {
            count++;
        }
        else
        {
            pSlD->arr[spacel] = pSlD->arr[i];
            spacel++;
        }

    }

    pSlD->size -= count;

}
void Swap(DataType *a, DataType *b)
{
    int tmp;
    tmp = *a;
    *a = *b;
    *b = tmp;
}


void SeqlistBubbleSort(SeqlistD *pSlD)
{
    int i = 0;
    int j = 0;
    for (i = 0; i < pSlD->size - 1; i++)
    {
        for (j = 0; j < pSlD->size - i - 1; j++)
        {
            if (pSlD->arr[j] > pSlD->arr[j + 1])
            {
                Swap(pSlD->arr + j, pSlD->arr + (j + 1));

            }
        }

    }
}
void SeqListSelectSort(SeqlistD *pSlD)
{
    int i, j;
    int minPos, maxPos;
    for (i = 0; i < pSlD->size / 2; i++)
    {
        minPos = maxPos = i;
        for (j = i; j < pSlD->size - i; j++)
        {
            if (pSlD->arr[j] < pSlD->arr[minPos])
            {
                minPos = j;
            }
            if (pSlD->arr[j] > pSlD->arr[maxPos])
            {
                maxPos = j;
            }
        }
        Swap(pSlD->arr + i, pSlD->arr + minPos);
        if (i == maxPos)
        {
            maxPos = minPos;
        }
        Swap(pSlD->arr + pSlD->size - i - 1, pSlD->arr + maxPos);
    }

}


int SeqlistSize(SeqlistD *pSlD)//顺序表的大小
{
    return pSlD->size;
}

int SeqlistEmpty(SeqlistD *pSlD)//判断是否为空
{
    return pSlD->size == 0 ? 1 : 0;
}


void SeqlistClear(SeqlistD *pSlD)//清空顺序表;
{
    pSlD->size = 0;
}

void SeqlistDestroy(SeqlistD *pSlD)
{
    free(pSlD->arr);
    pSlD->arr = NULL;
    pSlD->size = pSlD->capacity = 0;
}
void Seqlistprint(SeqlistD *pSlD)
{
    int i;
    for (i = 0; i < pSlD->size; i++)
    {
        printf("%d ", pSlD->arr[i]);
    }
    printf("\n");
}


void TestSeqlist()
{
    SeqlistD sl;
    SeqlistInit(&sl);//初始化顺序表

    SeqlistPushBack(&sl, 1);//尾插
    SeqlistPushBack(&sl, 2);
    SeqlistPushBack(&sl, 3);
    SeqlistPushBack(&sl, 4);
    Seqlistprint(&sl);

    SeqlistPushBack(&sl, 1);//尾插
    SeqlistPushBack(&sl, 2);
    SeqlistPushBack(&sl, 3);
    SeqlistPushBack(&sl, 4);
    Seqlistprint(&sl);

    SeqlistPushFront(&sl, 1);//头插
    SeqlistPushFront(&sl, 2);
    SeqlistPushFront(&sl, 3);
    SeqlistPushFront(&sl, 4);
    Seqlistprint(&sl);


    SeqlistPopBack(&sl);//尾删
    Seqlistprint(&sl);


    SeqlistPopFront(&sl);//头删
    Seqlistprint(&sl);

    SeqlistInsert(&sl, 2, 5);//随机位置插入
    SeqlistInsert(&sl, 4, 15);
    Seqlistprint(&sl);

    SeqlistErase(&sl, 3);//随机位置删除
    Seqlistprint(&sl);

    int ret = SeqlistFind(&sl, 15);//查找数

    if (ret == -1)
    {
        printf("没有找到\n");
    }
    else
    {
        printf("找到了，该数下标为:%d\n", ret);
    }

    SeqlistRemove(&sl, 3);//删除第一次出现的数
    Seqlistprint(&sl);

    SeqlistRemoveAll(&sl, 2);//删除所有出现的数
    Seqlistprint(&sl);

    SeqlistPushBack(&sl, 9);
    SeqlistPushBack(&sl, 12);
    SeqlistPushBack(&sl, 10);
    SeqlistPushBack(&sl, 11);
    SeqlistPushBack(&sl, 6);
    Seqlistprint(&sl);


    SeqlistBubbleSort(&sl);//冒泡排序
    Seqlistprint(&sl);

    SeqListSelectSort(&sl);//选择排序
    Seqlistprint(&sl);

    int tmp = SeqlistSize(&sl);//顺序表大小
    printf("%d\n", tmp);

    int r = SeqlistEmpty(&sl);//判断顺序表是否为空
    if (r == 1)
    {
        printf("为空\n");
    }
    else
    {
        printf("不为空\n");
    }

    SeqlistClear(&sl);//清空顺序表
    Seqlistprint(&sl);

    SeqlistDestroy(&sl);
    Seqlistprint(&sl);
}