C语言单链表和顺序表的基本操作

最新推荐文章于 2024-05-18 14:57:40 发布
最新推荐文章于 2024-05-18 14:57:40 发布
阅读量2.1k 收藏 22
点赞数 3
文章标签： 学校数据结构 C单链表顺序表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/BO688/article/details/101601031
版权

笔者当初学的时候不熟悉结构，很容易出错

因为本人不是专学C，所以有些知识不是很懂

顺序表

typedef struct{
ElemType *elem; //存储空间的基地址
int length; //当前长度
}SqList;

  1. 顺序表结构比较简单，只需要在一个结构体中，加入一个数组，和一个表示数组长度的数
  2. *elem 的意思是指向一个地址==指针
  3. 所有的操作都基于结构体中的数组和长度

顺序表操作

#include<iostream>
using namespace std;
#define OK 1
#define ERROR 0
#define OVERFLOW -2
typedef int Status;	   //Status 是函数返回值类型，其值是函数结果状态代码。
typedef int ElemType;  //ElemType 为可定义的数据类型，此设为int类型

#define MAXSIZE 100	  //顺序表可能达到的最大长度

typedef struct{
	ElemType *elem;	  //存储空间的基地址
	int length;		  //当前长度
}SqList;

Status InitList_Sq(SqList &L){ //功能1--算法2.1 顺序表的初始化
	//构造一个空的顺序表L
	L.elem=new ElemType[MAXSIZE]; //为顺序表分配一个大小为MAXSIZE的数组空间
	if(!L.elem)  exit(OVERFLOW);  //存储分配失败
	L.length=0;	    	//空表长度为0
	return OK;
}

Status ListInsert_Sq(SqList &L,int i,ElemType e){ //功能3--算法2.3 顺序表的插入
	//在顺序表L中第i个位置之前插入新的元素e
	//i值的合法范围是1<=i<=L.length+1
	if(i<1 || i>L.length+1)	return ERROR;		//i值不合法
	if(L.length==MAXSIZE)	return ERROR;		//当前存储空间已满
	for(int j=L.length-1;j>=i-1;j--)
		L.elem[j+1]=L.elem[j];					//插入位置及之后的元素后移
	L.elem[i-1]=e;								//将新元素e放入第i个位置
	++L.length;									//表长增1
	return OK;
}

void display(SqList L){ //功能4--依次显示顺序表L中的全部数据元素
    if(L.length==0) {cout<<"空表"<<endl; return ;}  //空白，直接返回
	cout<<"表中元素依次为：";
	for(int i=0;i<L.length;i++)
		cout<<L.elem[i]<<" ";
	cout<<"，共有"<<L.length<<"个元素。"<<endl;
}
int LocateElem_Sq(SqList L,ElemType e) { //功能5. 顺序表的查找
	
	if(L.length==0) {cout<<"空表"<<endl; return ERROR;}
	for (int i = 0; i < L.length; i++)
		if (L.elem[i] == e)
			return i + 1;//查找成功，返回序号i+1
	return 0;//查找失败，返回0
}
Status ListDelete_Sq(SqList &L, int i) { //功能6. 顺序表的删除
	//在顺序表L中删除第i个元素，并用e返回其值
	//i值的合法范围是1<=i<=L.length
	if(L.length==0) {cout<<"空表"<<endl; return ERROR;}  //空白，直接返回
	if ((i < 1) || (i > L.length))
		return ERROR; //i值不合法
	for (int j = i; j <= L.length; j++)
		L.elem[j - 1] = L.elem[j]; //被删除元素之后的元素前移
	--L.length; //表长减1
	return OK;
}

