程序员经验分享-hwhale

循环单链表（C语言版）

2023-11-19

前言

小可爱们，本次一起来看看循环单链表吧，嘻嘻！

一、循环单链表的定义

        循环单链表是单链表的另一种形式，其结构特点链表中最后一个结点的指针域不再是结束标记，而是指向整个链表的第一个结点，从而使链表形成一个环。和单链表相同，循环链表也有带头结点结构和不带头结点结构两种，带头结点的循环单链表实现插入和删除操作较为方便。

二、循环单链表的结构

1、结构图
在这里插入图片描述

2、代码表示

#define ElemType int

typedef struct Node
{
	ElemType data; //数据域
	struct Node *next; //指针域
}Node, *PNode;
//循环链表管理结点
typedef struct List
{
	PNode first; //指向头结点
	PNode last; //指向尾结点
	int   size;
}List;

三、循环单链表的常用操作

1、初始化

//初始化循环单链表
void InitSCList(List *list)
{
	//申请头结点
	Node *s = (Node *)malloc(sizeof(Node));
	assert(s != NULL);
	//将链表管理结点中的头指针和尾指针分别指向这个结点
	list->first = list->last = s;
	//将尾结点的下一个结点指向头结点形成循环
	list->last->next = list->first;
	//此时存有数据的结点个数为0
	list->size = 0;
}

2、获取结点

//获取结点 x为存入结点内的数据
Node* _buynode(ElemType x)
{
	//申请结点
	Node *s = (Node *)malloc(sizeof(Node));
	assert(s != NULL);
	//存放数据
	s->data = x;
	s->next = NULL;
	return s;
}

3、尾插

//尾插
void push_back(List *list, ElemType x)
{
	Node *s = _buynode(x);//获取一个结点
	list->last->next = s;//将该结点插入
	list->last = s;//更改管理结点中尾结点的指向
	list->last->next = list->first;//重新形成环状
	list->size++;//将有效结点数加一
}

4、头插

//头插
void push_front(List *list, ElemType x)
{
	Node *s = _buynode(x);//获取结点
	//将结点插入
	s->next = list->first->next;
	list->first->next = s;
	//如果这是一个有效结点，那么需要更改管理结点中尾指针的指向
	if(list->first == list->last)
	{
		list->last = s;
	}
	list->size++;//有效结点数加一
}

5、数据显示

//查看链表内的所有数据
void show_list(List *list)
{
	Node *p = list->first->next;//指向有效结点部分
	while(p != list->first)//将有效结点内的数据输出
	{
		printf("%d-->",p->data);
		p = p->next;//下移
	}
	printf("Nul.\n");
}

6、尾删

//尾删
void pop_back(List *list)
{
	//如果没有可删除的有效结点则退出
	if(list->size == 0)
		return;
	//查找要删除结点的上一结点
	Node *p = list->first;
	while(p->next != list->last)
	{
		p = p->next;
	}
	//删除尾结点
	free(list->last);
	//将之前查找到的结点(倒数第二个结点)设置为新的尾结点
	list->last = p;
	list->last->next = list->first;//重新形成环
	list->size--;//有效结点数减一
}

7、头删

//头删
void pop_front(List *list)
{
	//如果没有有效结点可删除则退出
	if(list->size == 0)
		return;
	//删除有效头结点
	Node *p = list->first->next;
	list->first->next = p->next;
	free(p);
	//如果此时链表内只有一个有效结点，那么需要改变尾指针的指向
	if(list->size == 1)
	{
		list->last = list->first;
	}
	list->size--;//将有效结点数减一
}

8、按值插入(按照升序插入)

