day03 3.双向链表4.循环链表

已于 2024-07-23 20:07:16 修改
阅读量275 收藏 3
点赞数 5
文章标签： c语言 数据结构 linux
于 2024-07-22 23:13:45 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_55984508/article/details/140621440
版权

作业：

1> 将双向链表和循环链表自己实现一遍，至少要实现创建、增、删、改、查、销毁工作

2> 使用循环链表完成约瑟夫环问题

work1.h

#ifndef WORK1_H
#define WORK1_H
#include <myhead.h>

typedef int datatype;   //定义数据域的类型

typedef struct Node
{
	union
	{
		int len;
		datatype data;
	};
	struct Node *prio;
	struct Node *next;
}Node, *NodePtr;

NodePtr list_create();

//申请节点封装函数
NodePtr apply_node(datatype e);

int list_empty(NodePtr L);

//定义头插函数
int list_sert_head(NodePtr L,datatype e);

//定义展示函数
int list_show(NodePtr L);

//按位置查找返回节点
NodePtr list_search_pos(NodePtr L,int pos);

//链表任意位置删除
int list_delete_pos(NodePtr L,int pos);

//链表任意位置修改
int list_revise_pos(NodePtr L,int pos,datatype e);

//销毁工作
void list_destroy(NodePtr L);

#endif








work11.c

#include "work1.h"

//创建双向链表
NodePtr list_create()
{ 
	//给头结点申请空间
 	NodePtr L = (NodePtr)malloc(sizeof(Node));
	
	//判断逻辑
	if(NULL == L)
	{
		printf("创建失败\n");
		return NULL;
	}
	
	//初始化
	L->len = 0;
	L->prio = NULL;
	L->next = NULL;

	//创建成功
	printf("创建成功\n");
	return L;
}

NodePtr apply_node(datatype e)
{
	//在堆区申请一个节点的大小
	NodePtr p = (NodePtr)malloc(sizeof(Node));
	
	//判断逻辑
	if(NULL == p)
	{
		printf("申请失败\n");
		return NULL;
	}

	//给节点赋值
	p->data = e;
	p->prio = NULL;
	p->next = NULL;
	
	return p;
}

int list_empty(NodePtr L)
{
	return L->next == NULL;
}

//定义头插函数
int list_sert_head(NodePtr L, datatype e)
{
	//判断逻辑
	if(NULL == L)
	{
		printf("插入失败\n");
		return -1;
	}
	
	NodePtr p = apply_node(e);
	if(NULL == p)
	{
		printf("头插失败\n");
		return 0;
	}
	if(L->next == NULL)
	{
		L->next = p;
		p->prio = L;
	}else
	{
		p->prio = L;
		p->next = L->next;
		L->next->prio = p;
		L->next = p;
	}
	printf("插入成功\n");

	L->len++;
	return 0;
}

int list_show(NodePtr L)
{
	if(NULL == L || list_empty(L))
	{
		printf("遍历失败\n");
		return -1;
	}
	
	NodePtr p = L->next;
	while(p)
	{
		printf("%d\t",p->data);
		p=p->next;
	}
	
	printf("\n");
}

//按位置查找返回节点
NodePtr list_search_pos(NodePtr L,int pos)
{
	if(NULL == L || list_empty(L)|| pos<0 ||pos>L->len)
	{
		printf("查找失败\n");
		return NULL;
	}
	
	NodePtr p=L;
	for(int i=0;i<pos;i++)
	{
		p=p->next;
	}
	return p;
}

//链表任意位置删除
int list_delete_pos(NodePtr L,int pos)
{
	if(NULL == L || list_empty(L) || pos<1 ||pos>L->len)
	{
		printf("删除失败\n");
		return -1;
	}
	NodePtr p =	list_search_pos(L,pos);
	
	if(p->next == NULL)
	{
		p->prio->next=NULL;
	}else
	{
		p->prio->next=p->next;
		p->next->prio=p->prio;
	}
	free(p);
	p=NULL;
	printf("删除成功\n");
}
//链表任意位置修改
int list_revise_pos(NodePtr L,int pos,datatype e)
{
	if(NULL == L || list_empty(L)|| pos<1||pos>L->len)
	{
		printf("修改失败\n");
		return -1;
	}

	NodePtr p = list_search_pos(L,pos);
	p->data = e;
	return 0;
}
//销毁工作
void list_destroy(NodePtr L)
{
//判断逻辑
	if(NULL==L)
	{
		printf("删除失败\n");
		return;
	}
	
	//删除所有节点
	while(!list_empty(L))
	{
		list_delete_pos(L, 1);
	}
	
 
	//删除头结点
	free(L);
	L = NULL;
 
	printf("链表释放成功\n");
}













