0
点赞
收藏
分享

微信扫一扫

线性表总结——顺序表和单链表总结

福福福福福福福福福 2022-04-30 阅读 47
数据结构

在这里插入图片描述

#include<iostream>
using namespace std;

//线性表——顺序表的基本操作 （静态分配） 
#define ElemType int
#define MaxSize 10

//类型定义 
typedef struct{
	ElemType data[MaxSize];
	int length;
}SqList; 

//顺序表的基本操作
bool InitList(SqList &L){
	L.length=0;
	return true;
} 

//插入操作-顺序表L的第i个位置（位序为i）(数组下标为：i-1)插入新元素e 
bool ListInsert(SqList &L,int i,ElemType e){
	if(i<1||i>L.length+1)
		return false;
	if(L.length>=MaxSize)
		return false;
	for(int j=L.length+1;j>=i;j--){
		L.data[j]=L.data[j-1];}
	L.data[i-1]=e;
	L.length++;
	return true;
} 

//删除操作- 删除顺序表L的第i个位置的元素，用引用变量e返回 
bool ListDelete(SqList &L,int i,ElemType &e){
	if(i<1||i>L.length)return false;
	e=L.data[i-1];
	for(int j=i;j<L.length;j++){
		L.data[j-1]=L.data[j];
	}
	L.length--;
	return true;
} 

//按值查找-在顺序表中查找第一个元素值等于e的元素，并返回其位序
int LocateElem(SqList &L,ElemType e){
	for(int i=0;i<L.length;i++)
		if(L.data[i]==e)
			return i+1;	
	return 0;
} 

//输出操作
void PrintList(SqList &L){
	printf("当前数列中的元素为： ");
	for(int i=0;i<L.length;i++){
		printf("%d  ",L.data[i]);
	}
	printf("\n");	
} 
void testSqList()
{
	ElemType e;
	SqList L;
	
	InitList(L);
	
	ListInsert(L,1,0);
	ListInsert(L,2,1);
	ListInsert(L,3,2);
	ListInsert(L,4,3);
	PrintList(L);
	
	ListDelete(L,1,e);
	printf(" e = %d \n",e);
	PrintList(L);
	
	int loc=LocateElem(L,3);
	printf("loc = %d \n",loc);
 } 
int main()
{
	testSqList();
	return 0; 
 } 

#include<iostream>
#include<malloc.h>
using namespace std;

//线性表——顺序表的基本操作 （动态分配） 
#define ElemType int
#define MaxSize 10

//类型定义
typedef struct{
	ElemType *data;
	int length;
}SqList; 

//顺序表的基本操作
//初始化操作 
bool InitList(SqList &L){
	L.data=(ElemType *)malloc(sizeof(SqList)*MaxSize);
	if(!L.data){
		cout<<"内存分配失败"<<endl<<endl;
		return false;
	}
	L.length=0;
	cout<<"内存分配成功"<<endl<<endl;
	return true;
} 
 
//插入操作-顺序表L的第i个位置（位序为i）(数组下标为：i-1)插入新元素e 
bool ListInsert(SqList &L,int i,ElemType e){
	if(i<1||i>L.length+1)
		return false;
	if(L.length>=MaxSize)
		return false;
	for(int j=L.length+1;j>=i;j--){
		L.data[j]=L.data[j-1];}
	L.data[i-1]=e;
	L.length++;
	return true;
} 

//删除操作- 删除顺序表L的第i个位置的元素，用引用变量e返回 
bool ListDelete(SqList &L,int i,ElemType &e){
	if(i<1||i>L.length)return false;
	e=L.data[i-1];
	for(int j=i;j<L.length;j++){
		L.data[j-1]=L.data[j];
	}
	L.length--;
	return true;
} 

//按值查找-在顺序表中查找第一个元素值等于e的元素，并返回其位序
int LocateElem(SqList &L,ElemType e){
	for(int i=0;i<L.length;i++)
		if(L.data[i]==e)
			return i+1;	
	return 0;
} 

//输出操作
void PrintList(SqList &L){
	printf("当前数列中的元素为： ");
	for(int i=0;i<L.length;i++){
		printf("%d  ",L.data[i]);
	}
	printf("\n");	
} 
void testSqList()
{
	ElemType e;
	SqList L;
	
	InitList(L);
	
	ListInsert(L,1,0);
	ListInsert(L,2,1);
	ListInsert(L,3,2);
	ListInsert(L,4,3);
	PrintList(L);
	
	ListDelete(L,1,e);
	printf(" e = %d \n",e);
	PrintList(L);
	
	int loc=LocateElem(L,0);
	printf("loc = %d \n",loc);
 } 
int main()
{
	testSqList(); 
	return 0;
 } 

#include<iostream>
#include<malloc.h>
using namespace std;
 

#define ElemType int
 
typedef struct LinkNode{
	ElemType data;
	LinkNode *next;
} *LinkList; 

//单链表的基本操作 

bool List_HeadInsert(LinkList &L);//头插法创建单链表 （带头结点） 

bool List_HeadInsert_no(LinkList &L);//头插法创建单链表 （不带头结点） 

bool List_TailInsert(LinkList &L);//尾插法建立单链表（带头结点） 

bool List_TailInsert_no(LinkList &L);//尾插法建立单链表（不带头结点） 

LinkNode *GetElem(LinkList L,int i);// 按序号查找结点值,返回该结点的地址（带头结点） 

LinkNode *GetElem_no(LinkList L,int i);//按序号查找结点值,返回该结点的地址（不带头结点） 

int LocateElem(LinkList L,ElemType e);//按值查找表结点(返回位序)（带头结点） 