//按值插入(按照升序插入)
void insert_val(List *list, ElemType x)
{
	//寻找结点的插入位置
	Node *p = list->first;
	while(p->next!=list->last && p->next->data < x)
	{
		p = p->next;
	}
	//如果插入位置在尾部，那么进行尾插，否则在中间插入
	if(p->next == list->last && p->next->data < x)
	{
		push_back(list,x);//尾插
	}
	else
	{
		//中间插入
		Node *s = _buynode(x);
		s->next = p->next;
		p->next = s;
		list->size++;
	}
}

9、按值查找

//查找
Node* find(List *list, ElemType key)
{
	//如果没有有效数据结点则无需查找
	if(list->size == 0)
		return NULL;
	//从有效结点的首位置进行查找
	Node *p = list->first->next;
	while(p != list->first && p->data!=key)
		p = p->next;

	//如果没有找到，返回空
	if(p == list->first)
		return NULL;
	//如果找到，返回结点地址
	return p;
}

10、求有效结点个数

//求链表有效结点个数
int  length(List *list)
{
	return list->size;
}

11、按值删除

//按值删除
void delete_val(List *list, ElemType key)
{
	//如果不存在有效结点，那么无需进行删除
	if(list->size == 0)
		return;
	//查找要删除结点的位置
	Node *p = find(list,key);
	//如果没有查找到则无需删除
	if(p == NULL)
	{
		printf("要删除的数据不存.\n");
		return;
	}
	//如果要删除结点是尾结点，那么可进行尾删
	if(p == list->last)
	{
		pop_back(list);
	}
	else //如果在中间位置，那么把要删除结点的下一结点拷贝到当前要删除结点，然后删除下一结点
	{
		Node *q = p->next;
		//把要删除结点的下一结点拷贝到当前要删除结点
		p->data = q->data;
		p->next = q->next;
		//删除下一结点
		free(q);
		list->size--;//有效结点数减一
	}
}

12、按升序排序

//升序排列
void sort(List *list)
{
	//判断是否要进行排序（有效结点数小于等于1个不进行排序）
	if(list->size==0 || list->size==1)
		return;
	
	Node *s = list->first->next;//指向第一个有效结点
	Node *q = s->next;//指向第二个有效结点

	//将原来的循环链表断开，形成一个只含一个有效结点的循环链表和一个单链表
	list->last->next = NULL;//单链表的尾结点指向空
	list->last = s;
	list->last->next = list->first;

	while(q != NULL) //将单链表内的有效结点逐一按照值插入方式（升序的值插入）插入到循环链表中
	{
		//从单链表中拿下一个有效结点
		s = q;
		q = q->next;

		//查找插入的位置
		Node *p = list->first;
		while(p->next!=list->last && p->next->data < s->data)
		{
			p = p->next;
		}
		//如果插入位置在尾部，那么进行尾插，否则在中间插入
		if(p->next == list->last && p->next->data < s->data)
		{
			s->next = list->last->next;
			list->last->next = s;
			list->last = s;
		}
		else
		{
			//中间插入
			s->next = p->next;
			p->next = s;
		}
	}
}

13、逆置

//逆置
void resver(List *list)
{
	//判断是否要进行逆置（有效结点数小于等于1个不进行逆置）
	if(list->size==0 || list->size==1)
		return;
	Node *p = list->first->next;//指向第一个有效结点
	Node *q = p->next;//指向第二个有效结点

	//将原来的循环链表断开，形成一个只含一个有效结点的循环链表和一个单链表
	list->last->next = NULL;//单链表的尾结点指向空
	list->last = p;                    
	list->last->next = list->first;

	while(q != NULL)//将单链表内的有效结点逐一头插到循环链表中
	{
		//从单链表中拿下一个有效结点
		p = q;
		q = q->next;
		//头插
		p->next = list->first->next;
		list->first->next = p;
	}
}

14、清空循环单链表

//清除有效结点
void clear(List *list)
{
	Node *p = list->first->next;//指向第一个有效结点
	while(p != list->first)//将所有有效结点释放清除
	{
		list->first->next = p->next;
		free(p);
		p = list->first->next;
	}
	//设置管理结点中的尾结点指向和头结点的指针域指向
	list->last = list->first;
	list->last->next = list->first;
	list->size = 0;//有效结点数为0
}

