双向链表、循环链表以及循环双向链表的整理

最新推荐文章于 2023-03-15 09:00:00 发布
最新推荐文章于 2023-03-15 09:00:00 发布
阅读量262 收藏 3
点赞数 2
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xwl666666/article/details/114638037
版权

双向链表

引言

页面的前进与回退

在这里插入图片描述

已知某指针q的位置，求指针p。
在这里插入图片描述

由于单链表节点中只有一个指向其直接后继结点的指针域，因此若已知某结点的指针域为p，找其前驱结点只能从该链表的头结点开始，顺链查找，直到找到某个结点q的直接后继为p为止。q所指的结点即为p的直接前驱，其时间复杂度为O(n)。

所以要想让其时间复杂度达到O(1)，可以选择增加一个指向直接前驱的指针域。
在这里插入图片描述

双向链表的基本操作

//定义结构体变量
typedef struct node{
	int data;			//data域存放数据
	struct node *prev;	//prev指针域存放上一个结点的地址
	struct node *next;	//next指针域存放下一个结点的地址
}LNode,*Linklist;

//创建头结点
Linklist CreatList(); 

//双向链表判空操作
int isEmpty(Linklist head); 

//链表的创建 [头插法]
void ListByInsertHead(Linklist head );

//链表的创建[尾插法]
void ListByInsertTail(Linklist head );
 
//将p结点插入q结点之前 
void Insert(LNode *p, LNode *q);

//删除给定结点
void delete_Node(LNode *p); 

//删除链表
void delete_List(LNode *p);

链表创建头结点[初始化]

在这里插入图片描述

/**
*创建链表，返回头指针。
**/
Linklist CreatList(){
	Linklist head = (Linklist)malloc(sizeof(LNode));//创建头结点
	head->next=NULL;	//将next指针域置空
	head->prev=NULL;	//将prev指针域置空
	return head;		//返回头结点
}

/**
*双向链表判空操作
**/
int isEmpty(Linklist head){
	if(head->next==NULL && head->prev==NULL){
		//为空 
		return 1;
	}
	//不为空 
	return 0; 	
}

如何连接我相信大家画图都是知道的，但是有时候代码跑不起来的原因就是因为插入的次序没有。

链表头插法创建

在这里插入图片描述

断开两个连接

在这里插入图片描述

我们先看一下原图

在这里插入图片描述

