【数据结构】线性表（顺序存储和链式存储）两种方法，细节满满，保你学会

在下小吉 2023-04-21 原文

⭐⭐⭐⭐⭐⭐

🎊专栏【数据结构】

🍔喜欢的诗句：更喜岷山千里雪三军过后尽开颜。

🎆音乐分享【勋章】

大一同学小吉，欢迎并且感谢大家指出我的问题🥰

⭐⭐⭐⭐⭐⭐

目录

⭐定义：

⭐ 理解：

⭐存储方式：

⭐顺序存储的优缺点：

优点：

缺点：

⭐链式存储的优缺点：

优点：

缺点：

⭐基本操作

✨顺序存储

🍔存储结构

🎈添加数字建立表

🎈输出线性表里面的数

🎈插入数字

🎈删除数字

🎈取出数字

🎈置空

😎完整代码1

🚌小细节：什么时候使用引用，什么时候不使用引用

😎完整代码2

✨链式存储

🍔存储结构

⭐易错：首元结点VS头节点VS头指针

⭐链表增加头结点的好处

🎈便于首元结点的处理

🎈便于空表和非空表的统一处理

🎈初始化

🎈尾插法建立单链表

🎈头插法建立单链表

🎈插入

🎈删除

🎈取出元素

🎈输出链表

😎完整代码1

😎完整代码2

⭐定义：

线性表（List）:零个或多个数据元素的有限序列

⭐ 理解：

线性表，顾名思义，就是具有像线一样性质的表，元素之间是有顺序的，若元素存在多个，那么第一个元素没有前驱元素，最后一个元素没有后继元素，其他元素既有前驱元素又有后继元素

⭐存储方式：

线性存储

链式存储

⭐顺序存储的优缺点：

优点：

1.表中数据元素可以根据序号随机存取

2. 存储密度大，存储密度为1（存储密度是指一个结点中数据元素所占的存储单元和整个结点所占的存储单元之比）

缺点：

1.做插入、删除操作时，要移动大量元素，因此对很长的线性表操作效率低，插入和删除操作不方便；

2.要预先分配存储空间，预先估计过大，会导致存储空间浪费，估计过小，会造成数据溢出。

⭐链式存储的优缺点：

优点：

1.做插入、删除操作时，不用移动大量元素，相比线性存储方式方便；

2.不用预先分配存储空间。

缺点：

1.表中数据元素不可随机存取

2.存储密度小，存储密度小于1

⭐基本操作

✨顺序存储

🍔存储结构

#define maxsize 100
typedef struct{
	ElemType *elem;//由于这里不知道线性表的具体长度，所以这里就用了指针
                   //可以是elem[maxsize]
	int length;
}SqList;

其中ElemType可以改为其他的数据类型，比如

typedef int ElemType

length表示当前线性表中数据元素的个数，注意数组里面的下标是从0开始的，那么

a1->elem[0]; //注意，用数组表示

a2->elem[1];

a3->elem[2] ;

an->elem[length-1];

🎈初始化

🚕分配空间，建立空表，使空表长度为0

使用引用初始化

int InitList(SqList &L)
{
	L.elem=new ElemType[maxsize];
	if(!L.elem) return -1;			//内存分配失败
	L.length=0;						//空表长度为0
	return 1;	
}

使用指针初始化

int InitList(SqList* L)
{
	L->elem = new int[100];
	if (!L->elem) exit(overflow);
	L->length = 0;
	return OK;
}

🎈添加数字建立表

🚕向空表里面添加数字，从而建立线性表

使用引用

void InputList(SqList& L, int num)
{
	L.elem[k++] = num;
	L.length++;
}

使用指针

void InputList(SqList* L, int num)
{
	L->elem[k++] = num;
	L->length++;
}

🎈输出线性表里面的数

🚕输出线性表里面的数

使用引用

void OutputList(SqList& L)
{
	for (int i = 1; i <= L->length; i++)
	{
		cout << L.elem[i] << " ";
	}
}

使用指针

void OutputList(SqList *L)
{
	for (int i = 1; i <= L.length; i++)
	{
		cout << L->elem[i] << " ";
	}
}

🎈插入数字

🚕顺序存储插入数字，就是找到要插入的数字的位置，从这个位置开始的后面的所有的数字全都后移一位，这样子前面就回空出一个位置，就是要插入的数字的位置

使用引用

void ListInsert(SqList& L, int place, int num)
{
	L.length++;
	for (int i = L.length; i >= place; i--)
	{
		L.elem[i + 1] = L.elem[i];
	}
	L.elem[place] = num;

}

注意：这里是 i = L.length , 不是 i = L.length-1

你想一下，数组下标是从0开始的，所以整个表最后一个位置（L.elem[length]）没有存数

这样把数组后移，到最后刚好可以空出一个位置来存需要插入的数

