01_线性表的顺序存储结构

这个顺序链表中申请的空间存放的只是指针。

/*
*seqList.h
*/
#pragma once

#ifndef _SEQLIST_H_
#define _SEQLIST_H_

#include <iostream>
#include <malloc.h>
using namespace std;

//typedef unsigned int SeqListNode;
using SeqListNode = unsigned int ;
struct SeqList {
    int capacity;
    int length;
    SeqListNode * next;
};


class seqList {
    public:
        seqList();
        ~seqList();
        SeqList* SeqList_Create(int capacity);
        void SeqList_Destroy(SeqList* list);
        void SeqList_Clear(SeqList* list);
        int SeqList_Length(SeqList* list);
        int SeqList_Capacity(SeqList* list);
        int SeqList_Insert(SeqList* list, SeqListNode* node, int pos);
        SeqListNode* SeqList_Get(SeqList* list, int pos);
        SeqListNode* SeqList_Delete(SeqList* list, int pos);
};
#endif

/*
*seqList.c
*/
#include "seqList.h"

seqList::seqList(){
}
seqList::~seqList(){
}

SeqList * seqList::SeqList_Create(int capacity){ //o(1)

    SeqList *ret = nullptr ;
    if( capacity>0 ) {
        ret = (SeqList*)malloc( sizeof(SeqList)+capacity*sizeof(SeqListNode*) );
    }
    if ( ret!=nullptr ) {
        ret->capacity = capacity;
        ret->length = 0;
        ret->next = (SeqListNode*)(ret + 1);
    }
    return ret ;
}

void seqList::SeqList_Destroy(SeqList * list) { //o(1)

    if ( list!=nullptr ) {
        free( list );
        list = nullptr;
    }
}

void seqList::SeqList_Clear(SeqList * list) {//o(1)

    if ( nullptr!=list ) {
        list->length = 0;
        //这个要不要无所谓
        //list->next = (SeqListNode *)(list + 1);
    }
}

int seqList::SeqList_Length(SeqList * list) {o(1)

    int ret = -1;
    if ( nullptr!=list ) {
        ret = list->length;
    }
    return ret;
}

int seqList::SeqList_Capacity(SeqList * list) {o(1)

    int ret = -1;
    if ( nullptr!=list ) {
        ret = list->capacity;
    }
    return ret;
}

int seqList::SeqList_Insert(SeqList * list, SeqListNode * node, int pos) {//o(n)

    int ret = -1;
    int i = 0;
    ret = (list!=nullptr) && (pos>=0 );
    ret = ret && ( list->length+1<=list->capacity);
    if ( ret ) {
        if ( pos>=list->length ) {
            pos = list->length;
        }
        for (int i = list->length; i > pos; --i) {
            list->next[i] = list->next[i - 1];
        }
        //这个申请的空间是存放指针的，所以要把传进来的地址抢转。
        list->next[i] = (SeqListNode)node;
        ++list->length;
    }
    return ret;
}

SeqListNode* seqList::SeqList_Get(SeqList * list, int pos) {//o(1)

    SeqListNode *ret = nullptr;
    if ( (list!=nullptr)&&(pos>=0)&&(pos<list->length) ) {
        //这里申请的空间存放的内容是地址，但是其声明的类型是无符号整形，不是指针类型，所以要强转通知编译器这是地址。
        ret = (SeqListNode*)list->next[pos];
    }
    return ret ;
}

SeqListNode * seqList::SeqList_Delete(SeqList * list, int pos) {//o(n)

    SeqListNode* ret = SeqList_Get(list,pos) ;
    if ( ret != nullptr ) {
        for (int i = pos + 1; i < list->length; ++i ) {
            list->next[i - 1] = list->next[i];
        }
        --list->length ;
    }
    return ret;
}

/*
*main.c
*/
#include "seqList.h"

int main( int argc , char **argv ) {

    seqList chen;
    SeqList* list = chen.SeqList_Create(5);

    SeqListNode i = 0;
    SeqListNode j = 1;
    SeqListNode k = 2;
    SeqListNode x = 3;
    SeqListNode y = 4;
    SeqListNode z = 5;
    int index = 0;

    chen.SeqList_Insert(list, &i, 0);
    chen.SeqList_Insert(list, &j, 0);
    chen.SeqList_Insert(list, &k, 0);
    chen.SeqList_Insert(list, &x, 0);
    chen.SeqList_Insert(list, &y, 0);
    chen.SeqList_Insert(list, &z, 0);

    for (index = 0; index<chen.SeqList_Length(list); index++)
    {
        int* p = (int*)chen.SeqList_Get(list, index);

        printf("%d\n", *p);
    }

    printf("\n");

    while (chen.SeqList_Length(list) > 0)
    {
        int* p = (int*)chen.SeqList_Delete(list, 0);

        printf("%d\n", *p);
    }

    chen.SeqList_Destroy(list);

    return 0;
}