int LocateElem_no(LinkList L,ElemType e);//按值查找表结点（返回位序）（不带头结点） 

void PrintList(LinkList &L);//输出顺序表中的元素（带头结点）

void PrintList_no(LinkList &L);//输出顺序表中的元素（不带头结点）

//1.用头插法建立单链表(带头结点) 
bool List_HeadInsert(LinkList &L){
	int x;
	LinkList s;

	L=(LinkList)malloc(sizeof(LinkNode));
	L->next=NULL; 
	if(L==NULL)return false;
	
	cout<<"请输入插入元素："<<endl; 
	cin>>x;
	while(x!=-1){
		s=(LinkList)malloc(sizeof(LinkNode));
		s->data=x;
		s->next=L->next;
		L->next=s;
		cin>>x;
	}
	return true;
}

//1.用头插法建立单链表（不带头结点） 
bool List_HeadInsert_no(LinkList &L){
	int x;
	LinkList s;
	
	cout<<"请输入插入元素："<<endl; 
	cin>>x;
	while(x!=-1){
		s=(LinkList)malloc(sizeof(LinkNode));
		s->data=x;
		if(L==NULL){
			L=s;
			L->next=NULL;
		}
		else{
			s->next=L;
			L=s;
		}
		cin>>x;
	}
	return true;
}


//2.用尾插法建立单链表（带头结点） 
bool List_TailInsert(LinkList &L){
	int x;
	L=(LinkList)malloc(sizeof(LinkNode));
	if(!L){return false;}
	LinkList s,t=L;
	cout<<"请输入插入元素："<<endl; 
	cin>>x;
	while(x!=-1){
		s=(LinkNode *)malloc(sizeof(LinkNode));
		s->data=x;
		t->next=s;
		t=s;
		cin>>x;
	}
	t->next=NULL;
	return true;
}

//2.用尾插法建立单链表（不带头结点） 
bool List_TailInsert_no(LinkList &L){
	ElemType x;
	LinkNode *s,*t;
	cout<<"请输入插入值："<<endl;
	cin>>x;
	while(x != -1){
		//为待加入的结点分配内存并初始化 
		s=(LinkNode *)malloc(sizeof(LinkNode));
		s->data=x;
		s->next=NULL;
		
		if(L==NULL){	//链表为空
			L=s;
			t=L;
		} 
		else{			//链表不为空 
			t->next=s;
			t=s;
		}
		cin>>x;
	}
	return true; 
} 

//3.按序号查找结点值,返回该结点的地址（带头结点） 
LinkNode *GetElem(LinkList L,int i){
	LinkNode *p=L->next;
	int j=1;
	if(i<1)return NULL;
	if(i==0)return L;
	while(p&&j<i){
		p=p->next;
		j++;
	}
	return p;
}
//3.按序号查找结点值,返回该结点的地址(不带头结点)
LinkNode *GetElem_no(LinkList L,int i){
	LinkNode *p=L;
	int j=1;
	if(i<1)return NULL;
	if(i==0)return p;
	while(p&&j<i){
		p=p->next;
		j++;
	}
	return p;
}
//4.按值查找表结点(返回位序)（带头结点） 
int LocateElem(LinkList L,ElemType e){
	LinkNode *p=L->next;
	int i=1;
	while(p){
		if(p->data==e)return i;
		p=p->next;i++;
	}
	return 0;
}

//4.按值查找表结点(返回位序)（不带头结点） 
int LocateElem_no(LinkList L,ElemType e){
	LinkNode *p=L;
	int i=1;
	while(p){
		if(p->data==e)return i;
		p=p->next;i++;
	}
	return 0;
}

//输出顺序表中的元素（带头结点） 
void PrintList(LinkList &L){
	LinkNode *p=L;
	if(!p->next){
		return;
	}
	while(p=p->next){
		cout<<p->data<<"   ";
	}
	cout<<endl;
}
//输出顺序表中的元素（不带头结点）
void PrintList_no(LinkList &L){
	LinkNode *p=L;
	while(p){
		cout<<p->data<<"   ";
		p=p->next;
	}
	cout<<endl;
	return; 
}

void testLinkList(){
	LinkList L=NULL;
//头插法 
//	List_HeadInsert(L);
//	PrintList(L);
//	List_HeadInsert_no(L);
//	PrintList_no(L);

//尾插法 
//	List_TailInsert(L);
//	PrintList(L);
//	List_TailInsert_no(L);
//	PrintList_no(L);

	
//	LinkNode *p=GetElem(L,2);
//	LinkNode *p=GetElem_no(L,2);
//	cout<<"第二个元素为："<<p->data<<endl;
//	cout<<LocateElem(L,3)<<endl;
//	cout<<LocateElem_no(L,2)<<endl;
	
}
int main()
{
	testLinkList();
	return 0;
}
举报

相关推荐

线性表——顺序表，单向链表和双向链表

链表java数据结构

线性表——单链表

spring bootjava后端

线性表--顺序表--静态链表(八)

指针链表数据结构数据结点HarmonyOS后端开发

线性表：顺序表

线性表顺序表数据结构与算法人工智能

【Python】数据结构——线性表（顺序表、单链表、循环单链表、双链表、循环双链表）

python数据结构链表

线性表之【顺序表】

c++c语言开发语言

链表(线性表)

#include链表结点JavaScript前端开发

线性表的顺序存储——顺序表

数据结构算法顺序表数据sqlLinux系统/运维

线性表-带头结点的单链表

链表数据结构散列表

数据结构线性表——单链表

c#锁屏winform息屏
0 条评论