断的次序(head->next后断）：

在这里插入图片描述

特殊情况：

当只存在head结点时，head的next指针域为空。

在这里插入图片描述

已知Head结点和p结点，上面共四步：

Head->next=p;(1)
p->prev=Head;(2)
Head->next->prev=p;(3)
p->next=Head->next;(4)

3 4 1

/**
*头插法创建链表
**/
void ListByInsertHead(Linklist head ){
	
	LNode *p;	//指针p用来接受数据，进行插入
	int x;
	while(scanf("%d",&x)&&x!=-1){
		p=(Linklist)malloc(sizeof(LNode)) ;
		p->data=x;
		
        //头插法
        //只有头结点时，头结点的next域为NULL，不存在prev指针域，第一步要放在第三步之前，此时未更新head->next
		if(head->next!=NULL){	
			head->next->prev=p;
		}
		p->next=head->next;	//单链表头插操作
		head->next=p;		//单链表头插操作
		p->prev=head;		//将p的prev指针域指向head（这一步放哪都行）
        
	}
	return ;
}

链表尾插法创建

在这里插入图片描述

在这里插入图片描述

此时有四步改动

p->next=s;(1)
p=s;(2)
s->prev=p;(3)
s->next=p->next;(4)
//还有一种写法是s->next=NULL;

3 2

/**
*尾插法创建链表
**/
void ListByInsertTail(Linklist head ){

	LNode *p,*s;	//指针p用来保存尾指针位置，指针s用来存数据进行插入
	p=head;//只有头结点时，头结点即为最后一个结点
	int x;
	while(scanf("%d",&x)&&x!=-1){
		s=(Linklist)malloc(sizeof(LNode)) ;
		s->data=x;
    
        //尾插法
        s->next=p->next;//s的结点指向尾结点p的下一个，即NULL
		p->next=s;//将尾结点的next指针指向要插入的结点
        //第三步和第四步不能交换
		s->prev=p;//要插入的结点的前一个结点更新为尾结点
		p=s;//将尾结点更新为新插入的结点
        
       

    }
	
	return ;	
}

/**
*尾插法创建链表第二种写法
**/
void ListByInsertTail(Linklist head ){

	LNode *p,*s;	//指针p用来保存尾指针位置，指针s用来存数据进行插入
	p=head;//只有头结点时，头结点即为最后一个结点
	int x;
	while(scanf("%d",&x)&&x!=-1){
		s=(Linklist)malloc(sizeof(LNode)) ;
		s->data=x;
    
        //尾插法
		p->next=s;//将尾结点的next指针指向要插入的结点
        //第二步和第三步不能交换
		s->prev=p;//要插入的结点的前一个结点更新为尾结点
		p=s;//将尾结点更新为新插入的结点
    }
	s->next=NULL;//尾结点指向为空
    
	return ;	
}

指定结点前插入

在q结点前插入p结点

在这里插入图片描述

在这里插入图片描述

此处共有四处改动

p->prev=q->prev;(1)
q->prev->next=p;(2)
p->next=q;(3)
q->prev=p;(4)

/**
*指定结点前插入（在q结点前插入p结点）
**/

void Insert(LNode *p, LNode *q){
    //只有等q指针前面那个结点的相关操作处理完之后才能修改q->prev
	p->prev=q->prev;
	q->prev->next=p;
    
	p->next=q;
	q->prev=p;
}

链表删除

在这里插入图片描述

在这里插入图片描述

特殊：p为尾指针在这里插入图片描述

上述有三处改动

p->prev->next=p->next;(1)
p->next=p->prev(2)
free(p)(3)

/**
*删除指定结点
**/

void delete_Node(LNode *p){
	p->prev->next=p->next;
	if(p->next!=NULL){
		p->next->prev=p->prev;
	}                                                    
	free(p);
}

双向链表完整代码

#include<stdio.h>
#include<stdlib.h>
#include<windows.h>
typedef struct node{
	int data;
	struct node *prev;
	struct node *next;
}LNode,*Linklist;

//创建链表
Linklist CreatList(); 

//双向链表判空操作
int isEmpty(Linklist head); 

//链表的创建 [头插法]
void ListByInsertHead(Linklist head );

//链表的创建[尾插法]
void ListByInsertTail(Linklist head );
 

//将p结点插入q结点之前 
void Insert(LNode *p, LNode *q);

//删除p结点
void delete_Node(LNode *p); 

//删除链表
void delete_List(LNode *p); 

//打印链表
void print_List(Linklist head);


int main(){
	
	Linklist head = CreatList();
	printf("%d\n",isEmpty(head)); 
	ListByInsertTail(head);
	print_List(head);
	printf("\n");
	Linklist head1 = CreatList();
	ListByInsertHead(head1);
	print_List(head1);
//	LNode *t = (Linklist)malloc(sizeof(LNode));
//	t->data=10;
//	Insert(t,head->next);
//	print_List(head);
//	printf("\n");
//	delete_Node(t);
//	print_List(head);
//	delete_List(head);
	return 0;
	
} 

Linklist CreatList(){
	Linklist head = (Linklist)malloc(sizeof(LNode));
	head->next=NULL;
	head->prev=NULL;
	return head;
}

int isEmpty(Linklist head){
	if(head->next==NULL && head->prev==NULL){
		//为空 
		return 1;
	}
	//不为空 
	return 0; 	
}

void ListByInsertHead(Linklist head ){
	
	LNode *p;
	int x;
	while(scanf("%d",&x)&&x!=-1){
		p=(Linklist)malloc(sizeof(LNode)) ;
		p->data=x;
		
		if(head->next!=NULL){
			head->next->prev=p;
		}
		p->next=head->next;
		head->next=p;
		p->prev=head;
	}
	return ;
}

void ListByInsertTail(Linklist head ){

	LNode *p,*s;
	p=head;
	int x;
	while(scanf("%d",&x)&&x!=-1){
		s=(Linklist)malloc(sizeof(LNode)) ;
		s->data=x;
		s->next=p->next; 
		p->next=s;
		s->prev=p;
		p=s;
	}
	//s->next=NULL;
	return ;
	
	
}
				
void Insert(LNode *p, LNode *q){
	p->prev=q->prev;
	q->prev->next=p;
	p->next=q;
	q->prev=p;
}


void delete_Node(LNode *p){
	p->prev->next=p->next;
	if(p->next!=NULL){
		p->next->prev=p->prev;
	}                                                    
	free(p);
}

void delete_List(LNode *p){
	LNode *t,*temp;
	t=p->next;
	while(t){
		temp=t->next;
		delete_Node(t);
		t=temp;
		print_List(p);
	}
	free(p);
}
void print_List(Linklist head){
	Linklist p;
	p=head;
	while(p->next){
		p=p->next;
		printf("%d ",p->data);	
	} 
	
	system("pause"); 
	printf("\n");
	while(p->prev){	
		printf("%d ",p->data);
		p=p->prev;
	}
}

循环双向链表的实现

小思考：自己实现循环双向链表

循环双向链表和双向链表的操作基本一致， 注意由于head指针的prev域和尾指针的next域不为空，因此部分操作需要增加对这两个指针的连接

双向循环链表完整代码：

#include<stdio.h>
#include<stdlib.h>
#include<windows.h>
typedef struct node{
	int data;
	struct node *prev;
	struct node *next;
}LNode,*Linklist;

//创建链表
Linklist CreatList(); 

//双向循环链表判空操作
int isEmpty(Linklist head); 

//链表的创建 [头插法]
void ListByInsertHead(Linklist head );

//链表的创建[尾插法]
void ListByInsertTail(Linklist head );
 

//将p结点插入q结点之前 
void Insert(LNode *p, LNode *q);

//删除p结点
void delete_Node(LNode *p); 

//删除链表
void delete_List(LNode *p); 

//打印链表
void print_List(Linklist head);


int main(){
	
		Linklist head = CreatList();
		printf("%d\n",isEmpty(head));
	ListByInsertTail(head);
	print_List(head);
	printf("\n");
	//Linklist head1 = CreatList();
	//ListByInsertHead(head1);
	//print_List(head1);
	LNode *t = (Linklist)malloc(sizeof(LNode));
	t->data=10;
	Insert(t,head->next);
	print_List(head);
	printf("\n");
	delete_Node(t);
	print_List(head);
	delete_List(head);
	return 0;
	
} 

Linklist CreatList(){
	Linklist head = (Linklist)malloc(sizeof(LNode));
	head->next=head;
	head->prev=head;
	return head;
}

int isEmpty(Linklist head){
	if(head->next==head && head->prev==head){
		//为空 
		return 1;
	}
	//不为空 
	return 0; 	
}

void ListByInsertHead(Linklist head ){
	
	LNode *p;
	int x;
	while(scanf("%d",&x)&&x!=-1){
		p=(Linklist)malloc(sizeof(LNode)) ;
		p->data=x;
		
		head->next->prev=p;
		p->next=head->next;
		head->next=p;
		p->prev=head;
	}
	return ;
}

void ListByInsertTail(Linklist head ){

	LNode *p,*s;
	p=head;
	int x;
	while(scanf("%d",&x)&&x!=-1){
		s=(Linklist)malloc(sizeof(LNode)) ;
		s->data=x;
		s->next=p->next;
		//增加代码：尾指针所指的下一个结点即头指针的prev修改为要插入的结点，即将头指针与新要插入的结点连接起来
		p->next->prev=s; 
		p->next=s;
		s->prev=p;
		p=s;
	}
	return ;
	
	
}
				
void Insert(LNode *p, LNode *q){
	p->prev=q->prev;
	q->prev->next=p;
	p->next=q;
	q->prev=p;
}


void delete_Node(LNode *p){
	p->prev->next=p->next;
	//if(p->next!=NULL){ //p->next不会为空，可删去 
	p->next->prev=p->prev;
//	}                                                    
	free(p);
}

void delete_List(LNode *p){
	LNode *t,*temp;
	t=p->next;
	while(t!=p&&t!=p){//判断条件改为当t又绕回一圈时即链表只剩一个结点 
		temp=t->next;
		delete_Node(t);
		t=temp;
		print_List(p);
		printf("\n");
	}
	free(p);
}
void print_List(Linklist head){
	Linklist p;
	p=head->next;
	while(1){
	
		printf("%d ",p->data);	
		if(p->next==head){
			break;
		}	
		p=p->next;
	} 
	
	system("pause"); 
	printf("\n");
	while(1){	
		printf("%d ",p->data);
		
		if(p->prev==head){
			break;
		}
		p=p->prev;
	}
}

模拟链表

引言

前面介绍的链表都是由指针实现的，链表中结点的分配和回收都是动态的，称为"动态链表“。与之对应的，还有一种"静态链表"，又称模拟链表,静态链表由数组实现，每个数据元素除了存储数据信息外，还要存储逻辑相邻的下一个数据元素在数组中的位置。可见，静态链表虽然是用数组实现的，但是逻辑相邻的数据元素不一定在物理上是相邻的。

下表就是一个模拟链表，他的存储顺序是：a1->a2->a3->a4->a5->……，但是他的物理顺序是a4->a2-a3->a1->a5->……

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-aCqcRdob-1615363269774)(.\双向链表.assets\image-20201208221730863.png)]

