顺序表增删查改，翻转，合并

此文章用于记录顺序表的知识

今天下午突发其想想知道自己还会不会顺序表，于是花了大概一个小时写了下面这段程序。欢迎交流讨论。

// 代码部分
//
//  gradation_link.c
//  test
//
//  Created by echo on 2020/5/20.
//  Copyright © 2020 echo. All rights reserved.
//

#include "gradation_link.h"
#include "stdlib.h"
#define MAXSIZE 20

typedef struct{
    int array[MAXSIZE];
    int length;
} Data;

Data List_A[60];
Data List_B[20];
Data List_C[20];

/*
 建立顺序表，成功返回1，失败返回0
 */
int Init_List(Data* List)
{
    List->length = 0;
    if (List->length == 0)
        return 1;
    else return 0;
}

/*
 清空表
 */
void Clear_List(Data* List)
{
    List->length = 0;
}

/*
 用随机函数生成顺序表元素值
 */
int Data_Source()
{
    int data = rand()%10;
    return data;
}

/*
 x为顺序表元素个数，例如x = 10代表顺序表中有十个元素
 */
int Get_Data(Data* List,int x)
{
    for(int i = 0;i < x;i++)
    {
        List->array[i] = Data_Source();
        //Data_Source（）为元素生成函数
        List->length ++;
    }
    if(List->length == x)
        return 1;
    else return 0;
}

void Locate_Value(int x)
{
    if (x != -1) {
        printf("the value is being,numbers is %d\n",x);
    }
    else
        printf("the value dont being\n");
}

/*
 检查时候含有输入到元素，如果有则返回元素下标，没有则返回-1；
 */
int Locate_List(Data* List, int x)
{
    for(int i = 0; i < List->length; i++)
    {
        if (List->array[i] == x)
            //检查元素值是否等于输入值x
            return i;
    }
    return -1;
}

/*
 删除输入x对应下标的元素
 */
int Dletle_List_Elem(Data* List, int x)
{
    int temp = 0;
    if (x > List->length)
        //如果输入值大于顺序表长度则返回0
        return 0;
    else
        for(int i = x+1;i < List->length ;i++)
            //从输入元素后一个开始遍历
        {
            temp = List->array[i];
            //临时存储后续下标元素值
            List->array[i-1] = temp;
            //后续下标替换前一下标元素值
        }
    List->length = List->length-1;
    //更改线性表长度
    return 1;
}

/*
 遍历输出顺序表元素
 */
int ListTraverse(Data* List)
{
    int i = 0;
    for(i = 0; i < List->length; i++)
    {
        printf("List->array[%d] = %d\n",i,List->array[i]);
    }
    if( i == List->length)
    //如果输入完成则返回1，否则返回0
    return 1;
    printf(" The funtion name is 'ListTraverse' for List->length Value is %d",i);
    return 0;
}

/*
 顺序表合并函数，List_B代表顺序表合并时_B在顺序表_C前面
 反之List_C同理
 */
void Union_List_B(Data* List_A,Data* List_B,Data* List_C)
{
    for (int i = 0;i<List_B->length;i++)
    {
        List_A->array[i] = List_B->array[i];
        //正常的赋值操作
        List_A->length ++;
    }
    for(int i = 0;i<List_C->length;i++)
    {
        List_A->array[i+List_B->length] = List_C->array[i];
        List_A->length ++;
        /*
         由于前面顺序表B以及插入顺序表A，因此在赋值时顺序表
         A应该跳过顺序表B的长度进行赋值。List_C函数同理
         */
    }
}

void Union_List_C(Data* List_A,Data* List_B,Data* List_C)
{
    for (int i = 0;i<List_C->length;i++)
    {
        List_A->array[i] = List_C->array[i];
        List_A->length ++;
    }
    for(int i = 0;i<List_B->length;i++)
    {
        List_A->array[i+List_C->length] = List_B->array[i];
        List_A->length ++;
    }
}
/*
 用于合并顺序表，参数List_A代表目标顺序表，参数List_B和List_C
 代表被合并的两个顺序表。
 */
int Union_List(Data* List_A,Data* List_B,Data* List_C,int x)
{
    if (sizeof(List_A->array)/4 < (List_B->length + List_C->length))
        //如果顺序表A的长度小于顺序表B和顺序表C的长度
        //则返回0表示合并失败
        return -1;
        if(x == 0)
            /*
             x为输入参数，用于表示合并顺序表时List_B在前面
             还是List_C在前面，当x == 0时代表顺序表B在
             前面
             */
            Union_List_B(List_A, List_B, List_C);
        else
            Union_List_C(List_A, List_B, List_C);
    if(List_A->length == (List_B->length+List_C->length))
        //合并成功A的长度等于B+C的长度返回1，反之返回0
        return 1;
    else return 0;
}

int Reversion_List(Data *List)
{
    int temp = 0;
    //printf("List_A->length is %d\n",List->length);
    for(int i = 0 ;i < (int)(List->length-List->length/2); i++)
    {
        temp = List->array[i];
        List->array[i] = List->array[List->length-i];
        List->array[List->length-i] = temp;
    }
    return 0;
}

/*
 返回值定位函数
 */
void Return_Value(int x)
{
    if(x == 1)
        printf("The funtion return is true\n");
    else
        printf("The funtion return is false,the return value is %d\n",x);
}

/*
 程序功能：
 顺序表的遍历
 顺序表的清空
 顺序表的创建
 顺序表的增删查改
 顺序表的合并
 顺序表的翻转
 */
int main()
{
    
    Data List[100]; //定义顺序表
   
    Return_Value( Init_List(List)); //建立顺序表
   
    Clear_List(List);//清空顺序表
    
    Return_Value(Get_Data(List, 10));//生成顺序表元素
    
     
    Return_Value(ListTraverse(List));//遍历顺序表
    
    Locate_Value((Locate_List(List, 9)));
    /*
     查找顺序表中元素，看是否有与输入的值相同的元素
     有则返回对应下标，没有则返回提示语句
     */
    Return_Value(Dletle_List_Elem(List, 3));
    /*
     输入值为要删除元素的对应下标
     */
    Return_Value(ListTraverse(List));
    /*
     元素删除后重新遍历顺序表
     */
    
    Return_Value(Get_Data(List_B, 5));
    //顺序表赋值
    Return_Value(Get_Data(List_C, 5));
    
    Return_Value(ListTraverse(List_B));
    //顺序表遍历
    Return_Value(ListTraverse(List_C));
    
    Return_Value(Union_List(List_A, List_B, List_C, 1));//顺序表合并
    
    Return_Value(ListTraverse(List_A));//顺序表遍历
    
    Reversion_List(List_A);//翻转顺序表
    
    ListTraverse(List_A);
    return 0;
}