使用指针

void ListInsert(SqList *L, int place, int num)
{
	L->length++;
	for (int i = L->length; i >= place; i--)
	{
		L->elem[i + 1] = L->elem[i];
	}
	L->elem[place] = num;

}

🎈删除数字

🚕与插入数字类似，删除数字采用的是向前覆盖数字

使用引用

void ListDelete(SqList& L, int place)
{

	for (int i = place; i <= L.length; i++)
	{
		L.elem[i - 1] = L.elem[i];
	}
	L.length--;
}

使用指针

void ListDelete(SqList *L, int place)
{

	for (int i = place; i <= L->length; i++)
	{
		L->elem[i - 1] = L->elem[i];
	}
	L->length--;
}

🎈取出数字

🚕就是给出这个数字的位置，就是想当于给出了这个数字在数组里面的位置，然后直接根据这个位置取值

int GetElem(SqList L, int i, int& e)//int *e
{
	if ((i < 1) || (i > L.length)) return -1;
	e = L.elem[i];                  //*e=L.elem[i];
	return 1;
}

int GetElem(SqList *L, int i, int& e)
{
	if ((i < 1) || (i > L->length)) return -1;
	e = L->elem[i];
	return 1;
}

🎈置空

🚕直接L.length=0就可以了

（如果要返回线性表的长度，直接L.length即可）

😎完整代码1

#include<iostream>
using namespace std;
#define OK 1
#define overflow -1
int k=1;

typedef struct{
	int *elem;
	int length;
}SqList;

int InitList(SqList &L)
{
	L.elem=new int[100];
	if(!L.elem) exit(overflow);
	L.length=0;
	return OK;
}

//3
void InputList(SqList &L,int n)
{
	L.elem[k++]=n;
	L.length++;
}

//4
void OutputList(SqList &L)
{
	for(int i=1;i<=L.length;i++)
	{
		cout<<L.elem[i]<<" ";
	}
}	

//5
void ListInsert(SqList &L,int a,int b)
{
	L.length++;
	for(int i=L.length;i>=a;i--)
	{
		L.elem[i+1]=L.elem[i];
	}
	L.elem[a]=b;
	
}

//6 	
 void ListDelete(SqList &L,int x)
 {

	for(int i=x;i<=L.length;i++)
	{
		L.elem[i-1]=L.elem[i];
	 } 	
	L.length--;
 }
 
 //7
 int GetElem(SqList L,int i,int &e)
 { 
 	if((i<1)||(i>L.length)) return -1;
	 e=L.elem[i];
	 return OK;
 }
 
 //8
int ClearList(SqList L)
{
    L.length=0;
    return 1;
}
 
int main()
{
	SqList L;
	int s,e;
	InitList(L);
	if(InitList) cout<<"成功"<<endl;
	else cout<<"失败"<<endl;
	cout<<"0:退出程序"<<endl;
	cout<<"3:加入数"<<endl;
	cout<<"4:输出线性表里面的数"<<endl;
	cout<<"5:插入数"<<endl;
	cout<<"6:删除数"<<endl;
	cout<<"7:取出某个位置的数"<<endl;
	cout<<"8:置空"<<endl;
	cout<<endl;
	for(;;)
	{
		cout<<"请输入3~8之间的数，代表3~8题,0表示程序结束"<<endl;
		cin>>s;
		if(s==0) return 0;
		switch(s)
		{
		case 3:
			cout<<"请输入需要加入的数的个数:"<<endl;
			int n;
			cin>>n;
			cout<<"请输入需要加入的数:"<<endl;
			for(int i=1;i<=n;i++)
			{
				int t;
				cin>>t;
				InputList(L,t);	
			}
			break;
		case 4:
			OutputList(L);
			cout<<endl;
			break;
		case 5:
			for(int i=1;i<=2;i++)
			{
				cout<<"请输入插入的位置和插入的数是什么:"<<endl;
				int a,b;
				cin>>a>>b;
				ListInsert(L,a,b);
			}
			break;
		case 6:
			cout<<"请输入需要删除哪个位置的数:"<<endl;
			for(int i=1;i<=2;i++)
			{
				int aa;
				cin>>aa;
				ListDelete(L,aa);
			}
			break;	
		case 7:
			cout<<"请输入需要取出哪个位置的数:"<<endl;
			for(int i=1;i<=2;i++)
			{
				int a;
				cin>>a;
				GetElem(L,a,e);
				cout<<"第"<<a<<"个位置的数的值为:"<<e<<endl;
			}
			break;
		case 8:
			if (ClearList(L)) cout << "置空成功" << endl;
			else cout << "置空失败" << endl;
			break;
		}
	}
 }

🚌小细节：什么时候使用引用，什么时候不使用引用

观察代码我们会发现，

有的是SqList L（没有使用引用）

有的是SqList &L（使用了引用）

