线性表——顺序存储结构

一）声明

　　新手上路。如果有不对的，不合理的地方，编码风格，算法思路有待改进的地方，还请各位大神多多指点。

二）简介　　

　　本文中采用动态开辟内存的方法建立线性表，实现顺序表的基本操作。

　　此代码思路比较简单，毕竟只是简单的原理，没有具体的应用，仅仅作为入门学习的积累。

三）具体实现分析如下：

　3.1）头文件定义如下：

#ifndef LinearList_SqList_h
#define LinearList_SqList_h

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

#define OK 1
#define ERROR 0

#define LIST_INIT_SIZE 100
#define SIZE_INCREMENT 10

typedef int Status;
typedef int ElemType;

typedef struct {
    ElemType *pElem;
    int nLength;
    int nListSize;
}SqList;


void InitSqList(SqList *L);
Status InsertSqList(SqList *L, int nIndex, ElemType eValue);
Status AssignSqList(SqList *L);
Status DeleteSqList(SqList *L, int nIndex, ElemType *pValue);
Status ClearSqList(SqList *L);
Status DestroySqList(SqList *L);
Status LocateElem(SqList L, ElemType nValue);
Status PrintSqList(SqList L);

#endif

　3.2）具体实现：

　　3.2.1）基本原则：

　　　　a）函数参数中，只要传递的是指针，函数内必须首先校验指针是否为空。

　　　　b）如果要对顺序表进行修改，那么必须进行地址传递，而不是值传递。

　　　　c）malloc申请的内存，一定要用free释放，并且释放之后，置指针为空，防止出现也指针。

　　3.2.2）具体代码思路：

　　a、InitSqList

　　动态申请空间，依此对顺序表的成员赋值。

　　b、InsertSqList （此处允许对空表进行插入）

　　思路：校验指针参数——》校验插入点——》校验顺序表是否已初始化——》校验顺序表是否已满——》遍历顺序表，找到插入点——》移动元素——》插入——》同时表长增加；

　　分析：其实真正的插入就是一行代码，但是为了保证插入后不影响其他元素的使用，必须移动元素；为了保证程序的健壮性，必须增加很多校验过程；

　　　　　　重点在于下标的计算。

　　　　2.1参数校验：指针是否为空；插入点是否非法

　　　　2.2顺序表校验：顺序表是否已初始化；对于插入而言，顺序表是否已满；

　　　　2.3当所有的校验完毕之后，寻找正确插入点，移动元素（从表尾向待插入点方向遍历），最后插入，增加表长；

　　　　（2.4）关于空表是否允许插入的问题：根据不同的需求和功能设定。如果不允许对空表插入，可以多加一层校验功能即可；（此处允许空表插入）

 

　　c、DeleteSqList （基本原理类似于Insert）

　　　思路：校验指针参数——》校验删除点——》校验顺序表是否初始化——》校验顺序表是否为空——》遍历顺序表，寻找删除点——》移动元素——》删除——》同时表长自减；

　　　　分析：删除元素就是不断的移动元素，采用覆盖原理即可（从删除点向表尾方向遍历）。关键是下标的计算。

 

　　d、DestroySqList

　　　　思路：校验指针参数——》校验顺序表是否初始化——》释放申请的内存——》同时设置顺序表相关参数。

　　　　分析：重点在于参数的校验和free过后的指针应该置空。

 

　　3.3）具体代码如下：

　　

#include "SqList.h"

void InitSqList(SqList *L) {
    if (NULL == L) {
        printf("Error parament.");
        return ;
    }
    
    L->pElem = (ElemType*)malloc(LIST_INIT_SIZE * sizeof(SqList));
    if (NULL == L->pElem) {
        printf("Error:Out of memory.");
        return ;
    }
    
    L->nLength = 0;
    L->nListSize = LIST_INIT_SIZE;
}


