线性表（顺序表和链表的基本操作代码实现）

顺序表

分为可动态增加长度和静态长度

查找方便，增删要移动大量元素

#include<cstdio>
#include<cstdlib>
typedef int elemtype;
#define max 50
#define Initsize 20
/*顺序表
typedef struct {
	elemtype data[max];
	int lenth;
}SqList;

void InitList(SqList& L)
{
	for (int i = 0; i < max; i++)
		L.data[i] = 0;
	L.lenth = 0;
}*/
//可动态增加长度

typedef struct {
	elemtype *data;
	int lenth,maxsize;//顺序表当前长度，顺序表最大容量
}SqList;

void InitList(SqList& L)
{
	L.data = (elemtype*)malloc(Initsize * sizeof(elemtype));
	for (int i = 0; i < Initsize; i++)
		L.data[i] = 0;
	L.lenth = 0;
	L.maxsize = Initsize;
}

void increaseSize(SqList& L, int len) {
	elemtype*p= L.data;
	L.data = (elemtype*)malloc(Initsize * sizeof(elemtype));
	for (int i = 0; i < L.lenth; i++)
		L.data[i] = p[i];
	L.maxsize = L.maxsize + len;
	free(p);
}

bool ListInsert(SqList& L, int i, elemtype e)
{
	if (i < 1 || i>L.lenth + 1)//越界
		return false;
	if (L.lenth >= max)//超过内存
		return false;
	for (int j = L.lenth; j >= i; j--)//元素后移
		L.data[j] = L.data[j - 1];
	L.lenth++;
	return true;
}
void PrintList(SqList& L) {
	for (int i = 0; i < L.lenth; i++) {
		printf("%4d", L.data[i]);
	}
	printf("\n");
}

int GetElem(SqList L, int i) {//查找第i个位置元素
	return L.data[i - 1];
}
int LocateElem(SqList L, int e)//按值查找
{
	int i;
	for (i = 0; i < L.lenth; i++)
		if (L.data[i] == e)
			return i + 1;
	return 0;//查找失败
}
bool ListDelete(SqList& L, int i, int& e) {//删除第i个元素
	if (i<1 || i>L.lenth) return false;
	e = L.data[i - 1];
	for (int j = i; j < L.lenth; j++)
		L.data[j - 1] = L.data[j];
	L.lenth--;
	return true;
}

int main()
{
	SqList L;
	bool ret;
	elemtype del;
	InitList(L);
	//赋值
	L.data[0] = 1;
	L.data[1] = 2;
	L.data[2] = 3;
	L.lenth = 3;
	ret = ListInsert(L, 2, 60);//第二个位置插入60
	if (ret) {
		printf("ok\n");
		PrintList(L);
	}
	else {
		printf("error\n");
		PrintList(L);
	}
	//查找
	int locate = LocateElem(L, 2);//查找元素2的位置
	printf("该元素在第%d个位置\n", locate);

	int number = GetElem(L, 1);//查找第一个位置元素值
	printf("查找的第一个元素值%d\n", number);
	int e = -1;//带回删除的值
	ret = ListDelete(L, 1, e);//删除第一个位置
	if (ret) {
		printf("ok\n");
		PrintList(L);
	}
	else {
		printf("error\n");
		PrintList(L);
	}
	return 0;
}

链表（动态链表）静态链表略

查找要从头遍历，增加删除方便还可动态修改长度

分为带头节点和不带头节点

不带头节点主要是创建，添加，删除第一个节点时有差异

//带头结点单链表
#include<cstdio>
#include<cstdlib>

typedef int elemtype;

typedef struct LNode {
    elemtype data;//数据域
    struct LNode* next;//指针域
}LNode, * LinkList;
// typedef struct LNode LNode;typedef struct LNode* LinkList;

