c 数据结构与算法数据结构c+

转载

互联网小思悟 2023-06-07 10:02:05

文章标签 c++ 数据结构开发语言结点头结点 文章分类 代码人生

一、创建结构体

1.图解

2.代码

二、初始化

1.算法步骤

2.实现

2.1先创建一个头指针

2.2生成新节点作为头结点，用头指针L指向头结点。头结点指针域置空。

三、创建创建链表

1.前插法创建链表

【算法步骤】

2.后插法创建链表

【算法步骤】

四、查看链表数据

1.算法

2代码

五、取值

1.算法

2.代码

六、查找

1.算法

2.代码

七、插入

1.算法步骤

2.代码

八、删除

1.算法步骤

2.代码

一、创建结构体

1.图解

c 数据结构与算法数据结构c+_开发语言

这个结构体需要两个变量，

一个是数据存储数据的，可以是字符串、数字等。

一个是地址存储的，存储下一个结构体的地址，所以类型是本身结构体的类型。

2.代码

#include <iostream>
#include <string>

using namespace std;

//链表的结构体
struct LNode{
	string data;//节点的数据域（存储数据的地方） 
	LNode * next;//节点指针域 （储存下一个结构体的地方） 
}; 


int main(){

	return 0;
}

二、初始化

1.算法步骤

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

②头结点指针域置空

2.实现

2.1先创建一个头指针

c 数据结构与算法数据结构c+_开发语言_02

#include <iostream>
#include <string>

using namespace std;

//链表的结构体
struct LNode{
	string data;//节点的数据域（存储数据的地方） 
	LNode * next;//节点指针域 （储存下一个结构体的地方） 
}; 

int main(){
	LNode * p;//创建头指针p(L)

	return 0;
}

2.2生成新节点作为头结点，用头指针L指向头结点。头结点指针域置空。

c 数据结构与算法数据结构c+_头结点_03

#include <iostream>
#include <string>

using namespace std;

//链表的结构体
struct LNode{
	string data;//节点的数据域（存储数据的地方） 
	LNode * next;//节点指针域 （储存下一个结构体的地方） 
}; 

//初始化(生成头结点)
bool InitList(LNode * &L){//这个参数为了使用指针操作结构体 
	//生成新节点作为头结点，用头指针L指向头结点。
	L = new LNode;
	//头结点指针域置空
	L->next = NULL; 
	return true; 
} 

int main(){
	LNode * p;//创建头指针p(L)
	InitList(p) ;//初始化
	return 0;
}

注意：

使用new创建的数据，返回的是对象地址，应该用指针接收。

为了一直使用头指针，函数使用引用指针的方式传参。

三、创建创建链表

1.前插法创建链表

【算法步骤】

1创建一个只有头结点的空链表（初始化已完成此功能。）

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

①生成一个新的结点。

②数据数据，给新结点的数据域赋值。

③新结点指向头结点指向的结点：先将头结点的next保存到新结点的next。

④头结点指向新结点：头结点指向新结点(头结点的next保存新结点的地址)

c 数据结构与算法数据结构c+_开发语言_04

#include <iostream>
#include <string>

using namespace std;

//链表的结构体
struct LNode{
	string data;//节点的数据域（存储数据的地方） 
	LNode * next;//节点指针域 （储存下一个结构体的地方） 
}; 

//初始化(生成头结点)
bool InitList(LNode * &L){//这个参数为了使用指针操作结构体 
	//生成新节点作为头结点，用头指针L指向头结点。
	L = new LNode;
	//头结点指针域置空
	L->next = NULL; 
	return true; 
} 
//前插法创建链表
void CreateList_H(LNode * &L,int n){//n创建的个数 
	string a[5] = {"12","54","4","78","9"}; 
	for(int i=0;i<n;i++){
		//创建一个节点、赋值、插入 
		LNode * newNode = new LNode; 
		//cin >> newNode->data;//在控制台里取值。 
		newNode->data = a[i];//为了测试方便，在数组里取值。
        newNode->next = NULL;//***创建的时候，记得赋初始值，防止出现不必要的逻辑问题****  
		//先将头结点的next保存到新结点的next。
		newNode->next = L->next;
		//头结点指向新结点(头结点的next保存新结点的地址)
		L->next= newNode;
	}		
	
} 

int main(){
	LNode * p;//创建头指针p(L)
	InitList(p) ;//初始化
	CreateList_H(p,5)
	return 0;
}

2.后插法创建链表

【算法步骤】

1创建一个只有头结点的空链表（初始化已完成此功能。）

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