work1.c


#include "work1.h"

int main(int argc, const char *argv[])
{
	NodePtr L = list_create();
	if(NULL == L)
	{
		return -1;
	}

	list_sert_head(L,5);
	list_sert_head(L,2);
	list_sert_head(L,0);
	list_sert_head(L,0);

	list_show(L);

	list_delete_pos(L,1);
	list_delete_pos(L,3);

	list_show(L);

	list_revise_pos(L,1,8);
	list_show(L);

	list_destroy(L);
	list_show(L);
return 0;
}

 

 work2.h

#ifndef WORK2_H
#define WORK2_H
#include <myhead.h>

typedef int datatype;

typedef struct Node
{
	union
	{
		int len;
		datatype data;
	};
	struct Node *next;
}Node,*NodePtr;

NodePtr list_create();

NodePtr apply_node(datatype e);

int list_empty(NodePtr L);

int list_sert_head(NodePtr L,datatype e);

int list_show(NodePtr L);

int list_delete_show(NodePtr L);
#endif

work22.c

#include "work2.h"


NodePtr list_create()
{
	NodePtr L = (NodePtr)malloc(sizeof(Node));
	if(NULL == L)
	{
		printf("创建失败\n");
		return NULL;
	}

	L->len = 0;
	L->next = L;
	
	printf("创建成功\n");
	return L;
}

NodePtr apply_node(datatype e)
{
	NodePtr p = (NodePtr)malloc(sizeof(Node));
	if(NULL == p)
	{
		printf("创建失败\n");
		return NULL;
	}

	p->data=e;
	p->next=NULL;

	return p;
}

int list_empty(NodePtr L)
{
	return L->next == L;
}

int list_sert_head(NodePtr L,datatype e)
{
	if(NULL == L)
	{
		printf("插入失败\n");
		return -1;
	}

	NodePtr p = apply_node(e);
	
	p->next = L->next;
	L->next = p;

	L->len++;
	return 0;
}

int list_show(NodePtr L)
{
	if(NULL == L || list_empty(L))
	{
		printf("遍历失败\n");
		return -1;
	}
	
	NodePtr p =L->next;
	while(p!=L)
	{
		printf("%d\t",p->data);
		p=p->next;
	}
	printf("\n");
	return 0;
}

int list_delete_show(NodePtr L)
{
	if(NULL == L || list_empty(L))
	{
		printf("失败\n");
		return -1;
	}

	NodePtr q = L;
	NodePtr p = q->next;

	for(int i=0;i<8;i++)
	{
		for(int j=0;j<3;j++)
		{	
			
			if(q->next ==L)
			{
				q=L;
			}
			q=q->next;
		}
		p = q->next;
		printf("第%d个出局的元素为%d\n",i+1,p->data);
		q->next = p -> next;

		free(p);
		p=NULL;
		L->len--;
	}
}

work2.c

#include "work2.h"

int main(int argc, const char *argv[])
{
	NodePtr L=list_create();
	if(NULL == L)
	{
		return -1;
	}
	list_sert_head(L,2);
	list_sert_head(L,9);
	list_sert_head(L,7);
	list_sert_head(L,5);
	list_sert_head(L,6);
	list_sert_head(L,8);
	list_sert_head(L,1);
	list_sert_head(L,3);

	list_show(L);

	list_delete_show(L);
	return 0;
}
记得自己销毁一下（不销毁也没事）