这是为什么呢

原因：我们发现，使用引用的代码段里面都会有分配空间的操作，而没有使用引用的代码段里面就没有分配空间的操作

分配一段空间，使整个程序改变了，所以要使用引用，而如果不分配空间，那么就直接使用就行了，不需要引用

😎完整代码2

#include<iostream>
using namespace std;
#define OK 1
#define overflow -1
int k = 1;

typedef struct {
	int* elem;
	int length;
}SqList;

int InitList(SqList* L)
{
	L->elem = new int[100];
	if (!L->elem) exit(overflow);
	L->length = 0;
	return OK;
}

//3
void InputList(SqList* L, int n)
{
	L->elem[k++] = n;
	L->length++;
}

//4
void OutputList(SqList* L)
{
	for (int i = 1; i <= L->length; i++)
	{
		cout << L->elem[i] << " ";
	}
}

//5
void ListInsert(SqList *L, int place, int num)
{
	L->length++;
	for (int i = L->length; i >= place; i--)
	{
		L->elem[i + 1] = L->elem[i];
	}
	L->elem[place] = num;

}

//6 	
void ListDelete(SqList *L, int place)
{

	for (int i = place; i <= L->length; i++)
	{
		L->elem[i - 1] = L->elem[i];
	}
	L->length--;
}

//7
int GetElem(SqList L, int i, int& e)
{
	if ((i < 1) || (i > L.length)) return -1;
	e = L.elem[i];
	return OK;
}

//8
int ClearList(SqList *L)
{

	L->length=0;
    return 1;
}

int main()
{
	SqList L;
	int s, e;
	InitList(&L);
	if (InitList) cout << "成功" << endl;
	else cout << "失败" << endl;
	cout << "0:退出程序" << endl;
	cout << "3:加入数" << endl;
	cout << "4:输出线性表里面的数" << endl;
	cout << "5:插入数" << endl;
	cout << "6:删除数" << endl;
	cout << "7:取出某个位置的数" << endl;
	cout << "8:置空" << endl;
	cout << endl;
	for (;;)
	{
		cout << "请输入3~8之间的数，代表3~8题,0表示程序结束" << endl;
		cin >> s;
		if (s == 0) return 0;
		switch (s)
		{
		case 3:
			cout << "请输入需要加入的数的个数:" << endl;
			int n;
			cin >> n;
			cout << "请输入需要加入的数:" << endl;
			for (int i = 1; i <= n; i++)
			{
				int t;
				cin >> t;
				InputList(&L, t);
			}
			break;
		case 4:
			OutputList(&L);
			cout << endl;
			break;
		case 5:
			for (int i = 1; i <= 2; i++)
			{
				cout << "请输入插入的位置和插入的数是什么:" << endl;
				int a, b;
				cin >> a >> b;
				ListInsert(&L, a, b);
			}
			break;
		case 6:
			cout << "请输入需要删除哪个位置的数:" << endl;
			for (int i = 1; i <= 2; i++)
			{
				int aa;
				cin >> aa;
				ListDelete(&L, aa);
			}
			break;
		case 7:
			cout << "请输入需要取出哪个位置的数:" << endl;
			for (int i = 1; i <= 2; i++)
			{
				int a;
				cin >> a;
				GetElem(L, a, e);
				cout << "第" << a << "个位置的数的值为:" << e << endl;
			}
			break;
		case 8:
			if (ClearList(&L)) cout << "置空成功" << endl;
			else cout << "置空失败" << endl;
			break;
		}
	}
}

✨链式存储

🎆一定别忘记生成新结点

🍔存储结构

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

LinkList为指向结构体LNode的指针类型

🚥🚥🚥🚥🚥🚥

⭐习惯上用LinkList定义单链表，强调的是某个单链表的头指针，用LNode*定义指向单链表中任意结点的指针变量

例如：

定义LinkList L,那么L为单链表的头指针

定义LNode *p，那么p为指向单链表某个结点的指针，用*p代表该节点

⭐注意区分指针变量和结点变量两个不同的概念

例如

若定义LinkList p或LNode *p

p表示指向某个结点的指针变量，表示该结点的地址

*p表示对应的结点变量，表示该结点的名称

这两种定义方式是等价的

🚥🚥🚥🚥🚥🚥

⭐易错：首元结点VS头节点VS头指针

头节点是首元结点之前附设的结点

头指针是指向链表第一个结点的指针

（如果有头节点，那么头指针指向的结点为头节点）

（如果没有头节点，那么头指针指向的结点为首元结点）

🚥🚥🚥🚥🚥🚥

⭐链表增加头结点的好处

🎈便于首元结点的处理

增加头结点后，首元结点的地址

🎈便于空表和非空表的统一处理

没有头结点，设L为单链表的头指针，L应该指向首元结点，那么当单链表为长度为0的空表时，L指针为空（L==NULL）