c 数据结构与算法数据结构c+_开发语言_05

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

①生成一个新的结点。

②数据数据，给新结点的数据域赋值。

③尾指针指向的结点指向新结点。

④尾指针指向新结点（尾节点）

c 数据结构与算法数据结构c+_c++_06

#include <iostream>
#include <string>

using namespace std;

//链表的结构体
struct LNode{
	string data;//节点的数据域（存储数据的地方） 
	LNode * next;//节点指针域 （储存下一个结构体的地方） 
}; 

//初始化(生成头结点)
bool InitList(LNode * &L){//这个参数为了使用指针操作结构体 
	//生成新节点作为头结点，用头指针L指向头结点。
	L = new LNode;
	//头结点指针域置空
	L->next = NULL; 
	return true; 
} 

//后插法创建链表
void CreateList_E(LNode * &L,int n){//n创建的个数 
	LNode * r = L;//创建尾指针 
	string a[5] = {"12","54","4","78","9"}; 
	for(int i=0;i<n;i++){
		//创建一个节点、赋值、插入 
		LNode * newNode = new LNode; 
		//cin >> newNode->data;//在控制台里取值。 
		newNode->data = a[i];//为了测试方便，在数组里取值。 
        newNode->next = NULL;//***创建的时候，记得赋初始值，防止出现不必要的逻辑问题**** 
		//尾指针指向的结点指向新结点
		//尾指针指向的结点的next保存新结点地址 
		r->next = newNode;
		//尾指针指向新结点（尾节点）
		// 尾指针保存新结点的地址。 
		r= newNode;
	}		
	
} 

int main(){
	LNode * p;//创建头指针p(L)
	InitList(p) ;//初始化
	CreateList_E(p,5); 
	return 0;
}

四、查看链表数据

1.算法

①指针开始指向头结点

②如果指针指向结点的next不为空，就循环

③移动指针，输出数据。

2代码

#include <iostream>
#include <string>

using namespace std;

//链表的结构体
struct LNode{
	string data;//节点的数据域（存储数据的地方） 
	LNode * next;//节点指针域 （储存下一个结构体的地方） 
}; 

//初始化(生成头结点)
bool InitList(LNode * &L){//这个参数为了使用指针操作结构体 
	//生成新节点作为头结点，用头指针L指向头结点。
	L = new LNode;
	//头结点指针域置空
	L->next = NULL; 
	return true; 
} 

//后插法创建链表
void CreateList_E(LNode * &L,int n){//n创建的个数 
	LNode * r = L;//创建尾指针 
	string a[5] = {"12","54","4","78","9"}; 
	for(int i=0;i<n;i++){
		//创建一个节点、赋值、插入 
		LNode * newNode = new LNode; 
		//cin >> newNode->data;//在控制台里取值。 
		newNode->data = a[i];//为了测试方便，在数组里取值。 
        newNode->next = NULL;//***创建的时候，记得赋初始值，防止出现不必要的逻辑问题**** 
		//尾指针指向的结点指向新结点
		//尾指针指向的结点的next保存新结点地址 
		r->next = newNode;
		//尾指针指向新结点（尾节点）
		// 尾指针保存新结点的地址。 
		r= newNode;
	}		
	
} 
//查看所有元素
void ShowList(LNode * L){
	while(L->next){//判断当前结点是否有下一个结点 
		//移动指针 
		L = L->next;//头指针指向下一个结点。
		//输出数据 
		cout <<"数据："<< L->data <<"  地址："<< L->next <<endl;//输出这个元素的值 
	}	

}

int main(){
	LNode * p;//创建头指针p(L)
	InitList(p) ;//初始化
	CreateList_E(p,5); 
	ShowList(p);//查看所有元素
	return 0;
}

五、取值

1.算法

①指针开始指向头结点，计数器设置为0

②如果指针指向结点的next不为空，就循环

③移动指针，计数器加1 ，判断数据。

c 数据结构与算法数据结构c+_c++_07

2.代码

#include <iostream>
#include <string>

using namespace std;

//链表的结构体
struct LNode{
	string data;//节点的数据域（存储数据的地方） 
	LNode * next;//节点指针域 （储存下一个结构体的地方） 
}; 

//初始化(生成头结点)
bool InitList(LNode * &L){//这个参数为了使用指针操作结构体 
	//生成新节点作为头结点，用头指针L指向头结点。
	L = new LNode;
	//头结点指针域置空
	L->next = NULL; 
	return true; 
} 