15、销毁循环单链表

//销毁循环链表
void destroy(List *list)
{
	clear(list);//先清除所有有效结点
	free(list->first);//清除头结点
	list->first = list->last = NULL;
}

总结

        循环单链表是一种链式存储结构，它是由单链表改进而来的。把单链表改为循环单链表的过程是将它的尾结点next指针域由原来为空改为指向头结点，整个单链表形成一个环。由此，从表中任一个结点出发均可以找到链表中的其他结点。

附录

以下提供源码测试

Main.cpp

#include"SCList.h"

void main()
{
	List mylist;
	InitSCList(&mylist);

	ElemType Item;
	Node *p = NULL;
	int select = 1;
	while(select)
	{
		printf("**************************************\n");
		printf("* [1] push_back      [2] push_front  *\n");
		printf("* [3] show_list      [4] pop_back    *\n");
		printf("* [5] pop_front      [6] insert_val  *\n");
		printf("* [7] find           [8] length      *\n");
		printf("* [9] delete_val     [10] sort       *\n");
		printf("* [11] resver        [12] clear      *\n");
		printf("* [13*] destroy       [0] quit_system*\n");
		printf("**************************************\n");
		printf("请选择:>");
		scanf("%d",&select);
		if(select == 0)
			break;
		switch(select)
		{
		case 1:
			printf("请输入要插入的数据(-1结束):>");
			while(scanf("%d",&Item),Item != -1)
			{
				push_back(&mylist,Item);
			}
			break;
		case 2:
			printf("请输入要插入的数据(-1结束):>");
			while(scanf("%d",&Item),Item != -1)
			{
				push_front(&mylist,Item);
			}
			break;
		case 3:
			show_list(&mylist);
			break;
		case 4:
			pop_back(&mylist);
			break;
		case 5:
			pop_front(&mylist);
			break;
		case 6:
			printf("请输入要插入的数据:>");
			scanf("%d",&Item);
			insert_val(&mylist,Item);
			break;
		case 7:
			printf("请输入要查找的数据:>");
			scanf("%d",&Item);
			p = find(&mylist,Item);
			if(p == NULL)
			{
				printf("要查找的数据在链表中不存在.\n");
			}
			break;
		case 8:
			printf("单链表的长度为:> %d \n",length(&mylist));
			break;
		case 9:
			printf("请输入要删除的值:>");
			scanf("%d",&Item);
			delete_val(&mylist,Item);
			break;
		case 10:
			sort(&mylist);
			break;
		case 11:
			resver(&mylist);
			break;
		case 12:
			clear(&mylist);
			break;
		//case 13:
		//	destroy(&mylist);
		//	break;
		default:
			printf("输入的命令错误,请重新输入.\n");
			break;
		}
	}
	destroy(&mylist);
}

SCList.h

#ifndef __SCLIST_H__
#define __SCLIST_H__

#include<stdio.h>
#include<malloc.h>
#include<assert.h>

#define ElemType int

typedef struct Node
{
	ElemType data; //数据域
	struct Node *next; //指针域
}Node, *PNode;
//循环链表管理结点
typedef struct List
{
	PNode first; //指向头结点
	PNode last; //指向尾结点
	int   size;
}List;

Node* _buynode(ElemType x);

void InitSCList(List *list);

void push_back(List *list, ElemType x);
void push_front(List *list, ElemType x);
void show_list(List *list);

void pop_back(List *list);
void pop_front(List *list);
void insert_val(List *list, ElemType x);
Node* find(List *list, ElemType key);
int  length(List *list);
void delete_val(List *list, ElemType key);
void sort(List *list);
void resver(List *list);
void clear(List *list);
void destroy(List *list);

#endif //__SCLIST_H__

SCList.cpp