有头结点，无论链表是否为空，头指针都是指向头节点的非空指针，那么当头结点的指针域为空，（L->next==NULL）如下图所示

🚥🚥🚥🚥🚥🚥

在顺序表中，由于相邻的两个元素在物理位置上相邻，那么每个元素的存储位置都可以从线性表的起始位置计算得到

在单链表里面，各个元素的存储位置都是任意的，都是每个元素的存储位置都包含着其直接前驱结点，因为p->next=ai , p->next->next=ai+1 , 那么想要取得第i个数据元素必须从头指针出发顺链寻找

🚥🚥🚥🚥🚥🚥

🎈初始化

生成新结点作为头结点，用头指针 L 指向头结点

头结点的指针域置空

int InitList(LinkList &L)
{
	L=new LNode;
	L->next=NULL;
	return 1;
}

int InitList(LinkList *L)
{
	*L=new LNode;
	(*L)->next=NULL;//必须加上括号
	return 1;
}

为什么必须加上（）：优先级：->大于*

🎈尾插法建立单链表

1.创建一个只有头结点的空链表

2.尾指针 r 初始化，指向头结点

3.根据创建链表包括的元素个数n，循环n次执行以下操作

~生成一个新结点*p

~输入元素并把值赋给新结点*p的数据域

~将新结点*p插入尾结点*r后面

~尾指针r指向新的尾结点*p

（在前面说过，*X表示结点的名称）

int Create_back(LinkList &L,int num)
{
	L=new LNode;
	LNode *p,*r;		//先建立一个带有头节点的空链表 
	L->next=NULL;		//尾指针r指向头结点
	r=L;
	for(int i=0;i<num;i++)
	{
		p=new LNode;	//生成新结点
		cin>>p->data;
		p->next=NULL;
		r->next=p;		//新结点*p插入尾结点*r后（*X表示结点的名称）
		r=p;			//r指向新的尾结点*p
	}	
	return 1;
	
}

代码里面的 LNode *p,*r;还可以写为LinkList p,r;具体原因在上面说过了（就是在上面的⭐注意区分指针变量和结点变量两个不同的概念）

int Create_back(LinkList *L,int num)
{
	*L=new LNode;
	LNode *p,*r;		//先建立一个带有头节点的空链表 
	(*L)->next=NULL;		//尾指针r指向头结点
	r=*L;
	for(int i=0;i<num;i++)
	{
		p=new LNode;	//生成新结点
		cin>>p->data;
		p->next=NULL;
		r->next=p;		//新结点*p插入尾结点*r后（*X表示结点的名称）
		r=p;			//r指向新的尾结点*p
	}	
	return 1;
	
}

🎈头插法建立单链表

1.创建一个只有头结点的空链表

2.根据创建链表包括的元素个数n，循环n次执行以下操作

~生成一个新结点*p

~输入元素并把值赋给新结点*p的数据域

~将新结点*p插入到头结点后面

int Create_front(LinkList &L,int num)
{
	L=new LNode;
	LNode *p;
	L->next=NULL;
	for(int i=0;i<num;i++)
	{
		p=new LNode;		//生成新结点*p
		cin>>p->data;
		p->next=L->next;
		L->next=p;			//将新结点*p插入到头结点后面
	}
	return OK;
}

int Create_front(LinkList *L,int num)
{
	*L=new LNode;
	LNode *p;
	(*L)->next=NULL;
	for(int i=0;i<num;i++)
	{
		p=new LNode;		//生成新结点*p
		cin>>p->data;
		p->next=(*L)->next;
		(*L)->next=p;			//将新结点*p插入到头结点后面
	}
	return OK;
}

🎈插入

注意：插入和前面的前插法尾插法不同，前插法尾插法是建立单链表，而插入是在已经建立好的单链表里面再加入额外的结点

具体步骤如下图所示

注意：插入操作必须要找到该位置的前驱结点

（这句话看上去理所应当，但是在某些时候是真的特别有用）

int ListInsert(LinkList &L,int num,int place)
{
	LNode *p,*s;
	p=L;
	int j=0;
	while(p&&j<place-1)        //找到插入位置
	{
		p=p->next;
		j++;
	}
	if(!p||j>place-1) return ERROR;
	s=new LNode;			   //生成新结点
	s->data=num;			   //数据域赋值
							   
	s->next=p->next;		   //结点*s的指针域指向a2
	p->next=s;				   //结点*p的指针域指向*s
	return OK;
}

int ListInsert(LinkList *L,int num,int place)
{
	LNode *p,*s;
	p=*L;
	int j=0;
	while(p&&j<place-1)        //找到插入位置
	{
		p=p->next;
		j++;
	}
	if(!p||j>place-1) return ERROR;
	s=new LNode;			   //生成新结点
	s->data=num;			   //数据域赋值
							   
	s->next=p->next;		   //结点*s的指针域指向a2
	p->next=s;				   //结点*p的指针域指向*s
	return OK;
	
}