//后插法创建链表
void CreateList_E(LNode * &L,int n){//n创建的个数 
	LNode * r = L;//创建尾指针 
	string a[5] = {"12","54","4","78","9"}; 
	for(int i=0;i<n;i++){
		//创建一个节点、赋值、插入 
		LNode * newNode = new LNode; 
		//cin >> newNode->data;//在控制台里取值。 
		newNode->data = a[i];//为了测试方便，在数组里取值。 
		newNode->next = NULL;//***创建的时候，记得赋初始值，防止出现不必要的逻辑问题**** 
		//尾指针指向的结点指向新结点
		//尾指针指向的结点的next保存新结点地址 
		r->next = newNode;
		//尾指针指向新结点（尾节点）
		// 尾指针保存新结点的地址。 
		r= newNode;
	}		
	
} 
//查看所有元素
void ShowList(LNode * L){
	while(L->next){//判断当前结点是否有下一个结点 
		L = L->next;//头指针指向下一个结点。
		cout <<"数据："<< L->data <<"  地址："<< L->next <<endl;//输出这个元素的值 
	}	

}

//取值 
bool GetElem(LNode * L,int i,string &e){
	//计数器j初始值为0；
	int j = 0;	
	while(L->next){//当前结点的next为空停止，能够从头到尾 
		//移动指针 
		L=L->next;
		//计数器加1 
		j++;
		//判断 
		if(i==j){//中途找到对应的数据，赋值，退出。 
		 	e = L->data;
		 	return true;
		} 		 
		
	}	
	return false;//循环顺利结束，证明没找到。 
} 



int main(){
	LNode * p;//创建头指针p(L)
	InitList(p) ;//初始化
	CreateList_E(p,5); 
	ShowList(p);//查看所有元素
	
	//测试取值 
	string ee = "";//存储查找到的数据
	bool a = GetElem(p,15,ee);
	if (a){
		cout << "查到到的元素为" << ee << endl;
	}else{
		cout << "查找失败：" << endl;
	}
	return 0;
}

六、查找

1.算法

①指针开始指向头结点，计数器设置为0

②如果指针指向结点的next不为空，就循环

③移动指针，判断数据，返回指针。

c 数据结构与算法数据结构c+_结点_08

2.代码

#include <iostream>
#include <string>

using namespace std;

//链表的结构体
struct LNode{
	string data;//节点的数据域（存储数据的地方） 
	LNode * next;//节点指针域 （储存下一个结构体的地方） 
}; 

//初始化(生成头结点)
bool InitList(LNode * &L){//这个参数为了使用指针操作结构体 
	//生成新节点作为头结点，用头指针L指向头结点。
	L = new LNode;
	//头结点指针域置空
	L->next = NULL; 
	return true; 
} 

//后插法创建链表
void CreateList_E(LNode * &L,int n){//n创建的个数 
	LNode * r = L;//创建尾指针 
	string a[5] = {"12","54","4","78","9"}; 
	for(int i=0;i<n;i++){
		//创建一个节点、赋值、插入 
		LNode * newNode = new LNode; 
		//cin >> newNode->data;//在控制台里取值。 
		newNode->data = a[i];//为了测试方便，在数组里取值。 
		newNode->next = NULL;//***创建的时候，记得赋初始值，防止出现不必要的逻辑问题**** 
		//尾指针指向的结点指向新结点
		//尾指针指向的结点的next保存新结点地址 
		r->next = newNode;
		//尾指针指向新结点（尾节点）
		// 尾指针保存新结点的地址。 
		r= newNode;
	}		
	
} 
//查看所有元素
void ShowList(LNode * L){
	while(L->next){//判断当前结点是否有下一个结点 
		//移动指针 
		L = L->next;//头指针指向下一个结点。
		//输出数据 
		cout <<"数据："<< L->data <<"  地址："<< L->next <<endl;//输出这个元素的值 
	}	

}

//取值 
bool GetElem(LNode * L,int i,string &e){
	//计数器j初始值为0； 
	int j = 0;	
	while(L->next){//当前结点的next为空停止，能够从头到尾 
		//移动指针 
		L=L->next;
		//计数器加1 
		j++;
		//判断 
		if(i==j){//中途找到对应的数据，赋值，退出。 
		 	e = L->data;
		 	return true;
		} 		 
		
	}	
	return false;//循环顺利结束，证明没找到。 
} 

//查找 
LNode * GetID(LNode * L,string e){
	
	while(L->next){//当前结点的next为空停止，能够从头到尾 
		//移动指针 
		L=L->next;

		//判断 
		if(e==L->data){//中途找到对应的数据，赋值，退出。 
		 
		 	return L;
		} 		 
		
	}	
	
	return NULL;//循环顺利结束，证明没找到。 
} 

