C语言实现线性表（顺序存储结构）

linearTable.h

#pragma once
//线性表的实现
#define MAXSIZE 20
#define OK           -1
#define ERROR     -2

typedef struct list {
	int data[MAXSIZE];                       //数组存储
	int len;                                          //线性表长度
}LIST_T;

//线性表初始化
void initList(LIST_T *list);

//根据下表查询数据
int getElem(LIST_T *list, int i);

//根据数据查找下标
int getId(LIST_T *list, int e);

//获取线性表长度
int getLen(LIST_T *list);

//头插法
int addToHead(LIST_T *list, int e);

//尾插法
int addToTail(LIST_T *list, int e);

//指定位置插入
int addSpecific(LIST_T* list, int i, int e);

//删除指定下标元素
int delElembyId(LIST_T *list, int i);

//删除指定元素
int delElem(LIST_T *list, int e);

//清空线性表
void clearList(LIST_T *list);

//打印信息
void show(LIST_T *list);

linearTable.c

#include "linearTable.h"
#include <stdio.h>
//线性表初始化
void initList(LIST_T* list)
{
	for (int i = 0; i < MAXSIZE; ++i)
	{
		list->data[i] = 0;
	}
	list->len = 0;
}

//根据下表查询数据
int getElem(LIST_T* list, int i)
{
	if (i<0 || i>MAXSIZE || i > list->len)
	{
		return ERROR;
	}
	return list->data[i];
}

//根据数据查找下标
int getId(LIST_T* list, int e)
{
	for (int i = 0; i < list->len; ++i)
	{
		if (e == list->data[i])
		{
			return i;
		}
	}
	return ERROR;
}

//获取线性表长度
int getLen(LIST_T* list)
{
	return list->len;
}

//头插法
int addToHead(LIST_T* list, int e)
{
	if (list->len < MAXSIZE)
	{
		for (int i = list->len; i >=0; --i)
		{
			list->data[i] = list->data[i-1];
		}
		list->data[0] = e;
		list->len += 1;
		return OK;
	}
	return ERROR;
}

//尾插法
int addToTail(LIST_T* list, int e)
{
	if (list->len < MAXSIZE)
	{
		list->data[list->len] = e;
		list->len += 1;
		return OK;
	}
	return ERROR;
}

//指定位置插入
int addSpecific(LIST_T* list, int i, int e)
{
	if (i<0 || i>MAXSIZE || i > list->len)
	{
		return ERROR;
	}
	for (int count = list->len; count >= i; --count)
	{
		list->data[count] = list->data[count - 1];
	}
	list->data[i] = e;
	++list->len;
	return OK;
}

//删除指定下标元素
int delElembyId(LIST_T* list, int i)
{
	if (i<0 || i>MAXSIZE || i > list->len)
	{
		return ERROR;
	}
	for (int count = i; count < list->len; ++count)
	{
		list->data[count-1] = list->data[count];
	}
	--list->len;
	return OK;
}

//删除指定元素
int delElem(LIST_T* list, int e)
{
	for (int count = 0; count < list->len; ++count)
	{
		if (list->data[count] == e)
		{
			for (int i = count; i < list->len; ++i)
			{
				list->data[i] = list->data[i+1];
			}
			--list->len;
			break;
		}
	}
	return OK;
}

//清空线性表
void clearList(LIST_T* list)
{
	for (int i = 0; i < list->len; ++i)
	{
		list->data[i] = 0;
	}
	list->len = 0;
	return OK;
}

//打印信息
void show(LIST_T* list)
{
	for (int i = 0; i < list->len; ++i)
	{
		printf("NO%d:%d\n",i,list->data[i]);
	}
	printf("\n");
}

线性链表的c语言实现代码具体如下

#include <malloc.h>
#include <stdio.h>
#include <stdlib.h>
//函数结果状态码
#define OK 1
#define ERROR 0
#define false 0
#define true 1
#define INFEASIBLE -3