Status GetmaxPlaceAndItem(SqList L,ElemType &a,ElemType &b) {//功能7.　顺序表的取值及位置
	if(L.length==0) {cout<<"空表"<<endl; return ERROR;}  //空白，直接返回
	int i;
    b=L.elem[0];
	a=1;

	for(i=1;i<=L.length;i++)
	{
		if(b<=L.elem[i-1])
		{
			b=L.elem[i-1];
			a=i;
		}
	}

	return OK;
}
Status ListDelete_Sq(SqList &L) {
	//功能8. 顺序表最小的删除

	//i值的合法范围是1<=i<=L.length
	if(L.length==0) {cout<<"空表"<<endl; return ERROR;}  //空白，直接返回
	int e=L.elem[0];
	int x=0;
	for (int i =1; i <=L.length; i++)
	{
		if(e>=L.elem[i-1])
		e=L.elem[i- 1];
		x=i-1;
		} 
	for (int j = x; j <= L.length; j++)
		L.elem[j - 1] = L.elem[j];//被删除元素之后的元素前移

	--L.length;//表长减1
	return OK;
}
Status reverse(SqList &L){//

	int temp;//
	if(L.length==0) {cout<<"空表"<<endl; return ERROR;}//空白，直接返回
	for(int i=0;i<L.length/2;i++){//在中间对半进行交换
	 temp=L.elem[i];
	 L.elem[i]=L.elem[L.length-i-1];
	 L.elem[L.length-i-1]=temp;
}
	return OK;
}
Status deleteItem(SqList &L,int item){
		if(L.length==0) {cout<<"空表"<<endl; return ERROR;}//空白，直接返回
		int count=0;
	for (int i =1; i <=L.length; i++)
	{
		cout<<"大";
		if(item==L.elem[i-1]){
			
			cout<<"相等";
			
			count++;//计算长度

			for(int j =i; j <=L.length+1; j++){

			L.elem[j-1]=L.elem[j];
			}
			i--;//i往后退一个
				L.length--;//减少长度

		}
	}


	
	return OK;
}
int main()
{
	SqList L;
	int i,count,temp=0,choose;
	ElemType x;
	choose=-1;  count=0; //count专门用于控制菜单显示，不要做其他用途
	while(choose!=0)
	{
		if(count%5==0)
		{	cout<<"**********************************************************************\n";
			cout<<"1. 建立空表                              2. 在表中输入指定个数元素\n";
			cout<<"3. 在第i个元素的前面插入一个元素         4. 逐个显示表中元素\n";
			cout<<"5. 依值查找                              6. 删除表中第i个元素\n";
			cout<<"7. 返回表中值最大元素及其在表中位置      8. 删除线性表中值最小的数据元素\n";
			cout<<"9. 逆置线性表                            10.删除表中所有值为item的元素\n";
			cout<<"11.重置为空表                            0. 退出\n";
			cout<<"**********************************************************************\n";
		}
		count++;
		cout<<"请选择：";
		cin>>choose;
		switch(choose)
		{
		case 1:
			if(InitList_Sq(L))						//创建顺序表
				cout<<"成功建立顺序表\n\n";
			else
				cout<<"顺序表建立失败\n\n";
			break;
		case 2:										
			cout<<"请输入一个数，代表元素的个数：";
			cin>>L.length;
			cout<<"请输入"<<L.length<<"个元素的数据(以空格隔开，按回车结束)：";
			for(i=0;i<L.length;i++)
				cin>>L.elem[i];
			display(L); cout<<endl;
			break;
		case 3:	//顺序表的插入
			cout<<"请输入两个数，分别代表插入的位置和插入数值(用空格间隔，最后回车)：";
			cin>>i>>x;				//输入i和x，i代表插入的位置，x代表插入的数值
			cout<<"插入之前--";   display(L);
			if(ListInsert_Sq(L,i,x))
			{
				cout<<"插入成功--";  display(L);  cout<<endl;
			}
			else
			{
				cout<<"插入失败--";  display(L);  cout<<endl;
			}
			break;
		case 4:	//顺序表的输出
			display(L);  cout<<endl;
			break;
		case 5:	//顺序表的依值查找
				cout<<"请输入一个数查找";
			cin>>x;				//输入x进行查找
			cout<<"执行之前--";   display(L);
			i=LocateElem_Sq(L,x);
			if(i){
			cout<<"查找成功--序位为："<<i;   cout<<endl;
			}else{
				cout<<"查无";   cout<<endl;
			}
			cout<<"执行之后--"; display(L);
			break;
	   case 6:	//顺序表的删除
				cout<<"请输入一个序号进行删除";
			cin>>x;				//输入x位置进行删除
		cout<<"执行之前--";   display(L);
		i=ListDelete_Sq(L,x);
			if(i){
			cout<<"删除成功--序位为："<<i;   cout<<endl;
			}else{
				cout<<"删除失败--";   cout<<endl;
			}
		cout<<"执行之后--";   display(L);
			break;
		case 7:	//顺序表的返回最大数及其位置
			cout<<"顺序表的返回最大数及其位置"<<endl;
		cout<<"执行之前--";   display(L);
			int a,b;
			if(GetmaxPlaceAndItem(L,b,a)){
			cout<<"成功返回最大数："<<a<<"其位置："<<b;	
			}else{
			cout<<"返回失败";
			}
		cout<<"执行之后--";   display(L);
			cout<<endl;
			break;
		case 8:	//顺序表删除最小数
			cout<<"顺序表删除最小数"<<endl;	
		cout<<"执行之前--";   display(L);
			if(ListDelete_Sq(L)){
			cout<<"顺序表的删除最小数成功";	
			}else{
			cout<<"返回失败";
			}
	cout<<"执行之后--";   display(L);
			cout<<endl;
			break;
		case 9:	//顺序表倒序
			cout<<"顺序表倒序"<<endl;	
			cout<<"执行之前--";   display(L);
			if(reverse(L)){
			cout<<"顺序表倒序成功";	
			}else{
			cout<<"返回失败";
			}
		cout<<"执行之后--";   display(L);
			cout<<endl;
			break;
	case 10:	//顺序表删除输入相同的数
			cout<<"顺序表删除输入的相同数:"<<endl;	
		cin>>x;
		cout<<"执行之前--";   display(L);

		if(deleteItem(L,x)){
			cout<<"删除成功"<<endl;	
		}else{
			cout<<"删除失败"<<endl;	
		}
		cout<<"执行之后--";   display(L);
			cout<<endl;
			break;

		case 11: //重置为空表。
			L.length=0;  display(L);  cout<<endl;
			break;
		}
	}
	return 0;
}