🎈删除

1.先找到待删除位置a的前驱结点

2.创建临时结点q，保存待删除结点的地址

3.将结点*p的指针域指向a的直接后继结点

4.释放结点a的空间

int LinkDelete(LinkList &L,int place)
{
	LNode *p,*q;
	p=L;
	int j=0;
	while((p->next)&&(j<place-1))
	{
		p=p->next;
		++j;
	} 
	if(!(p->next)||(j>place-1) )return ERROR;
	q=p->next;				//创建临时结点q
	p->next=q->next;		//改变待删除结点的前驱结点的指针域
	delete q;				//释放被删除结点的空间
	return OK;
}

int LinkDelete(LinkList *L,int place)
{
	LNode *p,*q;
	p=*L;
	int j=0;
	while((p->next)&&(j<place-1))
	{
		p=p->next;
		++j;
	} 
	if(!(p->next)||(j>place-1) )return ERROR;
	q=p->next;				//创建临时结点q
	p->next=q->next;		//改变待删除结点的前驱结点的指针域
	delete q;				//释放被删除结点的空间
	return OK;
}

🎈取出元素

找到要取出的元素的位置，然后返回数据域即可

int ListPop(LinkList &L,int num)
{
	LNode *p;
	p=L;
	int j=0;
	while(p&&j<num)
	{
		p=p->next;
		j++;
	}
	if(p)
	return p->data;
	else
	return -1;
	
}

int ListPop(LinkList *L,int num)
{
	LNode *p;
	p=*L;
	int j=0;
	while(p&&j<num)
	{
		p=p->next;
		j++;
	}
	if(p)
	return p->data;
	else
	return -1;
	
}

🎈输出链表

void OutputList(LinkList &L)
{
	LNode *p;
	p=L->next;
	while(p)
	{
		cout<<p->data<<' ';
		p=p->next;
	}
	cout<<endl;
}

void OutputList(LinkList *L)
{
	LNode *p;
	p=(*L)->next;
	while(p)
	{
		cout<<p->data<<' ';
		p=p->next;
	}
	cout<<endl;
}

😎完整代码1

#include<iostream>
using namespace std;
#define OK 1
#define ERROR -1
typedef struct LNode
{
	int data;
	struct LNode *next;
	
}LNode,*LinkList;


//1
int InitList(LinkList *L)
{
	*L=new LNode;
	(*L)->next=NULL;
	return OK;
}

int Create_front(LinkList *L,int num)
{
	*L=new LNode;
	LNode *p;
	(*L)->next=NULL;
	for(int i=0;i<num;i++)
	{
		p=new LNode;		//生成新结点*p
		cin>>p->data;
		p->next=(*L)->next;
		(*L)->next=p;			//将新结点*p插入到头结点后面
	}
	return OK;
}

//3
int ListInsert(LinkList *L,int num,int place)
{
	LNode *p,*s;
	p=*L;
	int j=0;
	while(p&&j<place-1)        //找到插入位置
	{
		p=p->next;
		j++;
	}
	if(!p||j>place-1) return ERROR;
	s=new LNode;			   //生成新结点
	s->data=num;			   //数据域赋值
							   
	s->next=p->next;		   //结点*s的指针域指向a2
	p->next=s;				   //结点*p的指针域指向*s
	return OK;
	
}

//4
int LinkDelete(LinkList *L,int place)
{
	LNode *p,*q;
	p=*L;
	int j=0;
	while((p->next)&&(j<place-1))
	{
		p=p->next;
		++j;
	} 
	if(!(p->next)||(j>place-1) )return ERROR;
	q=p->next;				//创建临时结点q
	p->next=q->next;		//改变待删除结点的前驱结点的指针域
	delete q;				//释放被删除结点的空间
	return OK;
}

//5
int ListPop(LinkList *L,int num)
{
	LNode *p;
	p=*L;
	int j=0;
	while(p&&j<num)
	{
		p=p->next;
		j++;
	}
	if(p)
	return p->data;
	else
	return -1;
	
}

void OutputList(LinkList *L)
{
	LNode *p;
	p=(*L)->next;
	while(p)
	{
		cout<<p->data<<' ';
		p=p->next;
	}
	cout<<endl;
}