//Insert element to sqlist
Status InsertSqList(SqList *L, int nIndex, ElemType eValue) {
    if (NULL == L) {
        printf("Error parament.");
        return ERROR;
    }
    
    if (NULL == L->pElem) {
        printf("Error: The list is not initiated.");
        return ERROR;
    }
    
    if (nIndex < 1 || nIndex > L->nLength + 1) {
        printf("Error: Invalid insert point.");
        return ERROR;
    }
    
    ElemType *pNewBase;
    if (L->nLength >= L->nListSize) {
        pNewBase = (ElemType*)realloc(L->pElem, (LIST_INIT_SIZE + SIZE_INCREMENT) * sizeof(ElemType));
        if (NULL == pNewBase) {
            printf("Error:Out of memory.");
            return OK;
        }
        //here can also write with 'else'.
        //Logically no problem. But it takes effort to write the else and '{}'. Efficiently not good choice
        L->pElem = pNewBase;
        L->nListSize += SIZE_INCREMENT;
    }
    
    ElemType *pInsert, *pLast;
    pInsert = L->pElem + nIndex - 1;
    pLast = L->pElem + L->nLength - 1;
    
    
    while (pLast >= pInsert) {
        *(pLast + 1) = *pLast;
        pLast--;
    }
    
    *pInsert = eValue;
    ++L->nLength;
    
    return OK;
}

//Assign sqlist
Status AssignSqList(SqList *L) {
    if (NULL == L) {
        printf("Error parament.");
        return ERROR;
    }
    
    if (NULL == L->pElem) {
        printf("Error:The list is not initiated.");
        return ERROR;
    }
    
    int nLength, nValue;
    printf("Input the length:");
    scanf("%d", &nLength);
    
    for (int i = 1; i <= nLength; i++) {
        printf("Input the value:");
        scanf("%d", &nValue);
        
        InsertSqList(L, i, nValue);
    }
    
    return OK;
}

//delete element from sqlist
Status DeleteSqList(SqList *L, int nIndex, ElemType *pValue) {
    if (NULL == L || NULL == pValue) {
        printf("Error parament.");
        return ERROR;
    }
    
    if (NULL == L->pElem) {
        printf("Error:The list is not initiated.");
        return ERROR;
    }
    
    if (L->nLength <= 0) {
        printf("Error:The list is empty.Can't delete.");
        return ERROR;
    }
    
    if (nIndex < 1 || nIndex > L->nLength) {
        printf("Error:Invalid delete index.");
        return ERROR;
    }
    
    ElemType *pDelete, *pLast;
    pDelete = L->pElem + nIndex - 1;
    pLast = L->pElem + L->nLength - 1;
    
    *pValue = *pDelete;
    for (pDelete++; pDelete <= pLast; pDelete++) {
        *(pDelete - 1) = *pDelete;
    }
    
    --L->nLength;
    
    return OK;
}

//clear sqlist
Status ClearSqList(SqList *L) {
    if (NULL == L) {
        printf("Error parament.");
        return ERROR;
    }
    
    if (NULL == L->pElem) {
        printf("Error: The list is not initiated.");
        return ERROR;
    }
    
    L->nLength = 0;
    
    return OK;
}

//destroy sqlist
Status DestroySqList(SqList *L) {
    if (NULL == L) {
        printf("Error parament.");
        return ERROR;
    }
    
    if (NULL == L->pElem) {
        printf("Error:The list is not initiated.");
        return ERROR;
    }
    
    free(L->pElem);
    L->pElem = NULL;
    L->nLength = 0;
    L->nListSize = 0;
    
    return OK;
}

//locate element from sqlist
Status LocateElem(SqList L, ElemType nValue) {
    if (NULL == L.pElem) {
        printf("Error:The list is not initiated.");
        return ERROR;
    }
    
    if (L.nLength <= 0) {
        printf("Error:The list is empty.");
        return ERROR;
    }
    
    int nIndex;
    ElemType *pLocate = L.pElem;
    
    for (nIndex = 1; nIndex <= L.nLength; nIndex++) {
        if (nValue == *pLocate) {
            printf("Located succeeded.");
            return nIndex;
        }
        pLocate++;
    }
    
    return ERROR;
}


//Print sqlist
Status PrintSqList(SqList L) {
    if (NULL == L.pElem) {
        printf("Error:The list is not initiated.");
        return ERROR;
    }
    
    if (L.nLength <= 0) {
        printf("The list is empty.");
        return ERROR;
    }
    
    printf("The list is as follows:");
    for (int i = 1; i <= L.nLength; i++) {
        printf("%d ", *L.pElem);
        L.pElem++;
    }
    
    printf("
");
    return OK;
}