模拟链表通过两个数组实现链式存储，data数组用来存储当前结点的数据，next数组用来存储下一个结点的位置。(是不是感觉和链表很像)，通过相同点的数组下标，标识每一个元素存储的数据及下一个结点的位置信息，一样的，第一个结点并没有存放任何元素。

模拟链表的基本操作

//定义next=-1为空 
typedef struct{
	int data;
	int next;
}imitate;

//定义静态链表 
imitate im[Maxsize];

//链表表头和新要插入的位置 
int head,pos;

//初始化链表
void init_list(); 

//链表判空操作
int isEmpty() ;

//链表增加结点
void add_toList(); 

//指定位置之后插入结点
int add_postoList(int point,int x); 

//删除指定位置元素
int delete_pos_list(int point);

模拟链表的初始化

在这里插入图片描述

/**
*链表初始化
**/
void init_list(){
	head=0;//头结点放在0位置
	pos=1; 
	im[0].next=-1; 
}

链表判空

int isEmpty(){
	if(im[head].next==-1){
		return 1;
	}
	return 0;
}

链表增加节点

在这里插入图片描述

在这里插入图片描述

/**
*链表尾部增加结点
**/
void add_toList(int x){
    //从头开始遍历，找到尾结点
	int i=head;
	
	while(im[i].next!=-1){
		i=im[i].next;
	}
	
    im[pos].data=x;//读入新要插入的元素
    
	im[i].next = pos;//将尾结点的next指针指向新要插入的元素
	im[pos].next = -1;//将新插入的元素的尾指针置空
	++pos;
}