单链表操作

typedef struct LNode
{
ElemType data; //结点的数据域
struct LNode *next; //结点的指针域
}LNode,*LinkList;
Status InitList_L(LinkList &L){ /
L=new LNode; //生成新结点作为头结点，用头指针L指向头结点
L->next=NULL; //头结点的指针域置空
return OK;
}

  1. 单链表结构是一个带有嵌套的结构体，一个指向另一个
  2. 结构体定义LNode,*LinkList有些不同，LNode是直接给一个空间，LinkList是给一个指针还需要自行给它空间需要用到malloc函数
#include<iostream>
using namespace std;

#define OK 1
#define ERROR 0
#define OVERFLOW -2
typedef int Status;		//Status 是函数返回值类型，其值是函数结果状态代码。
typedef int ElemType;	 //ElemType 为可定义的数据类型，此设为int类型

typedef struct LNode
{
	ElemType data;	//结点的数据域
	struct LNode *next;		//结点的指针域
}LNode,*LinkList;  //LinkList为指向结构体LNode的指针类型

Status InitList_L(LinkList &L){	//功能1---算法2.5 单链表的初始化
	//构造一个空的单链表L
	L=new LNode;	//生成新结点作为头结点，用头指针L指向头结点
	L->next=NULL;    //头结点的指针域置空
	return OK;
}

Status ListInsert_L(LinkList &L,int i,ElemType &e){ //功能3---算法2.8 单链表的插入
	//在带头结点的单链表L中第i个位置之前插入元素e
	int j;
	LinkList p,s;
	p=L;j=0;
	while(p && j<i-1){p=p->next;++j;} //寻找第i-1个结点
	if(!p||j>i-1)	return ERROR;	//i大于表长+1或者小于1
	s=new LNode;	//生成新结点s
	s->data=e;		//将结点s的数据域置为e
	s->next=p->next; //将结点s插入L中
	p->next=s;
	return OK;
}//ListInsert_L