int main()
{
	LinkList L;
	int n,e;
	cout<<"请输入你的操作"<<endl;
	printf("0:结束程序\n1:建立空表\n2:尾插法建立空表\n3:插入\n4:删除\n5:取出元素\n");
	for(;;)
	{
		cin>>n;
		switch(n)
		{
			case 0:
				return 0;
				break;
			case 1:
				cout<<"建立空表"<<endl;
				if(InitList(&L))
				{
					cout<<"建立成功"<<endl;
				}
				else
				{
					cout<<"建立失败"<<endl;
				}
				break;
			case 2:
				cout<<"输入21 18 30 75 42 56，使用尾插法建立链表"<<endl;
				cout<<"请输入要加入的数字的数量"<<endl;
				int num;
				cin>>num;
				if(Create_front(&L,num)!=0)
				{
					 cout<<"请进行下一步操作"<<endl;
					 OutputList(&L); 
					 
				}
				else cout<<"失败了"<<endl;
				break;
			case 3:
				cout<<"在第3个位置插入67，在第9个位置插入10"<<endl;
				cout<<"请输入需要插入的数字的个数"<<endl;
				int qqq;
				cin>>qqq;
				for(int i=0;i<qqq;i++)
				{
					cout<<"需要插入的数据和位置"<<endl;
					int nn,mm;
					cin>>nn>>mm;
					if(ListInsert(&L,nn,mm))
					{
						cout<<"插入成功"<<endl;
						OutputList(&L);
					
					}
					else
					{
						cout<<"插入失败"<<endl;
					}
				}
				break;
			case 4:
				cout<<"删除第6个元素和第8个元素"<<endl;
				cout<<"输入需要删除的元素是哪一个"<<endl;
				int qq;
				cin>>qq;
				if(LinkDelete(&L,qq))
				{
					cout<<"删除成功"<<endl;
					OutputList(&L);
				}	
				else
				{
					cout<<"删除失败"<<endl;
				}
				break;
			case 5:
				cout<<"取出第5个元素和第7个元素"<<endl;
				cout<<"需要取出多少个数"<<endl;
				int cnt;
				cin>>cnt;
				for(int i=0;i<cnt;i++)
				{
					cout<<"需要取出哪个位置的元素"<<endl;
					int _;
					cin>>_;
					if(ListPop(&L,_)==-1) cout<<"取出元素失败"<<endl;
					else  cout<<ListPop(&L,_)<<endl;
				}
				break;
				
		}
	}
}

😎完整代码2

#include<iostream>
using namespace std;
#define OK 1
#define ERROR -1
typedef struct LNode
{
	int data;
	struct LNode *next;
	
}LNode,*LinkList;


//1
int InitList(LinkList &L)
{
	L=new LNode;
	L->next=NULL;
	return OK;
}

//2
int Create_back(LinkList &L,int num)
{
	L=new LNode;//头节点 
	LNode *p,*r;
	L->next=NULL;
	r=L;
	for(int i=0;i<num;i++)
	{
		p=new LNode;
		cin>>p->data;
		p->next=NULL;
		r->next=p;
		r=p;	
	}	
	return OK;
	
}

//3
int ListInsert(LinkList &L,int num,int place)
{
	LNode *p,*s;
	p=L;
	int j=0;
	while(p&&j<place-1)
	{
		p=p->next;
		j++;
	}
	if(!p||j>place-1) return ERROR;
	s=new LNode;
	s->data=num;
	s->next=p->next;
	p->next=s;
	return OK;
	
}

//4
int LinkDelete(LinkList &L,int place)
{
	LNode *p,*q;
	p=L;
	int j=0;
	while((p->next)&&(j<place-1))
	{
		p=p->next;
		++j;
	} 
	if(!(p->next)||(j>place-1) )return ERROR;
	q=p->next;
	p->next=q->next;
	//e=p->data;
	delete q;
	return OK;
}

//5
int ListPop(LinkList &L,int num)
{
	LNode *p;
	p=L;
	int j=0;
	while(p&&j<num)
	{
		p=p->next;
		j++;
	}
	if(p)
	return p->data;
	else
	return -1;
	
}

void OutputList(LinkList &L)
{
	LNode *p;
	p=L->next;
	while(p)
	{
		cout<<p->data<<' ';
		p=p->next;
	}
	cout<<endl;
}