LinkList List_headInsert(LinkList& L);//头插法建立单链表
LinkList List_tailInsert(LinkList& L);//尾插法建立单链表
LNode* GetElem(LinkList L, int i);//按位查找
LNode* LocateElem(LinkList L, elemtype e);//按值查找
bool InsertPriorNode(LNode* p, elemtype e);//前插操作(p节点前插入e）
bool InsertNextNode(LNode* p, elemtype e);//后插操作
bool DeleteNode(LNode* p);//指定节点的删除
bool ListDelete(LinkList& L, int i);//删除第i位
void PrintList(LinkList L);//输出链表

int main()
{
    LinkList L; int i;
    printf("请输入插入数据，输入0停止\n");
    //List_headInsert(L);//头插法
    List_tailInsert(L);//尾插法
    PrintList(L);
    printf("删除第几位:\n");
    scanf_s("%d", &i);
    if (ListDelete(L, i))
        PrintList(L);

}

void PrintList(LinkList L)
{
    LinkList p;
    //int len=0;
    p = L->next;
    printf("链表元素如下：\n");
    while (p != NULL)
    {
        printf("%d ", p->data);
        p = p->next;
        //len++;求表长
    }
    printf("\n");
}

LinkList List_headInsert(LinkList& L)//头插法建立单链表
{
    LNode* s; int x;
    L = (LinkList)malloc(sizeof(LNode));//创建头节点
    //L = (LNode*)malloc(sizeof(LNode));
    L->next = NULL;
    scanf_s("%d", &x);//输入节点的值
    while (x != 0) {
        s = (LNode*)malloc(sizeof(LNode));//创建新节点
        s->data = x;
        s->next = L->next;
        L->next = s;
        scanf_s("%d", &x);
    }
    return L;
}

LinkList List_tailInsert(LinkList& L)//尾插法建立单链表
{
    int x;
    L = (LinkList)malloc(sizeof(LNode));//创建头节点
    //L = (LNode*)malloc(sizeof(LNode));
    LNode* s, * r = L;//r为表尾指针
    scanf_s("%d", &x);//输入节点的值
    while (x != 0) {
        s = (LNode*)malloc(sizeof(LNode));//创建新节点
        s->data = x;
        r->next = s;
        r = s;
        scanf_s("%d", &x);
    }
    r->next = NULL;
    return L;
}

LNode* GetElem(LinkList L, int i)//按位查找
{
    LNode* p;//p指向当前扫描的节点
    int j = 0;//p指向的是第几个节点
    p = L;//p指向第0个节点
    while (p != NULL && j < i)//循环找到i个节点
    {
        p = p->next;
        j++;
    }
    return p;//返回第i个节点的指针，若i大于表长，则返回NULL
}

LNode* LocateElem(LinkList L, elemtype e)//按值查找
{
    LNode* p = L->next;
    while (p != NULL && p->data != e)//从第一个节点查找e
        p = p->next;
    return p;
}

bool InsertPriorNode(LNode* p, elemtype e)//前插操作(p节点前插入e）
{
    if (p == NULL) return false;
    LNode* s = (LNode*)malloc(sizeof(LNode));
    if (s == NULL)//内存分配失败
        return false;
    s->next = p->next;
    p->next = s;
    s->data = p->data;
    p->data = e;
}//p=GetElem(L,i-1),也可先创建节点s,将e放进去，然后交换s,p内的值

bool InsertNextNode(LNode* p, elemtype e)//后插操作
{
    if (p == NULL)
        return false;
    LNode* s = (LNode*)malloc(sizeof(LNode));
    if (s == NULL)//内存分配失败
        return false;
    s->next = p->next;
    p->next = s;
    return true;
}

bool DeleteNode(LNode* p)//指定节点的删除(最后一个节点要特殊处理）
{
    if (p == NULL)
        return false;
    LNode* q = p->next;
    p->data = p->next->data;
    p->next = q->next;
    free(q);
    return true;
}

bool ListDelete(LinkList& L, int i) {
    if (i < 1) return false;
    LNode* p = GetElem(L, i);
    return DeleteNode(p);
}