void display(LinkList L){ //功能4--依次显示单链表L中的全部数据元素
	LinkList p=L->next; 
	if(!p) {cout<<"空表"<<endl; return;}  //空白，直接返回
	cout<<"表中元素依次为：";
	int i=0;
	while(p)
	{
       i++;
	   cout<<p->data<<" ";
	   p=p->next;
	}
	cout<<"，共有"<<i<<"个元素。"<<endl;
}

void CreateList_F(LinkList &L,int n){ //算法2.10 前插法创建单链表
	//逆位序输入n个元素的值，建立到头结点的单链表L
	LinkList p;
	L=new LNode;
	L->next=NULL; 	//先建立一个带头结点的空链表
	cout<<"请输入 "<<n<<" 个数(以空格隔开，按回车结束)：";
	for(int i=n;i>0;--i){
		p=new LNode; 	//生成新结点
		cin>>p->data;   //输入元素值
		p->next=L->next;L->next=p;  //插入到表头
	}
}//CreateList_F

void CreateList_L(LinkList &L,int n){ //算法2.11 后插法创建单链表
	//正位序输入n个元素的值，建立到头结点的单链表L
	L=new LNode; //先建立一个带头结点的空链表
	LinkList r=L;          //尾指针r总是指向链表当前最末尾结点
	cout<<"请输入 "<<n<<" 个数(用空格间隔，最后回车)：";
	for(int i=0;i<n;i++){
		r->next=new LNode; 	//生成新结点
		r=r->next;        	//r指向新的尾结点
		cin>>r->data;  	//输入元素值
	}
	r->next=NULL; 
}//CreateList_L

