数据结构期末复习总结：线性表顺序存储和链式存储的基本代码区别；

本文链接：https://blog.youkuaiyun.com/Strawberry_595/article/details/85068693

本文深入探讨了线性表的顺序存储与动态存储，以及链表（包括普通单链表、循环链表和双向链表）的实现原理与操作方法，详细介绍了插入、删除和打印等功能的具体代码实现。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

我只写了插入和删除、打印的区别，别的好像根据这两种基本上看懂了就会写了

线性表顺序存储

静态存储：

考试应该涉及的比较多的是动态存储吧；但是静态存储模式的代码还是得了解，课本上并没有关于静态存储的代码段，所以就简单的写一下吧；

#include <cstdio>
#include <cmath>
#include <algorithm>
#include <iostream>
#define  maxleng 100

using namespace std;

typedef struct{
	int elem[maxleng];  //元素分配的内存块
	int length;    //表总长
}sql;
sql La;   //定义一个静态线性顺序存储La
void Init(sql &L){
	L.length = 0;
}

int Insert(sql &L, int i, int e)  //在第i位之前插入元素e
{
	if(i < 1 || i > L.length + 1) return 0;
	if(L.length >= maxleng)  return 0;
	for(int j = L.length - 1;j >= i - 1;j--)
		L.elem[j + 1] = L.elem[j];
	L.elem[i - 1] = e;
	L.length++;
	return 1;
}
int Delet(sql &L, int i)  //删除第i位元素
{
	if(i < 1 || i > L.length) return 0;
	for(int j = i - 1;j <= L.length - 1;j++)
		L.elem[j] = L.elem[j + 1];
	L.length--;
		return 1;
}
void Print(sql &L)   //打印静态存储
{
	for(int i = 0;i < L.length;i++)
		cout << L.elem[i] << "  ";
	cout << endl;
}
int main()
{
	Init(La);//初始化
	printf("请问你想在静态线性顺序存储La中插入几个数据？");
	int n; scanf("%d", &n);
	printf("请你输入%d个你要插入La静态线性顺序存储的数据\n", n);
	for(int i = 1;i <= n;i++)
	{
		int e; scanf("%d",&e);
		if(!Insert(La, i, e)) printf("插入数据出错请检查！\n");
		else printf("插入数据成功\n");
	}
	printf("打印插入数据后的静态线性顺序存储La\n\n");
	Print(La);
	printf("你要删除第几个元素？");
	int d; scanf("%d", &d);
	if(!Delet(La, d)) printf("删除失败！\n");
	else printf("删除成功！\n");
	Print(La);
	return 0;
}

动态存储：

#include <cstdio>
#include <cmath>
#include <algorithm>
#include <iostream>
#define  InitSize 100 //最初分配的内存可以存储的元素的个数
#define  Increment 10  //每次扩充内存，可多存储10个元素

using namespace std;

typedef struct{
	int *elem;  //元素分配的首地址
	int length;    //表现在总长有多少个元素
	int size;     //表的最大容量是多少个元素
}sql;
sql La;   //定义一个静态线性顺序存储La
void Init(sql &L){
	L.length = 0;
}

int Insert(sql &L, int i, int e)  //在第i位之前插入元素e
{
	if(i < 1 || i > L.length + 1) return 0;
	if(L.length >= L.size)   //如果有元素溢出的现象，就扩充内存，寻找新的更大的存储空间
	{
		int *newbase;     //定义新空间的基地址
		newbase = (int *)realloc(L.elem, (L.size + Increment)*sizeof(int));
		if(newbase == NULL) return 0;
		L.elem = newbase;
		L.size += Increment;
	}
	for(int j = L.length - 1;j >= i - 1;j--)
		L.elem[j + 1] = L.elem[j];
	L.elem[i - 1] = e;
	L.length++;
	return 1;
}
int Delet(sql &L, int i)  //删除第i位元素
{
	if(i < 1 || i > L.length) return 0;
	for(int j = i - 1;j <= L.length - 1;j++)
		L.elem[j] = L.elem[j + 1];
	L.length--;
		return 1;
}
void Print(sql &L)   //打印静态存储
{
	for(int i = 0;i < L.length;i++)
		cout << L.elem[i] << "  ";
	cout << endl;
}
int main()
{
	Init(La);//初始化
	printf("请问你想在静态线性顺序存储La中插入几个数据？");
	int n; scanf("%d", &n);
	printf("请你输入%d个你要插入La静态线性顺序存储的数据\n", n);
	for(int i = 1;i <= n;i++)
	{
		int e; scanf("%d",&e);
		if(!Insert(La, i, e)) printf("插入数据出错请检查！\n");
		else printf("插入数据成功\n");
	}
	printf("打印插入数据后的静态线性顺序存储La\n\n");
	Print(La);
	printf("你要删除第几个元素？");
	int d; scanf("%d", &d);
	if(!Delet(La, d)) printf("删除失败！\n");
	else printf("删除成功！\n");
	Print(La);
	return 0;
}

顺序存储总结：

链表：

（1）普通单链表：

#include <cstdio>
#include <cmath>
#include <algorithm>
#include <iostream>
#define size sizeof(struct node)
using namespace std;