int main(){
	LNode * p;//创建头指针p(L)
	InitList(p) ;//初始化
	CreateList_E(p,5); 
	ShowList(p);//查看所有元素
	
	//测试查找 
	LNode * a = GetID(p,"9"); 
	if (a){
		cout << "查到到的元素为" << a->data << endl;
	}else{
		cout << "查找失败：" << endl;
	}
	
	return 0;
}

七、插入

1.算法步骤

①指针开始指向头结点，计数器设置为0

②如果指针指向结点的next不为空，就循环

③移动指针，判断数据，实现插入。

c 数据结构与算法数据结构c+_c++_09

2.代码

#include <iostream>
#include <string>

using namespace std;

//链表的结构体
struct LNode{
	string data;//节点的数据域（存储数据的地方） 
	LNode * next;//节点指针域 （储存下一个结构体的地方） 
}; 

//初始化(生成头结点)
bool InitList(LNode * &L){//这个参数为了使用指针操作结构体 
	//生成新节点作为头结点，用头指针L指向头结点。
	L = new LNode;
	//头结点指针域置空
	L->next = NULL; 
	return true; 
} 

//后插法创建链表
void CreateList_E(LNode * &L,int n){//n创建的个数 
	LNode * r = L;//创建尾指针 
	string a[5] = {"12","54","4","78","9"}; 
	for(int i=0;i<n;i++){
		//创建一个节点、赋值、插入 
		LNode * newNode = new LNode; 
		//cin >> newNode->data;//在控制台里取值。 
		newNode->data = a[i];//为了测试方便，在数组里取值。 
		newNode->next = NULL;//***创建的时候，记得赋初始值，防止出现不必要的逻辑问题**** 
		//尾指针指向的结点指向新结点
		//尾指针指向的结点的next保存新结点地址 
		r->next = newNode;
		//尾指针指向新结点（尾节点）
		// 尾指针保存新结点的地址。 
		r= newNode;
	}		
	
} 
//查看所有元素
void ShowList(LNode * L){
	while(L->next){//判断当前结点是否有下一个结点 
		//移动指针 
		L = L->next;//头指针指向下一个结点。
		//输出数据 
		cout <<"数据："<< L->data <<"  地址："<< L->next <<endl;//输出这个元素的值 
	}	

}

//取值 
bool GetElem(LNode * L,int i,string &e){
	//计数器j初始值为0； 
	int j = 0;	
	while(L->next){//当前结点的next为空停止，能够从头到尾 
		//移动指针 
		L=L->next;
		//计数器加1 
		j++;
		//判断 
		if(i==j){//中途找到对应的数据，赋值，退出。 
		 	e = L->data;
		 	return true;
		} 		 
		
	}	
	return false;//循环顺利结束，证明没找到。 
} 

//查找 
LNode * GetID(LNode * L,string e){
	
	while(L->next){//当前结点的next为空停止，能够从头到尾 
		//移动指针 
		L=L->next;

		//判断 
		if(e==L->data){//中途找到对应的数据，赋值，退出。 
		 
		 	return L;
		} 		 
		
	}	
	
	return NULL;//循环顺利结束，证明没找到。 
} 

//插入 
bool InsertElem(LNode * L,int i,string e){
	//计数器j初始值为0； 
	int j = 0;	
	while(L->next){//当前结点的next为空停止，能够从头到尾 
		//移动指针 
		L=L->next;
		//计数器加1 
		j++;
		//判断 
		if(i==j+1){//中途找到对应的数据，赋值，退出。 
		 	//实现插入
			//创建一个节点、赋值、插入 
			LNode * newNode = new LNode; 
			newNode->data = e;
			newNode->next = NULL;//***创建的时候，记得赋初始值，防止出现不必要的逻辑问题**** 
			//链接起来 
			newNode->next = L->next;
			L->next = newNode;

		 	return true;
		} 		 
		
	}	
	return false;//循环顺利结束，证明没找到。 
} 




int main(){
	LNode * p;//创建头指针p(L)
	InitList(p) ;//初始化
	CreateList_E(p,5); 
	ShowList(p);//查看所有元素
	
	//测试插入 
	bool a = InsertElem(p,3,"==="); 
	if (a){
		cout << "测试插入成功" << endl;
		ShowList(p);//查看所有元素
	}else{
		cout << "测试插入失败：" << endl;
	}
	
	return 0;
}

八、删除

1.算法步骤

①指针开始指向头结点，计数器设置为0