int GetElem(LinkList &L,int e,ElemType &a)//功能五：输入一个序位进行查找
{
	
	int j=0;
	LinkList p=L;
	p=p->next;//
	if(!p) {cout<<"空表"<<endl; return 0;}  //空白，直接返回
	while (p!=NULL)//循环遍历查找
	{
		j++;
		if(j==e)
		{
		 a=p->data;	
		return 1;
		}
		
		p=p->next;
	}
	return 0;//查无返回0

}
int GetElem(LinkList &L,ElemType &e)//功能六：输入一个数进行查找
{
	
	int j=0;
	LinkList p=L;//
	if(!p) {cout<<"空表"<<endl; return 0;}  //空白，直接返回
	while (p!=NULL)//循环遍历查找
	{
		j++;
		if(p->data==e)
		{
			
		return j;
		}
		
		p=p->next;
	}
	return 0;//查无返回0

}
int ListDelete(LinkList &L,int i,ElemType &e)//功能七：删除输入的序位节点
{
	int j=0;
	LinkList p=L,q;
	if(!p) {cout<<"空表"<<endl; return 0;}  //空白，直接返回
	while (j<i-1 && p!=NULL)
	{
		j++;
		p=p->next;
	}
	if (p==NULL)				/*未找到第i-1个结点*/
		return 0;
	else						/*找到第i-1个结点*p*/
	{
		q=p->next;              /*q指向要删除的结点*/
		if(q==NULL) return 0;   /*不存在第i个结点*/
        e=q->data;  
		p->next=q->next;		/*从单链表中删除*q结点*/
		free(q);				/*释放*q结点*/
		return 1;
	}
}
int GetMax(LinkList L,ElemType &e)//功能八：获得单链表中最大值
{
	LinkList p=L;
	if(!p) {cout<<"空表"<<endl; return 0;}  //空白，直接返回
	p=p->next;
	e=p->data;
	while(p!=NULL)
	{
		if(e<=p->data){
		e=p->data;
		}
		p=p->next;

	}
	return 1;
}
int Reverse(LinkList &L)//功能九：逆序单链表
{
	LinkList p,q,w; 
		w=q=p=L;
	int count=0;
	if(!p) {cout<<"空表"<<endl; return 0;}  //空白，直接返回
	p=p->next;
	int temp;
	while(p!=NULL)
	{
		count++;
		p=p->next;

	}

	
	for(int j=1;j<=count/2;j++){
		

	for(int t=0;t<j;t++)
	{
			
q=q->next;

	}
		for(int h=count;h>=j;h--)
	{
	
w=w->next;
	}
	temp=q->data;
	q->data=w->data;
	w->data=temp;
	q=w=L;
		
	}
	return 1;
	
}
int deleteitem(LinkList &L,int a){//功能十：删除输入相同的数

	LinkList q,p=L;
	
	if(!p) {cout<<"空表"<<endl; return 0;}  //空白，直接返回
	
	while(p!=NULL){
		
		    q=p;
			p=p->next;
			
			if(p->data==a){
			
                          /*q指向要删除的结点*/
               
		       q->next=p->next;		/*从单链表中删除*q结点*/
		      		
				
				return 1;
			}
			

	
	}return 0;
}
int main()
{
	int i,n,choose;
	ElemType x;
	LinkList L,p;
	choose=-1;  
	int count=0; //count专门用于控制菜单显示，不要做其他用途
	while(choose!=0)
	{
		if(count%5==0)
		{	cout<<"**********************************************************************\n";
			cout<<"  1. 建立空链表;                          2. 在表中输入指定个数的数据元素\n";
			cout<<"  3. 在第i个元素的前插入一个元素;         4. 逐个显示表中数据元素\n";
			cout<<"  5. 查找位序为i的元素，返回其值;         6. 依值查找，返回其位序\n";
			cout<<"  7. 删除表中第i个元素;                   8. 返回值最大的元素及其在表中位置\n";
			cout<<"  9. 就地逆置;                            10. 删除表中所有值为item的数据元素\n";
			cout<<"  0. 退出\n";
			cout<<"*******************************************************************************\n";
		}
		count++;
		cout<<"请选择：";
		cin>>choose;
		switch(choose)
		{
		case 1:	  //建立一个单链表
			if(InitList_L(L))
				cout<<"成功建立链表!\n\n";
			break;
		case 2:	 //功能2---使用后插法创建单链表
			cout<<"请输入一个数，代表元素的个数：";
			cin>>n;
			CreateList_L(L,n);
			cout<<"成功创建链表---"; display(L); cout<<endl;
			break;
		case 3:  //单链表的插入
			cout<<"请输入两个数，分别代表插入的位置和插入数值(用空格间隔，最后回车)：";
			cin>>i>>x;				//输入i和x，i代表插入的位置，x代表插入的数值
			cout<<"插入之前--";   display(L);
			if(ListInsert_L(L,i,x))
			{
				cout<<"插入成功--";  display(L);  cout<<endl;
			}
			else
			{
				cout<<"插入失败--";  display(L);  cout<<endl;
			}
			break;
		case 4:	 //单链表的输出
			display(L);  cout<<endl;
			break;
		case 5:	 //依位序查找，返回查找的值
			cout<<"执行前"<<endl;
			display(L);
			cout<<"输入一个序位进行查找返回值"<<endl;

			cin>>x;
			int a;
			if(GetElem(L,x,a)){
			cout<<"查找成功！序位为"<<x<<"值为"<<a<<endl;
			}else{
				cout<<"查找失败"<<endl;

			}



			cout<<"执行后"<<endl;
			display(L);
			cout<<endl;

			break;

		case 6:	 //依值查找，返回查找值元素的序位
			cout<<"执行前"<<endl;
			display(L);
			cout<<"输入一个值进行查找返回序位"<<endl;

			cin>>x;
						
			if(GetElem(L,x)){
			cout<<"查找成功！序位为"<<GetElem(L,x)-1<<"值为"<<x<<endl;
			}else{
				cout<<"查找失败"<<endl;

			}



			cout<<"执行后"<<endl;
			display(L);
			cout<<endl;

			break;
		case 7:	 //删除指定位置节点
			cout<<"执行前"<<endl;
			display(L);
			cout<<"输入一个序位进行删除返回该值"<<endl;

			cin>>x;
			int b;
			if(ListDelete(L,x,b)){
			cout<<"删除成功！序位为"<<x<<"值为"<<b<<endl;
			}else{
				cout<<"删除失败"<<endl;

			}



			cout<<"执行后"<<endl;
			display(L);
			cout<<endl;

			break;
		case 8:	 //显示最大数
			cout<<"执行前"<<endl;
			display(L);
			int d;
			if(GetMax(L,d)){
			cout<<"显示成功,最大数:"<<d<<endl;
			}else{
				cout<<"显示失败"<<endl;


			}
			

			
			cout<<"执行后"<<endl;
			display(L);
			cout<<endl;

			break;
			break;



		case 9:	 //单链表逆序
			cout<<"执行前"<<endl;
			display(L);
		
			if(Reverse(L)){
			cout<<"逆序成功"<<endl;
			}else{
				cout<<"逆序失败"<<endl;


			}
			

			
			cout<<"执行后"<<endl;
			display(L);
			cout<<endl;

			break;
		case 10:	 //删除输入的数
			cout<<"执行前"<<endl;
			display(L);
				cout<<"输入一个数删除"<<endl;
				cin>>x;

		
			if(deleteitem(L,x)){
			cout<<"成功删除："<<x<<endl;
			}else{
				cout<<"显示失败"<<endl;


			}
			

			
			cout<<"执行后"<<endl;
			display(L);
			cout<<endl;

			break;
		



		}
	}
	return 0;
}
B0OO
关注
  • 3
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
(数据结构C语言版)顺序表和单链表的逆置.docx
07-07
以下是顺序表和单链表的逆置操作的C语言程序代码： 顺序表逆置操作： ```c #include #include #define MAX_LIST_SIZE 100 typedef struct { int *elem; int length; } list_node; list_node L; void init()...
在顺序表中第五个位置插入一个元素9，实现顺序表插入的基本操作，输出顺序表中所有元素
Zhangguohao666的博客
12-15 6908
题目 在顺序表中第五个位置插入一个元素9，实现顺序表插入的基本操作，输出顺序表中所有元素 #include&lt;iostream&gt; using namespace std; #define OK 1 #define ERROR 0 #define OVERFLOW -2 typedef int Status; //Status 是函数返回值类型，其值是函数结果状态代码。 typedef ...
单链表的插入操作（全）
热门推荐
Boyt1317的博客
05-04 2万+
单链表的插入（全） 三种方式进行插入操作
顺序表、链表——c语言实现
最新发布
2302_77041624的博客
05-18 834
我们先来初始化一个顺序表，用malloc函数先给数组动态开辟四个空间，每个空间的大小为我们需要存放的数据类型的大小，此时表中没有数据，令size为0，capacity为4。这种结构出现较多，我们以这个实现链表。，这个地址所存放的变量的数据类型是SLDataType，在这里定义为int类型，如果需要存放其它类型的数据，只需要改变语句中的int为想要存储的数据类型即可。这里面cur实参，head形参，如果直接用head的话，会改变head的值，导致head指向的链表丢失，所以用cur来遍历链表。
顺序表
Hanks软件库
02-19 738
#define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0 #define INFEASIBLE -1 #define OVERFLOW -2 #define LIST_INIT_SIZE 15 #define LIST_INCREMENT 10 #include #include #include typedef int Status;
【C++】单链表的创建、插入、删除
要恰饭得嘛
11-24 799
1.前言 最近没啥心情搞机器人，一直在仿真，输了呀。索性搞搞C++算法。虽然大二的时候学过数据结构，但是上的太水了。。。不过基本概念还是很清楚，所以就简单的用程序实现一下吧，顺便学习了： struct结构体 还有指针的应用 2.代码实现 首先定义结构体Node，来为每个结点定义，我理解的结构体为一种新的数据类型，相当于int、double这种，只不过该数据类型里面又有很多小的数据，不知道...
用C语言实现单链表的基本操作（附有完整代码）
m0_64365419的博客
10-22 7783
单链表的基本概念和定义以及实现过程。
基于C语言实现单链表的基本操作
03-25
本篇将详细介绍如何使用C语言来实现单链表的基本操作。 首先，我们需要定义链表节点的结构体。一个链表节点通常包含两部分：数据域和指针域。数据域用于存储数据，而指针域则指向下一个节点。在C语言中，这可以表示...
C语言单链表版学生信息管理系统
01-20
//以单链表作为存储结构，设计和实现课程成绩管理的完整程序。 //程序包括如下功能。 //1.建立学生成绩表，包含学生的学号、姓名和成绩。 //2.可以显示所有学生成绩。 //3.可以计算学生的总数。 //4.可以按学号和...
C语言顺序表_单链表_双链表代码.zip
03-30
本压缩包"**C语言顺序表_单链表_双链表代码.zip**"提供了C语言实现的三种基本数据结构——顺序表、单链表和双链表的源代码，这些代码适用于初学者学习和实践。以下将详细介绍这三种数据结构及其应用。 **1. 顺序表*...
C语言单链表实现19个功能完全详解.zip_C语言_C语言单链表_单链表
09-20
本文将详细解析如何使用C语言来实现单链表，并涵盖了19种不同的操作功能，帮助你深入理解这一核心概念。 单链表由一系列节点组成，每个节点包含两部分：数据域（用于存储数据）和指针域（指向下一个节点）。链表的...
单链表的插入操作
apple_2021的博客
08-01 751
单链表的插入操作（代码） #include<iostream> using namespace std; typedef struct LNode{ int data; struct LNode *next; }LNode,*LinkList; // 头插法建立单链表 LinkList HeadList(LinkList &L){ L = (LinkList)malloc(sizeof(LNode)); L->next = NULL; int x; LNode *p
单链表操作删除，插入，创建操作
u013669716的专栏
09-23 250
#include<stdio.h> #include<stdlib.h> #define ERROR -1 #define OK 1 typedef int status; typedef struct lnode { int data; struct lnode *next; }lnode ,*linklist; in...
顺序表的基本操作
qq_45917176的博客
06-30 2919
数据结构--顺序表的基本操作
单链表的插入
m0_54750251的博客
07-03 96
#include<iostream> using namespace std; typedef struct node { int data; node* next; }; class List { private: node* head, * last; public: List()//初始化 { head = new node; head->next = NULL; last = head; } void CreateList()//链表创建 { co.
c语言,c++顺序表操作（创建、插入、查找、显示、删除、有序合并、排序）
Systemas的博客
02-27 3614
C++链表 **这次链表操作包括 “链表初始化” “链表创建“ ”链表插入“ ”链表查找“ ”链表显示“ ”链表删除“ ”链表有序合并“；链表是c++的一个难点，这次我为大家献上了我的教程。 这也是我的第一篇博客因为本人也是一位大学生，学习时间紧所以不经常发博客，此次老师留作业要做链表操作，本来链表也是难点同学们也需要理解，这次共享望大家支持点赞。 下面是整体的代码 #include...
数据结构基础 线性表之单链表
山野有雾灯
04-12 1427
单链表的操作 1、初始化 写在程序前面 #include <iostream> using namespace std; #define OK 1; #define ERROR 0;//函数结果状态代码 typedef int Elemtype;//先把Elemtype 定义为int型 typedef int Status;//函数运行状态函数 （1）创建一个结点 struct LNode{ Elemtype data; struct LNode* next;//结点类型的指针
单链表基本操作实现
m0_74250742的博客
01-03 155
单链表基本操作实现 #include<iostream> #include<stdlib.h> using namespace std; #define ERROR 0 #define OK 1 typedef int ElemType; typedef int Statue; typedef struct LNode{ ElemType data; struct LNode*next; } LinkList; //初始化链表 LinkList*InitLink
单链表（建表、查找、插入、删除、清空、判空）
程序员，他们想的是什么?他们想的永远都是技术，他们崇尚的也永远都是技术。
07-21 266
建表、查找、插入、删除都使用了两种方法；分别调用两种方法测试效果。
C语言实现单链表的类定义及其操作
在C语言的数据结构课程中，单链表是一种常见的非顺序存储结构，...总结来说，本课程介绍了如何在C语言中通过类定义来构建单链表，并探讨了顺序表和链表的不同特性和操作方法，这对于理解和实现各种数据结构至关重要。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值