#include"SCList.h"
//获取结点 x为存入结点内的数据
Node* _buynode(ElemType x)
{
	//申请结点
	Node *s = (Node *)malloc(sizeof(Node));
	assert(s != NULL);
	//存放数据
	s->data = x;
	s->next = NULL;
	return s;
}
//初始化循环单链表
void InitSCList(List *list)
{
	//申请头结点
	Node *s = (Node *)malloc(sizeof(Node));
	assert(s != NULL);
	//将链表管理结点中的头指针和尾指针分别指向这个结点
	list->first = list->last = s;
	//将尾结点的下一个结点指向头结点形成循环
	list->last->next = list->first;
	//此时存有数据的结点个数为0
	list->size = 0;
}
//尾插
void push_back(List *list, ElemType x)
{
	Node *s = _buynode(x);//获取一个结点
	list->last->next = s;//将该结点插入
	list->last = s;//更改管理结点中尾结点的指向
	list->last->next = list->first;//重新形成环状
	list->size++;//将有效结点数加一
}
//头插
void push_front(List *list, ElemType x)
{
	Node *s = _buynode(x);//获取结点
	//将结点插入
	s->next = list->first->next;
	list->first->next = s;
	//如果这是一个有效结点，那么需要更改管理结点中尾指针的指向
	if(list->first == list->last)
	{
		list->last = s;
	}
	list->size++;//有效结点数加一
}
//查看链表内的所有数据
void show_list(List *list)
{
	Node *p = list->first->next;//指向有效结点部分
	while(p != list->first)//将有效结点内的数据输出
	{
		printf("%d-->",p->data);
		p = p->next;//下移
	}
	printf("Nul.\n");
}
//尾删
void pop_back(List *list)
{
	//如果没有可删除的有效结点则退出
	if(list->size == 0)
		return;
	//查找要删除结点的上一结点
	Node *p = list->first;
	while(p->next != list->last)
	{
		p = p->next;
	}
	//删除尾结点
	free(list->last);
	//将之前查找到的结点(倒数第二个结点)设置为新的尾结点
	list->last = p;
	list->last->next = list->first;//重新形成环
	list->size--;//有效结点数减一
}
//头删
void pop_front(List *list)
{
	//如果没有有效结点可删除则退出
	if(list->size == 0)
		return;
	//删除有效头结点
	Node *p = list->first->next;
	list->first->next = p->next;
	free(p);
	//如果此时链表内只有一个有效结点，那么需要改变尾指针的指向
	if(list->size == 1)
	{
		list->last = list->first;
	}
	list->size--;//将有效结点数减一
}
//按值插入(按照升序插入)
void insert_val(List *list, ElemType x)
{
	//寻找结点的插入位置
	Node *p = list->first;
	while(p->next!=list->last && p->next->data < x)
	{
		p = p->next;
	}
	//如果插入位置在尾部，那么进行尾插，否则在中间插入
	if(p->next == list->last && p->next->data < x)
	{
		push_back(list,x);//尾插
	}
	else
	{
		//中间插入
		Node *s = _buynode(x);
		s->next = p->next;
		p->next = s;
		list->size++;
	}
}
//查找
Node* find(List *list, ElemType key)
{
	//如果没有有效数据结点则无需查找
	if(list->size == 0)
		return NULL;
	//从有效结点的首位置进行查找
	Node *p = list->first->next;
	while(p != list->first && p->data!=key)
		p = p->next;

	//如果没有找到，返回空
	if(p == list->first)
		return NULL;
	//如果找到，返回结点地址
	return p;
}