三、双向链表

  • 3.1 概念

    • 1> 所谓双向链表，就是从任意一个节点既能存储其前驱节点信息也能存储后继节点信息 2> 节点结构体中增加一个指向前驱节点的指针 3> 头结点没有前驱，最后一个节点没有后继

  • 3.2创建双向链表

    • 1> 参数：不需要，只需要从堆区申请出一个头结点大小的空间，就创建了一个双向链表 2> 返回值：返回堆区空间中头结点的地址即可 3> 注意：需要将头结点数据域初始化为0，两个指针域分别初始化为NULL

  • 3.3 判空

    • 1> 跟单向链表的判空一致，只需要判断头结点的指针域是否为空即可

  • 3.4 申请节点封装数据

  • 3.5 头插

    • 1> 参数：链表、要插入的元素 2> 返回值：int 3> 注意：对于空链表和非空链表的插入，有所不同，并且不能合并

  • 3.6 链表遍历

    • 1> 参数：链表 2> 返回值：int 3> 注意：需要使用一个遍历指针，从第一个节点出发，到最后一个节点

  • 3.7 按位置查找节点

    • 1> 参数：链表、要查找的位置 2> 返回值：成功返回找到的结点，失败返回NULL

  • 3.8 任意位置删除

    • 1> 参数：链表、要删除的位置 2> 返回值:int 3> 注意：对于双向链表的任意位置进行操作时（插入、删除），可以找到前驱结点处理也可以不用找到前驱结点

  • 3.9 销毁链表

    1> 参数：链表 2> 返回值：int 3> 注意：需要将所有的节点，全部删除后，然后删除头结点

所有代码

test1.h

#ifndef TEST1_H
#define TEST1_H
#include <myhead.h>

typedef char datatype;//数据域的类型

typedef struct Node //定义节点类型
{
	union
	{
		int len;
		datatype data;
	};

	struct Node *prio;
	struct Node *next;
}Node,*NodePtr;

//创建双向链表
NodePtr list_create();

int list_empty(NodePtr);

//申请节点封装数据
NodePtr apply_node(datatype e);

//链表头插
int list_insert_head(NodePtr L,datatype e);

//遍历链表
int list_show(NodePtr L);

//按位置查找返回节点
NodePtr list_search_pos(NodePtr L,int pos);

//链表任意位置删除
int list_delete_pos(NodePtr L,int pos);

//链表删除
void list_destroy(NodePtr L);

 test11.c

#include "test1.h"

//创建双向链表
NodePtr list_create()
{
	//在堆区申请一个头节点
	NodePtr L=(NodePtr) malloc (sizeof(Node));
	if(NULL==L)
	{
		printf("创建失败\n");
		return NULL;
	}

	//初始化
	L->len = 0;
	L->prio = NULL;
	L->next = NULL;

	printf("创建成功\n");
	return L;
}

int list_empty(NodePtr L)
{
	return L-> next == NULL;
}

//申请节点封装数据
NodePtr apply_node(datatype e)
{
	//申请节点空间的大小
	NodePtr p = (NodePtr)malloc(sizeof(Node));
	if(NULL == p)
	{
		printf("节点申请失败\n");
		return NULL;
	}

	//给节点赋值
	p->data = e;
	p->prio = NULL;
	p->next = NULL;

	return p;
}

//链表头插
int list_insert_head(NodePtr L,datatype e)
{
	//判断逻辑
	if(NULL == L)
	{
		printf("插入失败\n");
		return -1;
	}

	//申请节点封装数据
	NodePtr p= apply_node(e);
	if(NULL == p)
	{
		return -1;
	}

	if(list_empty(L))
	{
		p->prio = L;
		L->next = p;
	}else
	{
		p->prio = L;
		p->next = L->next;
		L->next ->prio = p;
		L->next =p;
	}
	printf("插入成功\n");

	L->len++;

	return 0;
}

//遍历链表
int list_show(NodePtr L)
{
	//判断逻辑
	if(NULL == L || list_empty(L))
	{
		printf("遍历失败\n");
		return -1;
	}

	//遍历逻辑
	NodePtr q = L->next;
	while(q)
	{
		//输出数据域
		printf("%c\t",q->data);

		//遍历指针后移
		q = q->next;
	}
	printf("\n");
}

//按位置查找返回节点
NodePtr list_search_pos(NodePtr L,int pos)
{
	//判断逻辑
	if(NULL == L || list_empty(L)|| pos<0 || pos>L->len)
	{
		printf("查找失败\n");
		return NULL;
	}

	//查找逻辑
	NodePtr q = L;
	for(int i=0;i<pos;i++)
	{
		q = q->next;
	}

	//返回节点
	return q;
}

//链表任意位置删除
int list_delete_pos(NodePtr L,int pos)
{
	//判断逻辑
	if(NULL == L || L->len<1 ||list_empty(L) || pos>L->len)
	{
		printf("删除失败\n");
		return -1;
	}
	//找到要删除的节点
	NodePtr q = list_search_pos(L,pos);

	//删除逻辑
	if(NULL == q->next)
	{
		q->prio->next = NULL;
		free(q);
		q = NULL;
	}else
	{
		q->prio->next = q->next;
		q->next->prio = q->prio;

		free(q);
		q=NULL;
	}

	printf("删除成功\n");

	//表长变化
	L->len--;

	return 0;
}