int main()
{
	LinkList L;
	int n,e;
	cout<<"请输入你的操作"<<endl;
	printf("0:结束程序\n1:建立空表\n2:尾插法建立空表\n3:插入\n4:删除\n5:取出元素\n");
	for(;;)
	{
		cin>>n;
		switch(n)
		{
			case 0:
				return 0;
				break;
			case 1:
				cout<<"建立空表"<<endl;
				if(InitList(L))
				{
					cout<<"建立成功"<<endl;
				}
				else
				{
					cout<<"建立失败"<<endl;
				}
				break;
			case 2:
				cout<<"输入21 18 30 75 42 56，使用尾插法建立链表"<<endl;
				cout<<"请输入要加入的数字的数量"<<endl;
				int num;
				cin>>num;
				if(Create_back(L,num)!=0)
				{
					 cout<<"请进行下一步操作"<<endl;
					 OutputList(L); 
					 
				}
				else cout<<"失败了"<<endl;
				break;
			case 3:
				cout<<"在第3个位置插入67，在第9个位置插入10"<<endl;
				cout<<"请输入需要插入的数字的个数"<<endl;
				int qqq;
				cin>>qqq;
				for(int i=0;i<qqq;i++)
				{
					cout<<"需要插入的数据和位置"<<endl;
					int nn,mm;
					cin>>nn>>mm;
					if(ListInsert(L,nn,mm))
					{
						cout<<"插入成功"<<endl;
						OutputList(L);
					
					}
					else
					{
						cout<<"插入失败"<<endl;
					}
				}
				break;
			case 4:
				cout<<"删除第6个元素和第8个元素"<<endl;
				cout<<"输入需要删除的元素是哪一个"<<endl;
				int qq;
				cin>>qq;
				if(LinkDelete(L,qq))
				{
					cout<<"删除成功"<<endl;
					OutputList(L);
				
				}	
				else
				{
					cout<<"删除失败"<<endl;
				}
				break;
			case 5:
				cout<<"取出第5个元素和第7个元素"<<endl;
				cout<<"需要取出多少个数"<<endl;
				int cnt;
				cin>>cnt;
				for(int i=0;i<cnt;i++)
				{
					cout<<"需要取出哪个位置的元素"<<endl;
					int _;
					cin>>_;
					if(ListPop(L,_)==-1) cout<<"取出元素失败"<<endl;
					else  cout<<ListPop(L,_)<<endl;
				}
				break;
				
		}
	}
}

🥰如果大家有不明白的地方，或者文章有问题，欢迎大家在评论区讨论，指正🥰

Code over！

存储数据结构 lt strong int 算法 c++

有关【数据结构】线性表（顺序存储和链式存储）两种方法，细节满满，保你学会的更多相关文章