//求链表有效结点个数
int  length(List *list)
{
	return list->size;
}
//按值删除
void delete_val(List *list, ElemType key)
{
	//如果不存在有效结点，那么无需进行删除
	if(list->size == 0)
		return;
	//查找要删除结点的位置
	Node *p = find(list,key);
	//如果没有查找到则无需删除
	if(p == NULL)
	{
		printf("要删除的数据不存.\n");
		return;
	}
	//如果要删除结点是尾结点，那么可进行尾删
	if(p == list->last)
	{
		pop_back(list);
	}
	else //如果在中间位置，那么把要删除结点的下一结点拷贝到当前要删除结点，然后删除下一结点
	{
		Node *q = p->next;
		//把要删除结点的下一结点拷贝到当前要删除结点
		p->data = q->data;
		p->next = q->next;
		//删除下一结点
		free(q);
		list->size--;//有效结点数减一
	}
}
//升序排列
void sort(List *list)
{
	//判断是否要进行排序（有效结点数小于等于1个不进行排序）
	if(list->size==0 || list->size==1)
		return;
	
	Node *s = list->first->next;//指向第一个有效结点
	Node *q = s->next;//指向第二个有效结点

	//将原来的循环链表断开，形成一个只含一个有效结点的循环链表和一个单链表
	list->last->next = NULL;//单链表的尾结点指向空
	list->last = s;
	list->last->next = list->first;

	while(q != NULL) //将单链表内的有效结点逐一按照值插入方式（升序的值插入）插入到循环链表中
	{
		//从单链表中拿下一个有效结点
		s = q;
		q = q->next;

		//查找插入的位置
		Node *p = list->first;
		while(p->next!=list->last && p->next->data < s->data)
		{
			p = p->next;
		}
		//如果插入位置在尾部，那么进行尾插，否则在中间插入
		if(p->next == list->last && p->next->data < s->data)
		{
			s->next = list->last->next;
			list->last->next = s;
			list->last = s;
		}
		else
		{
			//中间插入
			s->next = p->next;
			p->next = s;
		}
	}
}
//逆置
void resver(List *list)
{
	//判断是否要进行逆置（有效结点数小于等于1个不进行逆置）
	if(list->size==0 || list->size==1)
		return;
	Node *p = list->first->next;//指向第一个有效结点
	Node *q = p->next;//指向第二个有效结点

	//将原来的循环链表断开，形成一个只含一个有效结点的循环链表和一个单链表
	list->last->next = NULL;//单链表的尾结点指向空
	list->last = p;                    
	list->last->next = list->first;

	while(q != NULL)//将单链表内的有效结点逐一头插到循环链表中
	{
		//从单链表中拿下一个有效结点
		p = q;
		q = q->next;
		//头插
		p->next = list->first->next;
		list->first->next = p;
	}
}
//清除有效结点
void clear(List *list)
{
	Node *p = list->first->next;//指向第一个有效结点
	while(p != list->first)//将所有有效结点释放清除
	{
		list->first->next = p->next;
		free(p);
		p = list->first->next;
	}
	//设置管理结点中的尾结点指向和头结点的指针域指向
	list->last = list->first;
	list->last->next = list->first;
	list->size = 0;//有效结点数为0
}
//销毁循环链表
void destroy(List *list)
{
	clear(list);//先清除所有有效结点
	free(list->first);//清除头结点
	list->first = list->last = NULL;
}
本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)

数据结构与算法

