实现动态顺序表

静态顺序表和动态顺序表之间的区别就是静态顺序表的存储大小一旦设定好之后便不能修改;显然动态顺序表采用的是动态分配内存,容量是可以增加的,当然动态顺序表要比静态顺序表多增加一个监测容量的参数,每当当前容量存满的时候就要触发扩容机制,实现动态开辟内存。由于两者差别不是很大,这里我就只实现动态顺序表,静态的基本一样,只是少了扩容机制。(这里我设置的初始容量为3,便于我们观察扩容机制)

现将动态顺序表的实现整理如下,要是哪里有错误,欢迎指正。

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

#define INIT_CAPACITY (3)
//实现动态顺序表
typedef int DataType;
typedef struct SeqList
{
    DataType* _a;
    size_t _size;    // 有效数据个数
    size_t _capacity;    // 容量
}SeqList;

void SeqPrint(SeqList* pSeq);//打印
void SeqInit(SeqList* pSeq);//初始化
void SeqDestory(SeqList* pSeq);//销毁

void SeqPushBack(SeqList* pSeq, DataType x);//尾插
void SeqPopBack(SeqList* pSeq);//尾删
void SeqPushFront(SeqList* pSeq, DataType x);//头插
void SeqPopFront(SeqList* pSeq);//头删

void SeqInsert(SeqList* pSeq, size_t pos, DataType x);//插入
void SeqErase(SeqList* pSeq, size_t pos);//删除

int SeqFind(SeqList* pSeq, DataType x);//查找
void SeqAt(SeqList* pSeq, size_t pos, DataType x);//修改

void BubbleSort(SeqList* pSeq);//冒泡排序
void SelectSort(SeqList* pSeq);//选择排序
int Binary_Search(SeqList* pSeq, DataType x);//二分查找



void SeqPrint(SeqList* pSeq){
    assert(pSeq != NULL);
    if(pSeq->_size == 0){
        printf("NULL\n");
    }
    for(int i=0; i<pSeq->_size; i++){
        printf("%d - > ", pSeq->_a[i]);
    }
    printf("\n");
}

void SeqInit(SeqList* pSeq){
    assert(pSeq);
    pSeq->_capacity = INIT_CAPACITY;
    pSeq->_a = (DataType *)malloc(sizeof(DataType)*pSeq->_capacity);
    assert(pSeq->_a);
    pSeq->_size = 0;
}
void SeqDestory(SeqList* pSeq){
    assert(pSeq);
    free(pSeq->_a);
    
    pSeq->_capacity = 0;
    pSeq->_a = NULL;
    pSeq->_size = 0;
}


void ExpendIfRequired(SeqList* pSeq){
    if(pSeq->_capacity > pSeq->_size){
        return;
    }
    pSeq->_capacity = pSeq->_capacity*2;
    
    DataType* newArray = (DataType *)malloc(sizeof(DataType)*pSeq->_capacity);
    
    for(int i=0; i<pSeq->_size; i++){
        newArray[i] = pSeq->_a[i];
    }
    free(pSeq->_a);
    pSeq->_a = newArray;
    
}
void SeqPushBack(SeqList* pSeq, DataType x){
    assert(pSeq);
    ExpendIfRequired(pSeq);
    
    pSeq->_a[pSeq->_size] = x;
    pSeq->_size++;
}

void SeqPopBack(SeqList* pSeq){
    assert(pSeq);
    if(pSeq->_size == 0){
        printf("this SeqList is NULL\n");
        return;
    }
    pSeq->_size--;
}

void SeqPushFront(SeqList* pSeq, DataType x){
    assert(pSeq);
    ExpendIfRequired(pSeq);
    
    for(int i=(int)pSeq->_size; i>0; i--){
        pSeq->_a[i] = pSeq->_a[i-1];
    }
    pSeq->_a[0] = x;
    pSeq->_size++;
}
void SeqPopFront(SeqList* pSeq){
    assert(pSeq);
    
    for(int i=0; i<pSeq->_size-1; i++){
        pSeq->_a[i] = pSeq->_a[i+1];
    }
    pSeq->_size--;
}

void SeqInsert(SeqList* pSeq, size_t pos, DataType x){
    assert(pSeq);
    if(pos == 0){
        SeqPushFront(pSeq, x);
    }
    else if(pos == pSeq->_size){
        SeqPushBack(pSeq, x);
    }
    else{
        for(int i=(int)pSeq->_size; i>pos; i--){
            pSeq->_a[i] = pSeq->_a[i-1];
        }
        pSeq->_a[pos] = x;
        pSeq->_size++;
    }
}
void SeqErase(SeqList* pSeq, size_t pos){
    assert(pSeq);
    if(pos == 0){
        SeqPopFront(pSeq);
    }
    else if (pos == pSeq->_size){
        SeqPopBack(pSeq);
    }
    else{
        for(int i=(int)pos; i<pSeq->_size-1; i++){
            pSeq->_a[i] = pSeq->_a[i+1];
        }
        pSeq->_size--;
    }
}

int SeqFind(SeqList* pSeq, DataType x){
    assert(pSeq);
    if(pSeq->_size == 0){
        return -1;
    }
    for(int i=0; i<pSeq->_size; i++){
        if(x == pSeq->_a[i]){
            return i;
        }
    }
    return -1;
}
void SeqAt(SeqList* pSeq, size_t pos, DataType x)//修改
{
    assert(pSeq);
    if(pSeq->_size == 0 || pos >= pSeq->_size){
        printf("不合法\n");
        return;
    }
    pSeq->_a[pos] = x;
    
}

void Swap(int *n1, int * n2){
    int temp = *n1;
    *n1 = *n2;
    *n2 = temp;
}
//升序
void BubbleSort(SeqList* pSeq){
    assert(pSeq);
    for(int i=0; i<pSeq->_size-1; i++){
        for(int j=0; j<pSeq->_size-1-i; j++){
            if(pSeq->_a[j] > pSeq->_a[j+1]){
                Swap(pSeq->_a+j, pSeq->_a+j+1);
            }
        }
    }
}

void SelectSort(SeqList* pSeq){
    int max = 0;
    int min = 0;
    
    int left = 0;
    int right = (int)pSeq->_size-1;
    
    while(left < right){
        max = min = left;
        for(int i=left; i<=right; i++){
            if(pSeq->_a[i] > pSeq->_a[max]){
                max = i;
            }
            else if (pSeq->_a[i] < pSeq->_a[min]){
                min = i;
            }
        }
        Swap(pSeq->_a+min, pSeq->_a+left);
        if(max == left){
            max = min;
        }
        Swap(pSeq->_a+max, pSeq->_a+right);
        
        left++;
        right--;
        SeqPrint(pSeq);
    }
}

int Binary_Search(SeqList* pSeq, DataType x){
    assert(pSeq);
    int left = 0;
    int right = (int)pSeq->_size-1;
    while(left<=right){
        int mid = left+(right-left)/2;
        if(x == pSeq->_a[mid]){
            return mid;
        }
        else if(x > pSeq->_a[mid]){
            left = mid+1;
        }
        else{
            right = mid-1;
        }
        
    }
    return -1;
}
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值