struct LNode
{
    int data;
    struct LNode *next;
} * LinkList;
//初始化链表
LNode *InitList(int n)
{

    LNode *p, *head;
    LinkList = head = (LNode *)malloc(sizeof(LNode));
    for (int i = 0; i < n; i++)
    {
        p = (LNode *)malloc(sizeof(LNode));
        printf("please input %dth number:", i + 1);
        scanf("%d", &p->data);
        LinkList->next = p;
        LinkList = p;
    }
    LinkList->next = NULL;
    return head;
}
//销毁一个已经存在的链表
int DestroyList(LNode *L)
{
    LNode *q;
    while (q)
    {
        q = L->next;
        free(L);
        L = q;
    }
    return 100;
}
//置空一个链表
void ClearList(LNode *L)
{
    LNode *p, *q;
    p = L->next;
    while (p)
    {
        q = p->next;
        free(p);
        p = q;
    }
    L->next = NULL;
}
//判断链表是否为空
int ListEmpty(LNode *L)
{
    if (L->next)
        return false;
    else
        return true;
}
//判断链表长度
int ListLength(LNode *L)
{
    int i = 0;
    LNode *p = L->next;
    while (p)
    {
        i++;
        p = p->next;
    }
    return i;
}
//用e返回指定顺序为i的值
int GetElem(LNode *L, int i, int e)
{
    LNode *p = L;
    int j = 1;
    while (p->next && j < i - 1)
    {
        p = p->next;
        j++;
    }
    if (!p || j > i)
    {
        printf("error\n");
    }
    e = p->data;
    return e;
}
//给定元素返回元素在链表中的位置
int LocatElem(LNode *L,int e)
{
    int i = 0;
    LNode *p = L->next;
    while(p)
    {
        i++;
        if(p->data==e)
        {
            return i;
        }
        p = p->next;
    }
    return 0;
}
//给定当前元素返回前一个元素
int PriorElem(LNode *L,int cur_e)
{
    int pri_e;
    LNode *q, *p = L->next;
    while(p->next)
    {
        q = p->next;
        if(q->data==cur_e)
        {
            pri_e = p->data;
            return pri_e;
        }
        p = q;
    }
    return INFEASIBLE;
}
//给定当前元素返回后一个元素
int NextElem(LNode *L,int cur_e)
{
    int next_e;
    LNode *p = L->next;
    while(p->next)
    {
        if(p->data==cur_e)
        {
            next_e = p->next->data;
            return next_e;
        }
        p = p->next;

    }
    return INFEASIBLE;
}
//在指定位序前插入数据e
int ListInsert(LNode *L, int i, int e)
{
    int j = 0;
    LNode *s;
    LNode *p = L;
    while (p && j < i - 1)
    {
        p = p->next;
        j++;
    }
    if (!p || j > i - 1)
        printf("error\n");
    s = (LNode *)malloc(sizeof(LNode));
    s->data = e;
    s->next = p->next;
    p->next = s;
    return OK;
}
//指定位置为i删除数据并用e返回
int ListDelete(LNode *L, int i, int e)
{
    int j = 0;
    LNode *q;
    LNode *p = L;
    while (p->next && j < i - 1)
    {
        p = p->next;
        j++;
    }
    if (!p->next || j > i - 1)
    {
        return ERROR;
    }
    q = p->next;
    p->next = q->next;
    e = q->data;
    free(q);
    return e;
}
//输出链表数据
void ListTraverse(LNode *L)
{
    LNode *p = L->next;
    printf("the list is :");
    while (p)
    {
        printf("%d  ", p->data);
        p = p->next;
    }
    printf("\n");
}

int main()
{
    LNode *L = InitList(6);
    int e = 0;
    ListTraverse(L);
    printf("the length of list is:%d\n", ListLength(L));
    ListInsert(L, 2, 88);
    printf("after insert 88 the result is:\n");
    ListTraverse(L);
    int DeleNum = ListDelete(L, 1, e);
    printf("after delete the %dth number\nthe result is:", DeleNum);
    ListTraverse(L);
    int GetNum = GetElem(L, 5, e);
    printf("the num is: %d\n", GetNum);
    printf("the 6 is the %dth number in the list\n", LocatElem(L, 6));
    printf("the number prior 4 is:%d(-3:not exit)\n",PriorElem(L, 4));
    printf("the number next 5 is:%d\n",NextElem(L, 5));
    if (DestroyList(L) == 100)
        printf("the list is destroyed\n");
    system("pause");
}

结果如下：

注意事项：
1、在严蔚敏的数据结构（C语言版）这本书种：初始化一个空表是用 int InitList_Sq(SqList &L)表示。我们特别要注意，引用类型可以将形参变量带回主函数，但是这是C++支持的，C语言时不支持的，所有我在写的时候也掉到这个坑里面去了，代码改了好久才发现一直有问题出在哪里。
具体的说明可以看博客：
c++引用类型–将形参变量值带回主函数
2、在程序种有很多地方用到.和->,这两个的区别就是->前面是指向结构体的指针变量，而.前面需要时结构体变量
具体可以见：c语言中.与->的区别