//链表删除
void list_destroy(NodePtr L)
{
	//判断逻辑
	if(NULL ==L)
	{
		printf("删除失败\n");
		return;
	}
	//删除所有节点
	while(!list_empty(L))
	{
		list_delete_pos(L,1);
	}
	//删除头结点
	free(L);
	L = NULL;

	printf("链表释放成功\n");
	
}

 test1.c

#include "test1.h"

int main(int argc, const char *argv[])
{
	//调用创建函数
	NodePtr L=list_create();
	if(NULL == L)
	{
		return -1;
	}
	
	list_insert_head(L,'Q');
	list_insert_head(L,'W');
	list_insert_head(L,'E');
	list_insert_head(L,'R');
	list_insert_head(L,'D');
	list_insert_head(L,'F');

	//遍历函数
	list_show(L);

	list_delete_pos(L,1);
	list_delete_pos(L,3);
	list_delete_pos(L,L->len);

	list_show(L);

	//释放链表
	list_destroy(L);
	L=NULL;

	list_show(L);
	return 0;
}

四、循环链表

  • 4.1 概念

    • 1> 循环链表，就是首尾相接的链表。 2> 单向循环链表：只需要将最后一个节点的指针域指向头结点即可 3> 双向循环链表：需要将最后一个阶段的指针域指向头结点，头结点的前驱指针指向最后一个阶段

  • 4.2 单向链表操作

    • 1> 节点结构体

    • 2> 链表的创建 注意：创建头结点后，需要将头结点的指针域指向头结点自身

    • 3> 链表判空

    • 4> 申请节点封装数据

    • 5> 按位置查找节点

    • 6> 尾插

    • 7> 链表遍历

    • 8> 头删

    • 9> 销毁链表

 test2.h

#ifndef TEST2_H
#define TEST2_H
#include <myhead.h>

typedef char datatype;//数据域的类型

typedef struct Node //定义节点类型
{
	union
	{
		int len;        //头节点数据域
		datatype data;  //普通节点数据域
	};
	struct Node *next;
}Node,*NodePtr;

//创建循环列表
NodePtr list_create();

//链表判空
int list_empty(NodePtr L);

//链表申请空间封装节点
NodePtr apply_node(datatype e);

//按位置进行查找
NodePtr list_search_pos(NodePtr L,int pos);

//链表尾插
int list_insert_tail(NodePtr L,datatype e);

//链表遍历
int list_show(NodePtr L);

//链表头删
int list_delete_head(NodePtr L);

//链表销毁
void list_destroy(NodePtr L);

#endif

test22.c

#include "test2.h"

//创建循环列表
NodePtr list_create()
{
	NodePtr L =(NodePtr) malloc(sizeof(Node));
	if(NULL == L)
	{
		printf("创建失败\n");
		return NULL;
	}

	L->len = 0;
	L->next = L;

	printf("创建成功\n");
	return L;
	
}

//链表判空
int list_empty(NodePtr L)
{
	return L->next == L;
}

//链表申请空间封装节点
NodePtr apply_node(datatype e)
{
	NodePtr p = (NodePtr)malloc(sizeof(Node));
	if(NULL == p)	
	{
		printf("申请失败\n");
		return NULL;
	}

	p->data = e;
	p->next = NULL;

	return p;
}

//按位置进行查找
NodePtr list_search_pos(NodePtr L,int pos)
{
	if(NULL == L ||pos<0||pos>L->len)
	{
		printf("查找失败\n");
		return NULL;
	}

	NodePtr q = L;
	for(int i =0; i<pos; i++)
	{
		q = q->next;
	}

	return q;
}

//链表尾插
int list_insert_tail(NodePtr L,datatype e)
{
	//判断逻辑
	if(NULL == L)
	{
		printf("插入失败\n");
		return -1;
	}

	//找到最后一个节点
	NodePtr q = list_search_pos(L,L->len);

	//封装节点
	NodePtr p = apply_node(e);
	if(NULL == p)
	{
		return -1;
	}

	//插入逻辑
	p->next = q->next;
	q->next = p;

	//表的变化
	L->len++;
	printf("插入成功\n");
	return 0;
}

//链表遍历
int list_show(NodePtr L)
{
	if(NULL== L || list_empty(L))
	{
		printf("遍历失败\n");
		return -1;
	}

	NodePtr q = L->next;
	while(q!=L)
	{
		printf("%c\t",q->data);
		q = q->next;
	}

	printf("\n");

}

