顺序表(数据结构)

本篇文章主要针对《数据结构》中的顺序表的增删查改以及一些常用算法进行详尽的代码描述。本代码使用c语言书写，并且通过测试。可以直接拷贝编译，在你的main函数中进行测试。

#include <stdio.h>
#include <stdlib.h>
#define MaxSize 50  //顺序表的表长
#define InitSize 100 //顺序表的初始表长

typedef struct {
    int data[MaxSize];  //顺序表的元素
    int length;         //顺序表的长度
}SqList;              //顺序表的类型定义

typedef struct{
    int *data;          //指示动态分配的数组指针
    int dataSize,length; //数组的最大容量和当前储存元素的个数
}mSqList;

/*
 * [InitList 顺序表初始化函数]
 * @param  L [传入需要初始化的顺序表]
 * @return   [成功初始化返回 1]
 */
int InitList(mSqList *L,int size){
    for (int i = 0; i < size; i++) {
        L->data[i] = rand()%1000;
    }
    L->dataSize = InitSize;
    L->length = size;
    return 1;
}

/**
 * [Length 计算表长]
 * @param  L [传入需要计算长度的顺序表]
 * @return   [返回表长]
 */
int Length(mSqList L){
    return L.length;
}

/**
 * [LocateElem 查找元素e所在的位置]
 * @param  L [传入需要查找的顺序表]
 * @param  e [需要查找的元素e]
 * @return   [成功查找返回元素的位置，查找失败返回-1]
 */
int LocateElem(mSqList L,int e){
    for(int i = 0; i < L.length; i++)
    {
        if(L.data[i] == e)
        {
            return i+1;
        }
    }
    return -1;
}

/**
 * [GetElem 按位置查找元素]
 * @param  L        [传入需要查找的顺序表]
 * @param  position [传入需要查找的位置position]
 * @return          [查找成功返回查找元素，查找失败返回-1]
 */
int GetElem(mSqList L,int position){
    if (position <= 0 || position > L.length)
    {
        return -1;
    }
    return L.data[position - 1];
}

/**
 * [ListInsert 向线性表对应位置i插入元素e]
 * @param  L [需要插入的顺序表]
 * @param  i [元素插入的位置]
 * @param  e [插入的元素]
 * @return   [成功返回 1，插入失败返回-1]
 */
int ListInsert(mSqList *L,int i,int e){
    if (i < 1 | i > L->length + 1)
    {
        return -1;
    }
    if (L->length >= L->dataSize)
    {
        return -1;
    }
    for (int j = L->length; j >= i; j--)
    {
        L->data[j] = L->data[j-1];
    }
    L->data[i-1] = e;
    L->length++;
    return 1;
}

/**
 * [ListDelete 删除顺序表中位置i的元素]
 * @param  L [待删除的顺序表]
 * @param  i [待删除元素的位置]
 * @return   [成功返回删除元素的值 e，失败返回 -1]
 */

int ListDelete(mSqList *L,int i)
{
    int e = 0;
    if (i < 1 || i > L->length)
    {
        return -1;
    }
    e = L->data[i-1];
    for (int j = i; j < L->length; j++)
    {
        L->data[j-1] = L->data[j];
    }
    L->length--;
    return e;
}

/**
 * [ListMinDelete 删除顺序表中最小的元素]
 * @param  L [待删除的顺序表]
 * @return   [成功返回删除的元素 e，失败返回 -1]
 */
int ListMinDelete(mSqList *L)
{
    int tmp = L->data[0];
    int position = 0;
    if(L->length < 1)
    {
        return -1;
    }
    for (int i = 0; i < L->length; i++)
    {
        if(tmp > L->data[i])
        {
            tmp = L->data[i];
            position = i;
        }
    }
    L->data[position] = L->data[L->length-1];
    L->length--;
    return tmp;
}

/**
 * [ListReverse 将顺序表原地逆置]
 * @param  L [需要逆置的顺序表]
 * @return   [成功返回 1，失败返回 -1]
 */
int ListReverse(mSqList *L)
{
    int tmp = 0;
    if(L->length <= 0)
    {
        return -1;
    }
    for(int i = 0; i < L->length / 2; i++)
    {
        tmp = L->data[i];
        L->data[i] = L->data[L->length - i - 1];
        L->data[L->length - i - 1] = tmp;
    }
    return 1;
}

/**
 * [ListElemDelete 删除顺序表中所有相同的元素]
 * @param  L [待删除的顺序表]
 * @param  x [待删除的元素 x]
 * @return   [成功删除反回删除后顺序表的长度 length，失败则返回 -1]
 */

int ListElemDelete(mSqList *L,int x)
{
    int k = 0;
    int delNUm = 0;
    if(L->length <= 0)
    {
        return -1;
    }
    for (int i = 0; i < L->length; i++)
    {
        if(L->data[i] != x)
        {
            L->data[k] = L->data[i];
            k++;
        }
    }
    delNUm = L->length - k;
    L->length = k;
    return delNUm;
}

/**
 * [ListRangeDelete 删除顺序表中在start 和 stop 范围内的 元素]
 * @param  L     [待删除的顺序表]
 * @param  start [删除值范围的最小值]
 * @param  stop  [删除值范围的最大值]
 * @return       [成功返回以删除的元素个数，失败返回-1]
 */
int ListRangeDelete(mSqList *L,int start,int stop)
{
    int k = 0;
    int delNUm = 0;
    if (start > stop)
    {
        return -1;
    }
    if (L->length <= 0)
    {
        return -1;
    }
    for (int i = 0; i < L->length; i++)
    {
        if(L->data[i] < start || L->data[i] > stop)
        {
            L->data[k] = L->data[i];
            k++;
        }
    }
    delNUm = L->length - k;
    L->length = k;
    return delNUm;
}

/**
 * [ListDumpDelete 删除有序的顺序表中含重复元素的项]
 * @param  L [待删除的有序顺序表]
 * @return   [成功返回删除返回删除元素个数，失败返回 -1]
 */
int ListDumpDelete(mSqList *L)
{
    int k = 0;
    int len = 0;
    if(L->length <=0 )
    {
        return -1;
    }
    for (int i = 1; i < L->length; i++)
    {
        if (L->data[k] != L->data[i])
        {
            L->data[++k] = L->data[j];
        }
    }
    len = L->length - k - 1;
    L->length = k + 1;
    return len;
}

/**
 * [ListBindSorted 将两个有序表进行合并，并且将合并后的有序表返回]
 * @param  L1 [待合并的有序表L1]
 * @param  L2 [待合并的有序表L2]
 * @param  L3 [合并后的有序表L3]
 * @return    [成功返回 1，失败返回 -1]
 */
int ListBindSorted(mSqList *L1, mSqList *L2, mSqList *L3)
{
    if (L1->length + L2->length > L3->dataSize)
    {
        return -1;
    }
    int i = 0;
    int j = 0;
    int k = 0;
    while(i < L1->Length && j < L2->length)
    {
        if (L1->data[i] < L2->data[j])
        {
            L3->data[k++] = L1->data[i++];
        }else {
            L3->data[k++] = L2->data[j++];
        }
    }
    while(i < L1->length)
    {
        L3->data[k++] = L1->data[i++];
    }
    while(j < L2->length)
    {
        L3->data[k++] = L2->data[j++];
    }
    L3->length = k;
    return 1;
}