顺序表的基本用法

顺序表的基本用法

1. 结构体定义（动态分配）

typedef int ElemType;       //元素类型，可自行定义,这里定义为int型，仅做区分

struct LIST {
    int lengh;              //当前顺序表长度
    int MaxSize;            //顺序表的最大长度
    ElemType *data;         //该顺序表的元素类型是int型(动态分配) };

2. 基本函数

这里使用了c++的bool类型和引用 文件名需要是.cc或者.cpp

//1.顺序表的初始化
void initList(LIST &list);
//2.增加顺序表的长度
void IncreaseSize(LIST &list,int len);
//3.顺序表的元素查找（按位查找）
bool GetElem(LIST list,int Index,ElemType &Value);
//4.顺序表的元素查找（按值查找）
bool LocateElem(LIST list,int &Index,ElemType Value);
//5.顺序表的元素插入
bool ListInset(LIST &list,int Index,ElemType value);
//6.顺序表的元素删除
bool ListDelete(LIST &list,int Index,ElemType &value);
//7.顺序表的打印
void ListPrint(LIST list);
//8.顺序表的表长
int ListLength(LIST list);
//9.顺序表的销毁
void DestoryList(LIST &list);

3. 完整代码

list.h

#ifndef __LIST_H__
#define __LIST_H__

#include<stdio.h>
#include<stdlib.h>          //malloc使用的头文件

#define InitSize 10

//判空
#define NULLPOINTER_CHECK_RT_NONE(pointer)\
{\
    if (NULL == (pointer))\
    {\
        printf("Pointer is NULL!");\
        return;\
    }\
}

typedef int ElemType;       //元素类型，可自行定义,这里定义为int型，仅做区分

struct LIST
{
    int lengh;              //当前顺序表长度
    int MaxSize;            //顺序表的最大长度
    ElemType *data;         //该顺序表的元素类型是int型(动态分配)
};

//1.顺序表的初始化
void initList(LIST &list);
//2.增加顺序表的长度
void IncreaseSize(LIST &list,int len);
//3.顺序表的元素查找（按位查找）
bool GetElem(LIST list,int Index,ElemType &Value);
//4.顺序表的元素查找（按值查找）
bool LocateElem(LIST list,int &Index,ElemType Value);
//5.顺序表的元素插入
bool ListInset(LIST &list,int Index,ElemType value);
//6.顺序表的元素删除
bool ListDelete(LIST &list,int Index,ElemType &value);
//7.顺序表的打印
void ListPrint(LIST list);
//8.顺序表的表长
int ListLength(LIST list);
//9.顺序表的销毁
void DestoryList(LIST &list);
#endif

list.cc

#include "list.h"

// 1.顺序表的初始化
void initList(LIST &list)
{
    list.data = (ElemType *)malloc(sizeof(ElemType) * InitSize);
    NULLPOINTER_CHECK_RT_NONE(list.data);
    list.lengh = 0;
    list.MaxSize = InitSize;
}

// 2.增加顺序表的长度
void IncreaseSize(LIST &list, int len)
{
    // p是局部变量，函数结束后，自动释放
    ElemType *p = list.data;
    list.data = (ElemType *)malloc(sizeof(ElemType) * (len + list.MaxSize));
    NULLPOINTER_CHECK_RT_NONE(list.data);
    for (int i = 0; i < list.lengh; i++) // 把原来内存的数据拷贝到新申请的内存中
    {
        list.data[i] = p[i];
    }
    list.MaxSize += len; // 修改最大值
    free(p);             // 释放原先申请的内存
}

// 3.顺序表的元素查找（按位查找）
bool GetElem(LIST list, int Index, ElemType &Value)
{
    if (Index < 1 || Index > list.lengh)
        return false;
    Value = list.data[Index - 1];
    return true;
}

// 4.顺序表的元素查找（按值查找）
bool LocateElem(LIST list, int &Index, ElemType Value)
{
    for (int i = 0; i < list.lengh; i++) // 遍历
    {
        if (Value == list.data[i])
        {
            Index = i + 1; // i是数组下标，返回位次要+1
            return true;
        }
    }
    return false;
}

// 5.顺序表的元素插入
bool ListInset(LIST &list, int Index, ElemType value)
{
    if (Index < 1 || Index > list.lengh+1) // Index 不合法
        return false;
    if (list.lengh == list.MaxSize) // 顺序表满了
        return false;
    for (int i = list.lengh; i >= Index; i--) // 插入序列后面的数往后移
    {
        list.data[i] = list.data[i - 1];
    }
    list.data[Index - 1] = value; // 放入值
    list.lengh++;                 // 顺序表的长度+1
    return true;
}

// 6.顺序表的元素删除
bool ListDelete(LIST &list, int Index, ElemType &value)
{
    if (Index < 1 || Index > list.lengh) // Index 不合法
        return false;
    value = list.data[Index - 1];
    for (int i = Index; i < list.lengh-1; i++)// 删除序列后面的数往前移
    {
        list.data[i-1] = list.data[i]; 
    }
    list.lengh--;// 顺序表的长度-1
    return true;
}

//7.顺序表的打印
void ListPrint(LIST list)
{
    if(list.lengh == 0)
        printf("NULL!");
    for(int i = 0;i<list.lengh;i++)
    {
        printf("%d ",list.data[i]);
    }
    printf("\n");
}

//8.顺序表的表长
int ListLength(LIST list)
{
    return list.lengh;
}

//9.顺序表的销毁
void DestoryList(LIST &list)
{
    list.lengh = 0;
    list.MaxSize = 0;
    free(list.data);
}