typedef struct node    //定义指针
{
	int data;
	struct node *next;
}node;
void Init(node* &L){     //初始化节点
	L = (node*)malloc(size);
	L->next = NULL;
}
int Insert(node* &L, int i, int e){  //在第i个位置之前插入元素e
	node* tail = L->next;
	int j = 0;
	while(tail && j < i - 1)
	{
		tail = tail->next;
		j++;
	}
	if(!tail || j > i - 1) return 0;
	node* s; Init(s);
	s->data = e;
	s->next = tail->next;
	tail->next = s;
	return 1;
}
int Delet(node* &L, int i) //删除第i个位置的元素
{
	node* p = L->next;
	int j = 0;
	while(p && j < i - 1){ p = p->next; j++;}
	if(!p && j > i - 1) return 0;
	node* s = (node*)malloc(size);
	s = p->next;
	p->next = s->next;
	free(s);
	return 1;
}
void Print(node* &L)    //打印
{
	node* p = L->next;
	while(p){
		cout << p->data << "  ";
		p = p->next;
	}
	cout << endl;
}
int main()
{
	printf("请你输入你想建立的链表\n");
	node* La;Init(La);
	int e;int k = 1;
	while(scanf(" %d", &e) && e != 0){
		if(Insert(La, k++, e)) printf("插入成功！\n");
		else printf("插入失败！！！\n");
	}
	printf("打印已经建成的链表La\n");
	Print(La);
	printf("你要删除第几个元素?\n");
	int d;cin >> d;
	if(Delet(La, d)) printf("删除成功！\n");
	else printf("删除失败！\n");
	Print(La);
	return 0;
}

（2）循环链表：

#include <cstdio>
#include <cmath>
#include <algorithm>
#include <iostream>
#define size sizeof(struct node)
using namespace std;

typedef struct node    //定义指针
{
	int data;
	struct node *next;
}node;
void Init(node* &L){     //初始化节点
	L = (node*)malloc(size);
	L->next = L;             ///这里是单链表和循环链表的主要区别，最后一位指向头结点
}
int Insert(node* &L, int i, int e){  //在第i个位置之前插入元素e
	node* tail = L->next;
	int j = 0;
	while(tail != L&& j < i - 1)
	{
		tail = tail->next;
		j++;
	}
	if(tail == L || j > i - 1) return 0;
	node* s; Init(s);
	s->data = e;
	s->next = tail->next;
	tail->next = s;
	return 1;
}
int Delet(node* &L, int i) //删除第i个位置的元素
{
	node* p = L->next;
	int j = 0;
	while(p != L && j < i - 1){ p = p->next; j++;}
	if(p == L && j > i - 1) return 0;
	node* s = (node*)malloc(size);
	s = p->next;
	p->next = s->next;
	free(s);
	return 1;
}
void Print(node* &L)    //打印
{
	node* p = L->next;
	while(p != L){                    //玄幻结束的条件是p==L的时候说明便利一遍结束
		cout << p->data << "  ";
		p = p->next;
	}
	cout << endl;
}
int main()
{
	printf("请你输入你想建立的链表\n");
	node* La;Init(La);
	int e;int k = 1;
	while(scanf(" %d", &e) && e != 0){
		if(Insert(La, k++, e)) printf("插入成功！\n");
		else printf("插入失败！！！\n");
	}
	printf("打印已经建成的链表La\n");
	Print(La);
	printf("你要删除第几个元素?\n");
	int d;cin >> d;
	if(Delet(La, d)) printf("删除成功！\n");
	else printf("删除失败！\n");
	Print(La);
	return 0;
}

（3）双向链表：

#include <cstdio>
#include <cmath>
#include <algorithm>
#include <iostream>
#define size sizeof(struct node)
using namespace std;

typedef struct node    //定义指针
{
	int data;
	struct node *next, *prior;         //多了前驱
	int len;
}node;
void Init(node* &L){     //初始化节点
	L = (node*)malloc(size);
	L->next = L->prior = L;
	L->len = 0;
}
int Insert(node* &L, int i, int e){  //在第i个位置之前插入元素e
	node* tail = L->next;
	int j = 0;
	while(tail != L && j < i - 1)
	{
		tail = tail->next;
		j++;
	}
	if(tail != L && j > i - 1) return 0;
	node* s; Init(s);
	s->data = e;
	s->prior = tail->prior;                 ///区别
	tail->prior->next = s;             ///区别
	s->next = tail;                  ///区别
	tail->prior = s;                 ///区别
	L->len++;
	return 1;
}
int Delet(node* &L, int i) //删除第i个位置的元素
{
	node* p = L->next;
	int j = 0;
	while( j < i - 1){ p = p->next; j++;}       ///区别
	if(p != L && j > i - 1) return 0;
	node* s = (node*)malloc(size);
	s = p->next;
	s->prior->next = s->next;         ///区别
	s->next->prior = s->prior;           ///区别
	L->len--;
	free(s);
	return 1;
}
void Print(node* &L)    //打印
{
	node* p = L->next;
	int k = L->len;
	while(k--){
		cout << p->data << "  ";
		p = p->next;
	}
	cout << endl;
}
int main()
{
	printf("请你输入你想建立的链表\n");
	node* La;Init(La);
	int e;int k = 1;
	while(scanf(" %d", &e) && e != 0){
		if(Insert(La, k++, e)) printf("插入成功！\n");
		else printf("插入失败！！！\n");
	}
	printf("打印已经建成的链表La\n");
	Print(La);
	printf("你要删除第几个元素?\n");
	int d;cin >> d;
	if(Delet(La, d)) printf("删除成功！\n");
	else printf("删除失败！\n");
	Print(La);
	return 0;
}

/*
void creatIncrement(node* &L, int e)   //生成一个递增的链表；
{
	node *q, *p;
	q = L;
	p = L->next;
	while(p && e > p->data)
	{
		q = p;
		p= p->next;
	}
	node* s = (node*)malloc(size);
	s->data = e;
	s->prior = q->prior;
	q->prior->next = s;
	s->next = q;
	q->prior = s;
}
*/