//链表头删
int list_delete_head(NodePtr L)
{
	if(NULL == L || list_empty(L))
	{
		printf("头删失败\n");
		return -1;
	}
	
	NodePtr p = L->next;
	L->next = p->next;
	free(p);
	p = NULL;

	L->len--;
	printf("删除成功\n");
	return 0;
}

//链表销毁
void list_destroy(NodePtr L)
{
	if(NULL == L)
	{
		printf("释放失败\n");
		return ;
	}

	while(!list_empty(L))
	{
		list_delete_head(L);
	}

	free(L);
	L = NULL;
	printf("销毁成功\n");
	
}

test2.c

#include "test2.h"

int main(int argc, const char *argv[])
{
	NodePtr L = list_create();
	if(NULL == L)
	{
		return -1;
	}
	
	list_insert_tail(L,'Q');
	list_insert_tail(L,'W');
	list_insert_tail(L,'E');
	list_insert_tail(L,'R');
	list_insert_tail(L,'D');
	list_insert_tail(L,'F');

	list_show(L);

	list_delete_head(L);

	list_show(L);

	list_destroy(L);
	L = NULL;
	return 0;
}

夏枳竺
关注
代码随想录DAY3 203.移除链表元素、707.设计链表、206.反转链表
weixin_46620779的博客
10-28 3562
val 是当前节点的值，next 是指向下一个节点的指针/引用。如果要使用双向链表，则还需要一个属性 prev 以指示链表中的上一个节点。一种通过指针串联在一起的线性结构，每一个节点由两部分组成，一个是数据域一个是指针域（存放指向下一个节点的指针），最后一个节点的指针域指向null（空指针的意思）双链表：每一个节点有两个指针域，一个指向下一个节点，一个指向上一个节点。可以设置一个虚拟头结点，这样原链表的所有节点就都可以按照统一的方式进行移除。单链表：指针域只能指向节点的下一个节点，如上图。
day03| 203.移除链表元素 707.设计链表 206.反转链表
m0_65709641的博客
07-05 864
1、注意while与if的顺序2、注意while(head!=null&&head.val == val)与if(head==null)顺序不可变，万一为【7,7,7,7,7】，head节点就变成了null，无法执行之后的代码// 定义单链表int val;// 链表中元素的个数int size;size = 0;return -1;// 包含一个虚拟头结点i<=index;return;
Day03.链表/203.移除链表元素 707.设计链表 206.反转链表
m0_65529181的博客
04-23 1801
203能够独立完成707没有办法独立完成，基础不扎实206思路想到了，但是反转的逻辑有点不对日期：2024.4.23。
Day03 | 203.移除链表元素 707.设计链表 206.反转链表
q864508127的博客
07-05 691
第五个类void addAtIndex(int index, int val)先定义值为val的新节点，判断index的长度，如果是0放在头节点，遍历到index的前一个节点进行插入。第三个类void addAtHead(int val) 插入一个元素之前，虚拟头节点派上用处了，定义一个新的节点，然虚拟头节点的next指向新节点。第四个类void addAtTail(int val) 追加最后一个节点，遍历到最后一个节点，定义一个新节点，让最后一个节点的next等于新节点。如果下标无效，则返回 -1。
Day 3 203.移除链表元素 707.设计链表 206.反转链表
Max0827的博客
11-18 2319
Day 3 学习
Leetcode刷题Day3 203. 移除链表元素 707. 设计链表
weixin_54199919的博客
04-23 120
void addAtIndex(int index, int val) 将一个值为 val 的节点插入到链表中下标为 index 的节点之前。在插入完成后，新节点会成为链表的第一个节点。给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点。void addAtTail(int val) 将一个值为 val 的节点追加到链表中作为链表的最后一个元素。给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。
代码随想录算法训练营Day03|203.移除链表元素、707.设计链表、206.反转链表
qq_41929830的博客
12-29 1778
代码随想录算法训练营Day03|203.移除链表元素、707.设计链表、206.反转链表
day18双向链表和循环链表
m0_69277585的博客
07-22 541
3> 注意：对于双向链表的任意位置进行操作时（插入、删除），可以找到前驱结点处理也可以不用找到前驱结点。3> 双向循环链表：需要将最后一个阶段的指针域指向头结点，头结点的前驱指针指向最后一个阶段。1> 参数：不需要，只需要从堆区申请出一个头结点大小的空间，就创建了一个双向链表。3> 注意：需要使用一个遍历指针，从第一个节点出发，到最后一个节点。3> 注意：对于空链表和非空链表的插入，有所不同，并且不能合并。3> 注意：需要将所有的节点，全部删除后，然后删除头结点。1> 参数：链表、要删除的位置。
代码随想录C++ Day3 | 203.移除链表元素 707.设计链表 206.反转链表
blackdog_的博客
06-25 732
cur指针负责遍历链表，将遍历到的节点的next赋值为前一个节点，也就是pre指针指向的节点。由于cur的next的指向已经被修改了，遍历无法继续，于是还需要一个temp指针，提前保存cur->next的值（纠正：动画应该是先移动pre，在移动cur）直观来说，重新创建一个空链表，然后再将原链表的每个节点依次插入到新建链表的头节点，时间和空间复杂度都是O(n)// 链表变为 1->2->3。// 现在，链表变为 1->3。，请你反转链表，并返回反转后的链表。是指向下一个节点的指针/引用。
数据结构(Java)——Day10(双向链表，栈)
LengchenAl的博客
11-24 719
数据结构(Java)——Day10(双向链表，栈)
循环链表、双向链表、顺序表和链表的比较
qq_45878468的博客
02-01 2572
循环链表 循环链表（Circular Linked List）是另一种形式的链式存储结构。其特点是表中最后一个结点的指针域指向头结点，整个链表形成一个环。 循环单链表的操作和单链表基本一致，差别仅在于：当链表遍历时，判别当前指针p是否指向表尾结点的终止条件不同。在单链表中，判别条件为 p!=L 或 p->next != L。 在某些情况下，若在循环链表中设立尾指针而不设头指针，可使一...
数据结构学习——双向链表
YiHeboy的博客
07-05 892
双向循环链表的创建及增删改查
Day03 链表概念与单向不循环链表的实现
qq_59111928的博客
06-15 788
链式存储，则线性表中每一个数据元素除了存储自身数据之外，还需要额外存储直接后继的地址，所以链表中的每一个数据元素都是由两部分组成：存储自身数据的部分被称为数据域，存储直接后继地址的部分被称为指针域，数据域和指针域组成的数据元素被称为结点（Node）。顺序表的数据在进行增删的时候，需要移动成片的内存，另外，当数据元素的数量较多的时候，需要申请一块较大的连续的内存，同时当数据元素的数量的改变比较剧烈，顺序表不灵活。顺序表和链式表的区别：顺序表使用连续的内存，链式表使用离散的内存空间。
DAY3:链表（一）：链表基础知识+移除链表元素
CFY1226的博客
05-13 2542
/ 单链表的定义 struct ListNode {int val;//节点上储存的元素 ListNode * next;//指向下一个节点的指针 ListNode(int x) : val(x) , next(NULL) {//节点的构造函数 } }//定义指针，指向链表对象（虚拟头节点用法）所以如果不定义构造函数使用默认构造函数的话，在初始化的时候就不能直接给变量赋值！首先，你需要一个指针来找到要删除的节点。这个指针通常是通过遍历链表得到的。
c语言--结构体
2303_80645930的博客
09-23 1328
熟悉运用c语言 结构体的知识
Linux上的C/C++编程
遥逖的博客
09-27 814
vim，gcc，make/makefile，gdb
C / C++的内存管理
2302_79964175的博客
09-21 1414
new的原理1.调用operator new来申请空间2.在申请的空间上执行构造函数，完成对象的构造delete的原理1.在空间上执行析构函数，完成对象的资源清理2.调用operator delete清理空间newT[N]的原理1.使用operator new[]函数，在operator new[]中调用operator new函数完成N个对象空间的申请2.在申请空间上执行N次构造函数。delete[]的原理在释放的空间上执行N次析构函数，完成N个对象的空间清理：、
洛谷 AT_abc275_c [ABC275C] Counting Squares 题解
最新发布
xzz_0611 的博客
09-27 577
洛谷 AT_abc275_c [ABC275C] Counting Squares 题解
JavaScript双向链表与循环链表详解与实现
本文将深入探讨JavaScript中的两种高级数据结构：双向链表和双向循环链表。在JavaScript编程中，数据结构是实现算法和设计高效数据处理方案的基础。双向链表相较于普通的单向链表，其独特之处在于每个节点除了指向下...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值