循环单链表（C语言版） 的相关文章

  • python 历险记(五）— python 中的模块

    目录 前言 基础 模块化程序设计 模块化有哪些好处 什么是 python 中的模块 引入模块有几种方式 模块的查找顺序 模块中包含执行语句的情况 用 dir 函数来窥探模块 python 的内置模块有哪些 结语 参考文档 系列文章列表 前言

  • 树06--二叉树中和为某一值的路径

    树06 二叉树中和为某一值的路径 jz24 题目概述 解析 参考答案 注意事项 说明 题目概述 算法说明 输入一颗二叉树的根节点和一个整数 按字典序打印出二叉树中结点值的和为输入整数的所有路径 路径定义为从树的根结点开始往下一直到叶结点所经

  • 将二叉树转为有序的双向链表

    一 题目要求 输入一棵二叉排序树 现在要将该二叉排序树转换成一个有序的双向链表 而且在转换的过程中 不能创建任何新的结点 只能调整树中的结点指针的指向来实现 include

  • 一文弄懂循环链表、双向链表、静态链表

    循环链表 双向链表 静态链表 三遍定律 理解了单链表本文的理解易如反掌 单链表请点击这里 理解了单链表本文的理解易如反掌 单链表请点击这里 理解了单链表本文的理解易如反掌 单链表请点击这里 1 循环链表 将单链表中终端结点的指针端由空指针改

  • Hash table and application in java

    查找的效率取决于在查找是比较的次数 次数越少效率越高 反之越低 最理想的情况是无需比较 一次存取便能找到所查找的记录 根据对应关系f找到给定值K的像f K hash function 应运而生 由此思想建的表称为hash table 集合h

  • 用 Java 实现的八种常用排序算法

    八种排序算法可以按照如图分类 前置知识 1 算法稳定性 在一个序列中 能保证两个相等的数 经过排序之后 其在序列的前后位置顺序不变 A1 A2 排序前 A1 在 A2 前面 排序后 A1 还在 A2 前面 2 时间复杂度 时间复杂度是用于衡

  • DDP入门

    DDP 即动态动态规划 可以用于解决一类带修改的DP问题 我们从一个比较简单的东西入手 最大子段和 带修改的最大子段和其实是常规问题了 经典的解决方法是用线段树维护从左 右开始的最大子段和和区间最大子段和 然后进行合并 现在我们换一种方法来

  • SDUT--OJ《数据结构与算法》实践能力专题训练6 图论

    A 数据结构实验之图论一 基于邻接矩阵的广度优先搜索遍历 Description 给定一个无向连通图 顶点编号从0到n 1 用广度优先搜索 BFS 遍历 输出从某个顶点出发的遍历序列 同一个结点的同层邻接点 节点编号小的优先遍历 Input

  • 如何根据链表节点数据大小对链表节点进行排序

    对链表排序有两种方法 1 比较了两个节点的大小后 对指针进行改变 从而交换节点的顺序 2 比较了两个节点的大小后 只交换数据域 而不改变指针 从而交换节点的顺序 第二种办法比较简单 本文主要对第二种方法进行讲解 链表节点排序算法 采用 冒泡

  • 算法系列15天速成——第八天 线性表【下】

    一 线性表的简单回顾 上一篇跟大家聊过 线性表 顺序存储 通过实验 大家也知道 如果我每次向 顺序表的头部插入元素 都会引起痉挛 效率比较低下 第二点我们用顺序存储时 容 易受到长度的限制 反之就会造成空间资源的浪费 二 链表 对于顺序表存

  • 数据结构与算法书籍推荐

    学习数据结构与算法 还是很有必要看几本相关的书籍 但根据不同基础的人 合适看的书也不一样 因此 针对不同层次 不同语言的人 推荐几本市面上口碑不错的书 1 入门级 针对刚入门的同学 建议不要急着去看那些经典书 像 算法导论 算法 这些比较经

  • JavaScript系列——数组元素左右移动N位算法实现

    引言 在自己刚刚毕业不久的时候 去了一家公司面试 面试官现场考了我这道题 我记忆深刻 当时没有想到思路 毫无疑问被面试官当成菜鸟了 最近刚好在研究数组的各种算法实现 就想到这道题 可以拿来实现一下 纪念自己逝去的青春 需求 假设有这样一个数

  • 人工智能概念

    人工智能概念 人工智能就是用人工方法在机器 计算机 上实现的智能 或称机器智能 即是研究如何用计算机来表示和执行人类的智能活动 以模拟人脑所从事的推理 学习 思考和规划等思维活动 并解决需要人类的智力才能处理的复杂问题 如医疗诊断 管理决策

  • Linux下进程退出的几种形式

    进程退出 Linux 下进程的退出分为正常退出和异常退出两种 1 正常退出 a 在main 函数中执行return b 调用exit 函数 c 调用 exit 函数 2 异常退出 a 调用about函数 b 进程收到某个信号 而该信号使程序

  • 用两个栈实现队列

    目录 一 栈的基本结构及其接口 二 我的队列结构定义 三 我的队列创建及其初始化 四 我的队列入队 五 我的队列出队 六 我的队列取队头元素 七 我的队列判空 八 我的队列销毁 一 栈的基本结构及其接口 栈的结构定义 typedef int

  • 牛客剑指offer刷题其他算法篇

    文章目录 构建乘积数组 题目 思路 代码实现 第一个只出现一次的字符

  • 【数据结构】单链表的定义和操作

    目录 1 单链表的定义 2 单链表的创建和初始化 3 单链表的插入节点操作 4 单链表的删除节点操作 5 单链表的查找节点操作 6 单链表的更新节点操作 7 完整代码 嗨 我是 Filotimo 很高兴与大家相识 希望我的博客能对你有所帮助

  • C++ AVL树(四种旋转,插入)

    C AVL树 四种旋转 插入 一 AVL树的概念及性质 二 我们要实现的大致框架 1 AVL树的节点定义 2 AVL树的大致框架 三 插入 1 插入逻辑跟BST相同的那一部分 2 修改平衡因子

  • 按照层次遍历结果打印完全二叉树

    按照层次遍历结果打印完全二叉树 按照推论结果 l 层首个节点位置 2 h l 1 l 层节点间距 2 h l 1 1 编码实现 public static

  • 最大流-Dinic算法，原理详解，四大优化，详细代码

    文章目录 零 前言 一 概念回顾 可略过 1 1流网络 1 2流 1 3最大流 1 4残留网络 1 5增广路

随机推荐

  • Nginx日志常见时间变量解析

    request time 官方解释 request processing time in seconds with a milliseconds resolution time elapsed between the first bytes

  • js做四则运算时，精度丢失问题及解决方法

    一 前言 这个问题可以说是程序员必踩的坑 因此网上针对该问题的分析有很多也很详细 解决方法也比较统一 写法也是大同小异 本以为预期效果真能如他们所说是完美的 然而效果却是差强人意 二 问题 首先 先来看看两数相加的一个经典问题 网上找过不少

  • android系统下使用openGL开发demo

    对openGL早有耳闻 但是刚接触android下的opengl 做个demo学习下 先把opengl的框架搭建起来 只要有如下几个文件 openActivity java 作为启动入口 android通过GLSurfaceView显示op

  • Unity笔记：修改代码执行的默认打开方式

    使用 External Tools 偏好设置可设置用于编写脚本 处理图像和进行源代码控制的外部应用程序 External Script Editor 选择 Unity 应使用哪个应用程序来打开脚本文件 Unity 会自动将正确的参数传递给内

  • js判断输入框不能全是空格

    var sno sno val var sname sname val while sno lastIndexOf gt 0 sname lastIndexOf gt 0 sno sno replace sname sname replac

  • Python图像处理实战：处理和分析图像数据

    引言 在现代数字化时代 人们生产和获取数以亿计的数字图像 具体而言 这些图像数据常用于计算机视觉 模式识别 医学影像 地球观测和卫星遥感等领域 通过高级图像处理技术 可以从这些数据中提取出有用的信息 从而支持实现各种应用 本文主要介绍Pyt

  • JS学习笔记十二——DOM 操作

    DOM 操作 一 DOM 操作 二 结语 一 DOM 操作 DOM 全名为 Document Object Model 是一整套操作文档流相关内容的属性和方法 这些方法可以用于操作元素修改样式 修改属性 改变位置 添加事件等 DOM 操作内

  • Selenium成长之路-26分页处理

    很长时间没有补充selenium 的脚本了 今天有小朋友问我 如何定位分页 告诉完 索性把代码贴出来 gt gt gt url 填写自己项目中的url地址即可 上代码 coding utf 8 auth carl DJ time 2020

  • 新手教程02：使用makefile脚本进行VCS逻辑仿真

    目录 前言 使用makefile脚本的方式使用VCS 1 新建文件夹 存放需要仿真的rtl代码 2 生成 filelist f 文件 罗列所有rtl文件的路径 3 书写makefile脚本 4 terimal中运行命令 进行仿真 总结 前言

  • jmeter使用教程之验证码登录接口(工作日记)

    首先我们打开jmeter 快捷按钮 win r 会弹出快捷运行弹框 我们输入cmd 后点击回车 会弹出一个控制窗口 我们输入jmeter 然后回车 首次进入jmeter 页面显示空白页且默认英文 我们可以切换语言 Options Choos

  • Flutter 仿朋友圈查看大图，Swiper支持滑动

    Swiper支持多图片预览 左右切换 flutter swiper插件传送地址 先上效果图 1 导入引用到pubspec yaml文件里面 引入后记得pub get flutter swiper 1 1 6 2 写一个图片的集合 可以使用本

  • Nginx配置安全策略总结

    Nginx配置安全策略总结 Content Security Policy 头缺失或不安全 X Content Type Options 头缺失或不安全 X XSS Protection 头缺失或不安全 HTTP Strict Transp

  • SpringCloud——GateWay网关（详解+案例）

    目录 一 相关概念 1 网关概念 2 网关作用 3 网关架构图 4 网关三大核心 二 案例 1 案例说明 2 搭建GateWay网关9527服务 1 创建maven工程 2 导入依赖 3 配置application yml文件 4 创建主启

  • 深入了解== 和 equals的比较

    原文链接 https blog csdn net qq 41841247 article details 106987762

  • SMI/慧荣/SM32**主控量产通用教程,PNY U盘量产！

    我的PNY 8G U盘已多次量产测试 绝对可用 SMI 慧荣主控 SMI主控应该都能通用 我量产后 型号变成SM321 325了 这个可以改的 量产的时候 量产前 PNP设备 ID VID 154B PID 0 044 设备备序列号 AAA

  • Mysql高可用高性能存储应用系列2 - 深入理解锁和Mvcc

    概述 Mysql数据库在处理并发中下了很多功夫 锁是为了更好的保护数据的正确和可靠 Mvcc是维持一个数据的多个版本 使得读写操作没有冲突的解决并发的数据库方案 锁 当数据访问多了 就会出现并发的问题 Mysql锁设计的初衷是处理并发问题

  • vite 创建vue.js项目及vant安装

    1 npm create vitejs app 2 project name select framework select variant 3 cd wx vant 4 npm install 5 npm run dev 6 npm i

  • Linux 内存管理

    摘要 本章首先以应用程序开发者的角度审视Linux的进程内存管理 在此基础上逐步深入到内核中讨论系统物理内存管理和内核内存的使用方法 力求从外到内 水到渠成地引导网友分析Linux的内存管理与使用 在本章最后 我们给出一个内存映射的实例 帮

  • 你不知道的js

    作用域 LHS RHS 区别 如果 RHS 查询在所有嵌套的作用域中遍寻不到所需的变量 引擎就会抛出 ReferenceError 异常 值得注意的是 ReferenceError 是非常重要的异常类型 相较之下 当引擎执行 LHS 查询时

  • 循环单链表（C语言版）

    前言 小可爱们 本次一起来看看循环单链表吧 嘻嘻 一 循环单链表的定义 循环单链表是单链表的另一种形式 其结构特点链表中最后一个结点的指针域不再是结束标记 而是指向整个链表的第一个结点 从而使链表形成一个环 和单链表相同 循环链表也有带头结

热门标签