ruby - 使用 ruby 将 HTML 转换为纯文本并维护结构/格式 - 2
我想将html转换为纯文本。不过，我不想只删除标签，我想智能地保留尽可能多的格式。为插入换行符标签，检测段落并格式化它们等。输入非常简单，通常是格式良好的html(不是整个文档，只是一堆内容，通常没有anchor或图像)。我可以将几个正则表达式放在一起，让我达到80%，但我认为可能有一些现有的解决方案更智能。最佳答案首先，不要尝试为此使用正则表达式。很有可能你会想出一个脆弱/脆弱的解决方案，它会随着HTML的变化而崩溃，或者很难管理和维护。您可以使用Nokogiri快速解析HTML并提取文本:require'nokogiri'h
ruby - 解析 RDFa、微数据等的最佳方式是什么，使用统一的模式/词汇(例如 schema.org)存储和显示信息 - 2
我主要使用Ruby来执行此操作，但到目前为止我的攻击计划如下:使用gemsrdf、rdf-rdfa和rdf-microdata或mida来解析给定任何URI的数据。我认为最好映射到像schema.org这样的统一模式，例如使用这个yaml文件，它试图描述数据词汇表和opengraph到schema.org之间的转换:#SchemaXtoschema.orgconversion#data-vocabularyDV:name:namestreet-address:streetAddressregion:addressRegionlocality:addressLocalityphoto:i
ruby - Ruby 有 `Pair` 数据类型吗？ - 2
有时我需要处理键/值数据。我不喜欢使用数组，因为它们在大小上没有限制(很容易不小心添加超过2个项目，而且您最终需要稍后验证大小)。此外，0和1的索引变成了魔数(MagicNumber)，并且在传达含义方面做得很差(“当我说0时，我的意思是head...”)。散列也不合适，因为可能会不小心添加额外的条目。我写了下面的类来解决这个问题:classPairattr_accessor:head,:taildefinitialize(h,t)@head,@tail=h,tendend它工作得很好并且解决了问题，但我很想知道:Ruby标准库是否已经带有这样一个类？最佳
ruby - 是否有用于序列化和反序列化各种格式的对象层次结构的模式？ - 2
给定一个复杂的对象层次结构，幸运的是它不包含循环引用，我如何实现支持各种格式的序列化？我不是来讨论实际实现的。相反，我正在寻找可能会派上用场的设计模式提示。更准确地说:我正在使用Ruby，我想解析XML和JSON数据以构建复杂的对象层次结构。此外，应该可以将该层次结构序列化为JSON、XML和可能的HTML。我可以为此使用Builder模式吗？在任何提到的情况下，我都有某种结构化数据-无论是在内存中还是文本中-我想用它来构建其他东西。我认为将序列化逻辑与实际业务逻辑分开会很好，这样我以后就可以轻松支持多种XML格式。最佳答案我最
ruby - 我如何添加二进制数据来遏制 POST - 2
我正在尝试使用Curbgem执行以下POST以解析云curl-XPOST\-H"X-Parse-Application-Id:PARSE_APP_ID"\-H"X-Parse-REST-API-Key:PARSE_API_KEY"\-H"Content-Type:image/jpeg"\--data-binary'@myPicture.jpg'\https://api.parse.com/1/files/pic.jpg用这个:curl=Curl::Easy.new("https://api.parse.com/1/files/lion.jpg")curl.multipart_form_
世界前沿3D开发引擎HOOPS全面讲解——集3D数据读取、3D图形渲染、3D数据发布于一体的全新3D应用开发工具 - 2
无论您是想搭建桌面端、WEB端或者移动端APP应用，HOOPSPlatform组件都可以为您提供弹性的3D集成架构，同时，由工业领域3D技术专家组成的HOOPS技术团队也能为您提供技术支持服务。如果您的客户期望有一种在多个平台（桌面/WEB/APP，而且某些客户端是“瘦”客户端）快速、方便地将数据接入到3D应用系统的解决方案，并且当访问数据时，在各个平台上的性能和用户体验保持一致，HOOPSPlatform将帮助您完成。利用HOOPSPlatform，您可以开发在任何环境下的3D基础应用架构。HOOPSPlatform可以帮您打造3D创新型产品，HOOPSSDK包含的技术有：快速且准确的CAD
ruby - Rack:如何将 URL 存储为变量？ - 2
我正在编写一个简单的静态Rack应用程序。查看下面的config.ru代码:useRack::Static,:urls=>["/elements","/img","/pages","/users","/css","/js"],:root=>"archive"map'/'dorunProc.new{|env|[200,{'Content-Type'=>'text/html','Cache-Control'=>'public,max-age=6400'},File.open('archive/splash.html',File::RDONLY)]}endmap'/pages/search.
FOHEART H1数据手套驱动Optitrack光学动捕双手运动(Unity3D) - 2
本教程将在Unity3D中混合Optitrack与数据手套的数据流，在人体运动的基础上，添加双手手指部分的运动。双手手背的角度仍由Optitrack提供，数据手套提供双手手指的角度。 01 客户端软件分别安装MotiveBody与MotionVenus并校准人体与数据手套。MotiveBodyMotionVenus数据手套使用、校准流程参照：https://gitee.com/foheart_1/foheart-h1-data-summary.git02 数据转发打开MotiveBody软件的Streaming，开始向Unity3D广播数据；MotionVenus中设置->选项选择Unit
使用canal同步MySQL数据到ES - 2
文章目录一、概述简介原理模块二、配置Mysql使用版本环境要求1.操作系统2.mysql要求三、配置canal-server离线下载在线下载上传解压修改配置单机配置集群配置分库分表配置1.修改全局配置2.实例配置垂直分库水平分库3.修改group-instance.xml4.启动监听四、配置canal-adapter1修改启动配置2配置映射文件3启动ES数据同步查询所有订阅同步数据同步开关启动4.验证五、配置canal-admin一、概述简介canal是Alibaba旗下的一款开源项目，Java开发。基于数据库增量日志解析，提供增量数据订阅&消费。Git地址：https://github.co
ruby-on-rails - 创建 ruby 数据库时惰性符号绑定(bind)失败 - 2
我正在尝试在Rails上安装ruby，到目前为止一切都已安装，但是当我尝试使用rakedb:create创建数据库时，我收到一个奇怪的错误:dyld:lazysymbolbindingfailed:Symbolnotfound:_mysql_get_client_infoReferencedfrom:/Library/Ruby/Gems/1.8/gems/mysql2-0.3.11/lib/mysql2/mysql2.bundleExpectedin:flatnamespacedyld:Symbolnotfound:_mysql_get_client_infoReferencedf

【数据结构】线性表（顺序存储和链式存储）两种方法，细节满满，保你学会

⭐定义：

⭐ 理解：

⭐存储方式 ：

⭐顺序存储的优缺点：

优点：

缺点：

⭐链式存储的优缺点：

优点：

缺点：

⭐基本操作

✨顺序存储

🍔存储结构

🎈添加数字建立表

🎈输出线性表里面的数

🎈插入数字

🎈删除数字

🎈取出数字

🎈置空

😎完整代码1

🚌小细节：什么时候使用引用，什么时候不使用引用

😎完整代码2

✨链式存储

🍔存储结构

⭐易错：首元结点VS头节点VS头指针

⭐链表增加头结点的好处

🎈便于首元结点的处理

🎈便于空表和非空表的统一处理

🎈初始化

🎈尾插法建立单链表

🎈头插法建立单链表

🎈插入

🎈删除

🎈取出元素

🎈输出链表

😎完整代码1

😎完整代码2

有关【数据结构】线性表（顺序存储和链式存储）两种方法，细节满满，保你学会的更多相关文章

随机推荐

⭐存储方式：