指定位置后增加结点

在这里插入图片描述

在这里插入图片描述

/**
*链表指定位置后增加结点 成功返回1 失败返回0
*point变量表示链表中第几个数据
**/
int add_postoList(int point,int x){
	
	for(int i= im[head].next;i!=-1;i=im[i].next){
		if((--point)==0){//找到那个要增加结点的位置
			im[pos].data=x;//读入值yuanxie
			im[pos].next=im[i].next;//新插入的值的下一个结点为第point个位置的结点的下一个结点
			im[i].next=pos;//第point个结点的下一个结点更新为新插入的结点
			++pos;//插入点后移
			return 1;
		}
	}
	return 0; 
}

删除指定位置的结点

在这里插入图片描述

在这里插入图片描述

/**
*链表指定位置删除结点 成功返回1 失败返回0
*point变量表示链表中第几个数据
**/
int delete_pos_list(int point){
	point=point-1;//找要删除的结点的前一个结点
	for(int i= im[head].next;i!=-1;i=im[i].next){
		if((--point)==0){		//循环找到那个结点
			im[i].next=im[im[i].next].next; //该结点等于要删除的结点的下一个结点。
			return 1;
		}
	}
	return 0;
}
xwl666666
关注
  • 2
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
C语言中双向链表和双向循环链表详解
08-30
C语言中双向链表和双向循环链表详解 本文主要介绍了C语言中双向链表和双向循环链表的实现与操作，包括双向链表和双向循环链表的定义、初始化、插入操作、删除操作等。 一、双向链表和双向循环链表的定义 在C语言...
Python双向循环链表实现方法分析
09-20
【Python双向循环链表实现方法分析】 Python中的双向循环链表是一种特殊的数据结构，它具有两个指针，分别指向当前节点的前一个节点（prev）和后一个节点（next），并且链表的最后一个节点的next指针指向第一个节点...
python双向链表以及双向循环链表
tt丫的博客
01-29 1424
深度学习入门小菜鸟，希望像做笔记记录自己学的东西，也希望能帮助到同样入门的人，更希望大佬们帮忙纠错啦~侵权立删。 目录 一、双向链表和双向循环链表概念 二、双向链表的实现 1、建立节点对象 2、链表对象的初始定义 3、判断链表是否为空 4、获取链表长度 5、向头部添加节点 6、向尾部添加节点 7、指定位置插入节点 8、删除指定位置的节点 9、查找是否有该数据的节点 10、遍历输出整个链表 11、输入数据创建链表 12、具体调用 三、双向循环链表的实现 1、建立节点对象 2
【数据结构】带头双向循环链表
Welcome home | Jian Liao 's blog
03-15 1947
前面学习了单链表的结构，并且做了些许单链表的OJ练习，相信大家已经对单链表的结构了如指掌。因此，本章带来了与单链表同源的但拥有不同的结构的链表带头双向循环链表供大家学习。可能大家听到带头双向循环链表这个名字，就会认为该结构很复杂（的确很复杂，是链表当中结构最复杂的），肯定比单链表要难许多，说实在的，如果没有前面单链表的铺垫，直接上这个结构，那肯定挺难的。但现在我们有了单链表的基础，并且做了挺多单链表的题了，也就不用怕了。实际上，带头双向循环链表只是看起来难，听起来难，但它实现起来，比单链表简单多了。
数据结构——双向循环链表
qq_67611811的博客
08-28 2056
双向循环链表，在原单链表的基础上多了一个指向上一个结点的前驱指针prev，这样前后结点就不仅仅有了单向的从头至尾的指向顺序，也可以从后指向前，从末结点指向头结点。双向带头循环链表结构} DGR;加入前驱指针后，不管是对于链表数据的尾插尾删，或是头插头删，其时间复杂度都为O(1)，大大简化了链表遍历过程，而可以直接在链表首尾增减数据，因为一个链表的末节点可由头结点的前驱指针直接访问而不需要遍历至尾。为了简化文本描述，本章双向循环带头链表均简称为双向链表。...
java 双向链表循环_(java实现)双向循环链表
weixin_34472954的博客
02-12 899
什么是双向循环链表在了解双向循环链表之前，如果对链表还没有一个清晰的概念，建议你看看单链表和单向循环链表，这有利于你更好的理解下面的内容。(废话有点多[逃]相比单链表，双向循环链表是一个更加复杂的结构。因为双向循环链表的节点不仅包含指向下一个节点的指针(next)，还包含指向前一个节点的指针(prev)。在双向循环链表中，可见的不只有头指针head，还有尾节点end。这是和单链表的区别。双向循环链...
双向循环链表
qq_52191699的博客
01-26 8903
链表的概念 链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。
数据结构——单向循环链表&双向循环链表
qq_56668869的博客
08-24 3129
数据结构、单向循环链表、程序实现单向循环链表、方法操作示例、双向循环链表、程序实现双向循环链表
双向循环链表操作的实现
m0_53676388的博客
01-24 2049
对双向循环列表进行如下操作： 1.建立一个空表。 2.在第i个位置插入新的元素x。 3.删除第i个位置上的元素。 4.取第i个位置上的元素。 5.返回元素x第一次出现在双向循环链表中的位置号。 6.求双向循环链表的长度，即元素个数。 7.输出双向循环链表中所有的元素值。 8.实现双向循环链表的就地逆置。
用c语言双向循环链表,C语言实现双向循环链表
weixin_28487725的博客
05-21 1014
说明 相比Linux内核链表宿主结构可有多个链表结构的优点,本函数集侧重封装性和易用性,而灵活性和效率有所降低. 可基于该函数集方便地构造栈或队列集. 本函数集暂未考虑并发保护. 一 概念 链表是一种物理存储单元上非连续.非顺序的存储结构,数据元素的逻辑顺序通过链表中的指针链接次序实现.链表由一系列存储结点组成,结点可在运行时动态生成.每个结点均由两部分组成,即存储数据元素的数据...
C语言双向循环链表
qq_45911878的博客
08-07 4355
C语言单向链表正向、反向、排序插入和链表逆转。
双向链表和循环链表的区别
weixin_51420051的博客
11-14 5289
双向链表： 1、为了方便编程，以及节点的插入删除，可以在首尾增加一个空节点，方便一系列的操作和判断，最后一个节点指针指向空数据的节点或者指向空。 2、双向链表在访问元素时，可以从任何结点开始任意向前向后双向访问节点元素，不像循环单链表只能按顺序访问后节点。 3、因为有前后两个指针，双向链表删除前驱和后驱节点，以及插入节点的操作非常便捷。 循环链表： 1、循环链表没有尾指针，必须将最后的一个节点的后指针指向头节点 2、循环链表在访问元素时，可以从任何一个结点开始，但是只能顺序向后访问节点元素 3、循环链表在
循环链表和双向链表.ppt
09-20
循环链表和双向链表是两种特殊类型的线性链表，它们在数据结构中扮演着重要角色，尤其在处理线性关系的数据时。下面将详细讨论这些概念。 首先，我们来看带头结点的链表。在普通链表的基础上，带头结点的链表会在...
双向循环链表使用实例.doc
09-21
在本文中，我们将深入探讨如何使用C++实现双向循环链表。双向循环链表是一种特殊的数据结构，每个节点不仅包含数据，还包含两个指针，分别指向前一个节点和后一个节点，形成一个首尾相接的循环链。这种数据结构在...
双向循环链表-C语言实现.doc
09-21
这篇文档主要介绍的是如何在C语言中实现双向循环链表的...总的来说，这篇文档详细介绍了如何使用C语言实现双向循环链表的初始化、插入、删除和查找操作，对于理解链表数据结构以及在C语言中操作链表有很好的指导作用。
qt练习控件label控件-lineEdit控件样例代码
最新发布
07-30
qt练习控件label控件-lineEdit控件样例代码
【JCR一区级】麻雀搜索算法SSA-CNN-LSTM-Attention故障诊断分类预测【含源码 5689期】.zip
07-30
CSDN海神之光上传的全部代码均可运行，亲测可用，直接替换数据即可，适合小白； 1、代码压缩包内容 主函数：Main .m； 数据； 调用函数：其他m文件；无需运行 运行结果效果图； 2、代码运行版本 Matlab 2019b；若运行有误，根据提示修改；若不会，可私信博主； 3、运行操作步骤 步骤一：将所有文件放到Matlab的当前文件夹中； 步骤二：双击打开除Main.m的其他m文件； 步骤三：点击运行，等程序运行完得到结果； 4、仿真咨询 如需其他服务，可私信博主或扫描博主博客文章底部QQ名片； 4.1 CSDN博客或资源的完整代码提供 4.2 期刊或参考文献复现 4.3 Matlab程序定制 4.4 科研合作 智能优化算法-CNN-LSTM-Attention分类系列程序定制或科研合作方向： 4.4.1 遗传算法GA/蚁群算法ACO-CNN-LSTM-Attention分类 4.4.2 粒子群算法PSO/蛙跳算法SFLA-CNN-LSTM-Attention分类 4.4.3 灰狼算法GWO/狼群算法WPA-CNN-LSTM-Attention分类 4.4.4 鲸鱼算法WOA/麻雀算法SSA-CNN-LSTM-Attention分类 4.4.5 萤火虫算法FA/差分算法DE-CNN-LSTM-Attention分类
详解MATLAB Simulink通信系统建模与仿真
07-30
第1 章 MATLAB 基础与通信系统仿真 1.1 MATLAB 简介 1.2 MATLAB 程序设计 1.3 通信系统仿真 第2 章 Simulink 仿真基础 2.1 Simulink 简介 2.2 Simulink 工作环境 2.3 Simulink 仿真的基本方法 2.4 创建自己的模块库 2.5 S-函数的编写 第3 章 通信信号与系统分析 3.1 离散信号和系统 3.2 Fourier 分析 3.3 带通信号的低通等效 3.4 随机信号分析 第4 章 信道 4.1 加性高斯白噪声信道 4.2 多径衰落信道 第5 章 模拟调制 5.1 幅度调制 5.2 角度调制 第6 章 数字基带传输 6.1 概述 6.2 二进制基带信号传输 6.3 基带PAM 信号传输 6.4 带限信道的信号传输 第7 章 数字信号载波传输 7.1 概述 7.2 载波幅度调制（PAM） 7.3 载波相位调制（PSK） 7.4 正交幅度调制（QAM） 7.5 载波频率调制（FSK） 第8 章 信道编码和交织 8.1 概述 8.2 线性分组码
SCI一区】淘金算法GRO-CNN-BiLSTM-Mutilhead-Attention多变量时序预测含源码 5642.zip
07-30
CSDN海神之光上传的全部代码均可运行，亲测可用，直接替换数据即可，适合小白； 1、代码压缩包内容 主函数：Main .m； 数据； 调用函数：其他m文件；无需运行 运行结果效果图； 2、代码运行版本 Matlab 2019b；若运行有误，根据提示修改；若不会，可私信博主； 3、运行操作步骤 步骤一：将所有文件放到Matlab的当前文件夹中； 步骤二：双击打开除Main.m的其他m文件； 步骤三：点击运行，等程序运行完得到结果； 4、仿真咨询 如需其他服务，可私信博主或扫描博主博客文章底部QQ名片； 4.1 CSDN博客或资源的完整代码提供 4.2 期刊或参考文献复现 4.3 Matlab程序定制 4.4 科研合作 智能优化算法-CNN-BiLSTM-Mutilhead-Attention回归预测系列程序定制或科研合作方向： 4.4.1 遗传算法GA/蚁群算法ACO-CNN-BiLSTM-Mutilhead-Attention回归预测 4.4.2 粒子群算法PSO/蛙跳算法SFLA-CNN-BiLSTM-Mutilhead-Attention回归预测 4.4.3 灰狼算法GWO/狼群算法WPA-CNN-BiLSTM-Mutilhead-Attention回归预测 4.4.4 鲸鱼算法WOA/麻雀算法SSA-CNN-BiLSTM-Mutilhead-Attention回归预测 4.4.5 萤火虫算法FA/差分算法DE-CNN-BiLSTM-Mutilhead-Attention回归预测
数据结构讲解：循环链表与双向链表操作
"循环链表和双向链表的讲解，包括它们的定义、操作以及线性表的应用示例。" 在数据结构与算法的学习中，循环链表和双向链表是两种重要的链式存储结构，它们扩展了单链表的功能，为数据操作提供了更多的便利。 5.1 ...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值