C语言实现动态顺序表

SeqListD.h

#ifndef __SEQLISTD_H__
#define __SEQLISTD_H__

#include "stdio.h"
#include "assert.h"
#include "stdlib.h"
#include "string.h"

#define DEFALT_CAPACITY 3

typedef int DataType;
typedef unsigned int size_t;

typedef struct SeqListD
{
    DataType* array;
    size_t capicity;   // 空间的实际大小--存放元素的最大个数
    size_t size;   //有效元素的个数
}SeqListD, *PSeqListD;

void InitSeqListD(PSeqListD pSeq);
void PushBack(PSeqListD pSeq, DataType data);
void PushFront(PSeqListD pSeq, DataType data);
void Destroy(PSeqListD pSeq);
void Insert(PSeqListD pSeq, DataType data);
void CheckCapicity(PSeqListD pSeq);
void BubbleSort(PSeqListD pSeq);
void SelectSort(PSeqListD pSeq);
unsigned int BinarySearch(PSeqListD pSeq, DataType data);
void PrintSeqD(PSeqListD pSeq);


#endif

SeqListD.c

#include "SeqListD.h"

//初始化动态线性表
void InitSeqListD(PSeqListD pSeq)
{
    assert(pSeq);
    pSeq->array = (DataType*)malloc(DEFALT_CAPACITY*sizeof(DataType));
    assert(pSeq->array);
    pSeq->size = 0;
    pSeq->capicity = DEFALT_CAPACITY;
}

//尾插
void PushBack(PSeqListD pSeq, DataType data)
{
    assert(pSeq);
    CheckCapicity(pSeq);

    pSeq->array[pSeq->size++] = data;
}

//扩容
void CheckCapicity(PSeqListD pSeq)  
{  
    if (pSeq->size == pSeq->capicity)  
    {  
        DataType* tmp = (DataType*)malloc(pSeq->capicity * 2 *sizeof(DataType));  
        memcpy(tmp, pSeq->array, sizeof(DataType) * pSeq->size);  

        // 释放原空间，更新指针  
        free(pSeq->array);  
        pSeq->array = tmp;  
        pSeq->capicity = pSeq->capicity * 2;  
    }  
}  


//头插
void PushFront(PSeqListD pSeq, DataType data)
{
    unsigned int i;
    assert(pSeq);
    CheckCapicity(pSeq);

    for(i=pSeq->size;i>0;i--)
    {
        pSeq->array[i] = pSeq->array[i-1];
    }
    pSeq->array[0] = data;
    pSeq->size++;

}

//将线性表排序——冒泡
void BubbleSort(PSeqListD pSeq)
{
    unsigned int i;
    unsigned int j;
    int flag = 1;
    assert(pSeq);
    for(i=0;i<(pSeq->size);i++)
    {
        for(j=0;j<(pSeq->size - i-1);j++)
        {
            if(pSeq->array[j]>pSeq->array[j+1])
            {
                DataType temp = pSeq->array[j];
                pSeq->array[j] = pSeq->array[j+1];
                pSeq->array[j+1] = temp;
                flag = 0;
            }
        }
        if(flag)
            return ;
    }
}

//将线性表排序——选择
void SelectSort(PSeqListD pSeq)
{
    unsigned int i = 0;
    unsigned int j = 0 ;
    unsigned int maxPos = 0;
    assert(pSeq);
    for(i=0;i<(pSeq->size-1);i++)
    {
        maxPos = 0;
        for(j=1;j<(pSeq->size-i-1);j++)
        {
            if(pSeq->array[j]>pSeq->array[maxPos])
                maxPos = j;
        }
            if(maxPos != pSeq->size-1-i)
            {
                DataType tmp = pSeq->array [maxPos];
                pSeq->array [maxPos] = pSeq->array [j];
                pSeq->array [j] = tmp;
            }

    }
}

//查找元素——二分法
unsigned int BinarySearch(PSeqListD pSeq, DataType data)
{
    unsigned int left = 0;
    unsigned int right = pSeq->size - 1;
    unsigned int mid = 0;
    assert(pSeq);
    while(left <= right)
    {
        mid = left+((right-left)>>1);
        if(pSeq->array[mid] == data)
            return mid;
        else if(pSeq->array[mid] > data)
            right = mid - 1;
        else
            left = mid + 1;
    }
    return -1;
}

//插入元素
void Insert(PSeqListD pSeq, DataType data)
{
    unsigned int i;
    assert(pSeq);
    for(i=0;i<(pSeq->capicity-1);i++)
    {
        if(pSeq->array[i] > data)
        {
            pSeq->size++;
            pSeq->array[i+1] = pSeq->array[i];
            pSeq->array[i] = data;
        }
    }
}

//销毁线性表
void Destroy(PSeqListD pSeq)
{
    if(pSeq)
    {
        free(pSeq->array);
        pSeq->size = 0;
        pSeq->capicity = 0;

    }
}

//打印动态顺序表
void PrintSeqD(PSeqListD pSeq)
{
    unsigned int i = 0;
    assert(pSeq);
    for(i=0;i<(pSeq->capicity);i++)
    {
        printf("%d->",pSeq->array[i]);
    }
    printf("\n");
}