②如果指针指向结点的next不为空，就循环

③移动指针，判断数据，实现删除。

注意：移动之后，要判断有没有下一。

c 数据结构与算法数据结构c+_c++_10

2.代码

#include <iostream>
#include <string>

using namespace std;

//链表的结构体
struct LNode{
	string data;//节点的数据域（存储数据的地方） 
	LNode * next;//节点指针域 （储存下一个结构体的地方） 
}; 

//初始化(生成头结点)
bool InitList(LNode * &L){//这个参数为了使用指针操作结构体 
	//生成新节点作为头结点，用头指针L指向头结点。
	L = new LNode;
	//头结点指针域置空
	L->next = NULL; 
	return true; 
} 

//后插法创建链表
void CreateList_E(LNode * &L,int n){//n创建的个数 
	LNode * r = L;//创建尾指针 
	string a[5] = {"12","54","4","78","9"}; 
	for(int i=0;i<n;i++){
		//创建一个节点、赋值、插入 
		LNode * newNode = new LNode; 
		//cin >> newNode->data;//在控制台里取值。 
		newNode->data = a[i];//为了测试方便，在数组里取值。 
		newNode->next = NULL;//***创建的时候，记得赋初始值，防止出现不必要的逻辑问题**** 
		//尾指针指向的结点指向新结点
		//尾指针指向的结点的next保存新结点地址 
		r->next = newNode;
		//尾指针指向新结点（尾节点）
		// 尾指针保存新结点的地址。 
		r= newNode;
	}		
	
} 
//查看所有元素
void ShowList(LNode * L){
	while(L->next){//判断当前结点是否有下一个结点 
		//移动指针 
		L = L->next;//头指针指向下一个结点。
		//输出数据 
		cout <<"数据："<< L->data <<"  地址："<< L->next <<endl;//输出这个元素的值 
	}	

}

//取值 
bool GetElem(LNode * L,int i,string &e){
	//计数器j初始值为0； 
	int j = 0;	
	while(L->next){//当前结点的next为空停止，能够从头到尾 
		//移动指针 
		L=L->next;
		//计数器加1 
		j++;
		//判断 
		if(i==j){//中途找到对应的数据，赋值，退出。 
		 	e = L->data;
		 	return true;
		} 		 
		
	}	
	return false;//循环顺利结束，证明没找到。 
} 

//查找 
LNode * GetID(LNode * L,string e){
	
	while(L->next){//当前结点的next为空停止，能够从头到尾 
		//移动指针 
		L=L->next;

		//判断 
		if(e==L->data){//中途找到对应的数据，赋值，退出。 
		 
		 	return L;
		} 		 
		
	}	
	
	return NULL;//循环顺利结束，证明没找到。 
} 

//插入 
bool InsertElem(LNode * L,int i,string e){
	//计数器j初始值为0； 
	int j = 0;	
	while(L->next){//当前结点的next为空停止，能够从头到尾 
		//移动指针 
		L=L->next;
		//计数器加1 
		j++;
		//判断 
		if(i==j+1){//中途找到对应的数据，赋值，退出。 
		 	//实现插入
			//创建一个节点、赋值、插入 
			LNode * newNode = new LNode; 
			newNode->data = e;
			newNode->next = NULL;//***创建的时候，记得赋初始值，防止出现不必要的逻辑问题**** 
			//链接起来 
			newNode->next = L->next;
			L->next = newNode;

		 	return true;
		} 		 
		
	}	
	return false;//循环顺利结束，证明没找到。 
} 

//插入 
bool DeleteElem(LNode * L,int i){
	//计数器j初始值为0； 
	int j = 0;	
	while(L->next){//当前结点的next为空停止，能够从头到尾 
		//移动指针 
		L=L->next;
		//计数器加1 
		j++;
		//判断 
		if(i==j+1&&L->next){//中途找到对应的数据，赋值，退出。 
			//获取要删除的结点
			LNode * delNode =  L->next;
		 	//实现删除 
			L->next =  delNode->next;
		 	return true;
		} 		 
		
	}	
	return false;//循环顺利结束，证明没找到。 
} 



int main(){
	LNode * p;//创建头指针p(L)
	InitList(p) ;//初始化
	CreateList_E(p,5); 
	ShowList(p);//查看所有元素
	
	//测试删除 
	bool a = DeleteElem(p,6); 
	if (a){
		cout << "测试删除成功" << endl;
		ShowList(p);//查看所有元素
	}else{
		cout << "测试删除失败：" << endl;
	}
	
	return 0;
}

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。