Linux C任务计数器实现-信号实现

已于 2022-05-04 15:58:52 修改
阅读量257 收藏
点赞数 1
文章标签： c语言 linux 开发语言
于 2022-05-03 19:05:17 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lg20171009/article/details/124559698
版权

感觉定义一个好的结构体，可以实现很强大的功能。

本程序是利用信号里面的知识来实现。功能是多任务定时器，有多个定时器，每个定时器都可以实现自己的功能（多少秒后打印任务，或者是周期性打印任务）。每个定时器返回自己的id，通过id来操控定时器任务取消，等待定时器结束（收尸任务）。

anytimer.h

#ifndef ANYTIMER_H__
#define ANYTIMER_H__

#define JOB_MAX 1024
typedef void at_addjob_t(void*);

int at_addjob(int sec,at_addjob_t *jobp,void* arg);
/*
* return >= 0 成功，返回任务ID
*        == -EINVAL 失败，参数非法
*        == -ENOSPC 失败，数组满
*        == -ENOMEM 失败，内存空间不足 
**/

int at_addjob_repeat(int sec,at_addjob_t *jobp,void* arg);
/*
* return >= 0 成功，返回任务ID
*        == -EINVAL 失败，参数非法
*        == -ENOSPC 失败，数组满
*        == -ENOMEM 失败，内存空间不足 
**/

int at_canceljob(int id);
/*
* return == 0 取消，指定任务成功取消
*        == -EINVAL 失败，参数非法
*        == -EBUSY  失败，任务已完成 
*        == -ECANCELED 失败，指定任务重复取消 
**/
int at_waitjob(int id);
/*
* return == 0 取消，指定任务成功释放
*        == -EINVAL 失败，参数非法
**/

#endif

anytimer.c

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <sys/time.h>
#include <signal.h>
#include "anytimer.h"

enum
{
    STATE_RUNNING = 1,
    STATE_CANCEL,
    STATE_OVER
};

struct at_job_st
{
    int job_state;   
    int sec;  
    int time_remain;
	int repeat;
    at_addjob_t *jobp;
    void *arg;
};

static struct at_job_st *job[JOB_MAX];
static int inited = 0;
struct sigaction sa_save;

static void module_unload(void)
{
	struct itimerval itv;
	
	itv.it_interval.tv_sec = 0;
	itv.it_interval.tv_usec = 0;
	itv.it_value.tv_sec = 0;
	itv.it_value.tv_usec = 0;
	if(setitimer(ITIMER_REAL, &itv, NULL) < 0)
	{
		perror("setitimer()");
		exit(1);
	}
	if(sigaction(SIGALRM, &sa_save, NULL) <0)
	{
		perror("sigaction()");
		exit(1);
	}
}

static void alrm_sigaction(int num, siginfo_t *infop, void *unused)
{
	int i;
	
	for(i=0; i<JOB_MAX; i++)
	{
		if(job[i] != NULL && job[i]->job_state == STATE_RUNNING)
		{
			job[i]->time_remain--;
			if(job[i]->time_remain == 0)
			{
				job[i]->jobp(job[i]->arg);
				if(job[i]->repeat == 1)
				{
					job[i]->time_remain = job[i]->sec;
				}
				else
				{
					job[i]->job_state = STATE_OVER;
				}
			}
		}
			
	}
	
}

static void module_load(void)
{
	struct sigaction sa;
	struct itimerval itv;
	
	sa.sa_sigaction = alrm_sigaction;
	sa.sa_flags = SA_SIGINFO;
	sigemptyset(&sa.sa_mask); 
	if(sigaction(SIGALRM, &sa, &sa_save) <0)
	{
		perror("sigaction()");
		exit(1);
	}
	
	itv.it_interval.tv_sec = 1;
	itv.it_interval.tv_usec = 0;
	itv.it_value.tv_sec = 1;
	itv.it_value.tv_usec = 0;
	if(setitimer(ITIMER_REAL, &itv, NULL) < 0)
	{
		perror("setitimer()");
		exit(1);
	}
	atexit(module_unload);
}

static int get_job_pos(void)
{
	int i;
	
	for(i=0; i<JOB_MAX; i++)
	{
			if(job[i] == NULL)
				return i;
	}
	return -1;
}

int at_addjob(int sec,at_addjob_t *jobp,void* arg)
/*
* return >= 0 成功，返回任务ID
*        == -EINVAL 失败，参数非法
*        == -ENOSPC 失败，数组满
*        == -ENOMEM 失败，内存空间不足 
**/
{
	struct at_job_st *me;
	int pos;
	
	if(!inited)
	{
		module_load();
		inited = 1;
	}
	
	if(sec < 0)
		return -EINVAL;
	
	me = malloc(sizeof(*me));
	if(me == NULL)
		return -ENOMEM;
	me->job_state = STATE_RUNNING;
	me->sec = sec;
	me->time_remain = me->sec;
	me->jobp = jobp;
	me->arg = arg;
	me->repeat = 0;
	
	pos = get_job_pos();
	if(pos <0)
		return -ENOSPC;
	job[pos] = me;
	
	return pos;
}
int at_addjob_repeat(int sec,at_addjob_t *jobp,void* arg)
/*
* return >= 0 成功，返回任务ID
*        == -EINVAL 失败，参数非法
*        == -ENOSPC 失败，数组满
*        == -ENOMEM 失败，内存空间不足 
**/
{
	struct at_job_st *me;
	int pos;
	
	if(!inited)
	{
		module_load();
		inited = 1;
	}
	
	if(sec < 0)
		return -EINVAL;
	
	me = malloc(sizeof(*me));
	if(me == NULL)
		return -ENOMEM;
	me->job_state = STATE_RUNNING;
	me->sec = sec;
	me->time_remain = me->sec;
	me->jobp = jobp;
	me->arg = arg;
	me->repeat = 1;
	
	pos = get_job_pos();
	if(pos <0)
		return -ENOSPC;
	job[pos] = me;
	
	return pos;
	
}

int at_canceljob(int id)
/*
* return == 0 取消，指定任务成功取消
*        == -EINVAL 失败，参数非法
*        == -EBUSY  失败，任务已完成 
*        == -ECANCELED 失败，指定任务重复取消 
**/
{
	if(id < 0 || id > JOB_MAX || job[id] == NULL)
		return -EINVAL;
	if(job[id]->job_state == STATE_CANCEL)
		return -ECANCELED;
	if(job[id]->job_state == STATE_OVER)
		return -EBUSY;
	job[id]->job_state = STATE_CANCEL;
	return 0;
}
int at_waitjob(int id)
/*
* return == 0 取消，指定任务成功释放
*        == -EINVAL 失败，参数非法
*		 == -EBUSY  失败，指定任务为周期性任务
**/
{
	if(id <0 || id > JOB_MAX || job[id] == NULL)
		return -EINVAL;
	
	if(job[id]->repeat == 1)
	{
		return -EBUSY;
	}
	
	while(job[id]->job_state == STATE_RUNNING)  //一直等到job状态变换才能取消。
		pause();
	
	if(job[id]->job_state == STATE_OVER || job[id]->job_state == STATE_CANCEL)
	{
		free(job[id]);
		job[id] = NULL;
	}
	return 0;
}

main.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include "anytimer.h"

static void f1(void *p)
{
	printf("f1():%s\n", p);
}

static void f2(void *p)
{
	printf("f2():%s\n", p);
}

int main(int argc, char **argv)
{
	int job1, job2;
#if 0
	job1 = at_addjob(2, f1, "aa");
	if(job1 < 0)
	{
		fprintf(stderr, "job1():%s\n", strerror(-job1));
		exit(1);
	}
	
	job2 = at_addjob(5, f2, "bb");
	if(job2 < 0)
	{
		fprintf(stderr, "job2():%s\n", strerror(-job1));
		exit(1);
	}
#endif

	job1 = at_addjob_repeat(2, f1, "aa");
	if(job1 < 0)
	{
		fprintf(stderr, "job1():%s\n", strerror(-job1));
		exit(1);
	}
	
	while(1)
	{
		write(1, "*", 1);
		sleep(1);
	}
	exit(1);
}

定义周期性任务结果

这里有个缺陷就是wait_job不能一直等待，不然得阻塞。只能先取消任务at_canceljob()，让后at_waitjob()

2，有限状态机的完善。

增加cancel和wait功能。因为是用线程写的，所以用全局互斥锁对临界区资源rel_job互斥访问。对cancel进行实现的时候，由于是对一个节点进行访问，可以不用使用全局锁，而是用一个节点里面的锁，对状态进行改变。对wait功能进行实现的时候，想法是一直等待状态发生改变（pthread_cond_wait()用通知法）,由于要释放rel_job里面的一个节点，所以又得访问临界区资源rel_job，这就形成了一个死穴了。

relay.h

#ifndef RELAY_H__
#define RELAY_H__

#include <stdint.h>

#define REL_JOBMAX 10000

struct rel_stat_st
{
	int state;
	int fd1;
	int fd2;
	int64_t count12, count21;
};
int rel_addjob(int fd1, int fd2);
/*
	return >= 0			成功，返回当前任务ID
		   == -EINVAL	失败，参数非法
		   == -ENOSPC   失败，任务数组满
		   == -ENOMEM   失败，内存分配有误
*/
int rel_canceljob(int id);
/*
	return == 0			成功，指定任务成功取消
		   == -EINVAL	失败，参数非法
		   == -EBUSY    失败，任务早已被取消
*/
int rel_waitjob(int id, struct rel_stat_st*);
/*
	return == 0			成功，指定任务已终止并返回状态
		   == -EINVAL	失败，参数非法
		
*/
int rel_statjob(int id, struct rel_stat_st*);
/*

	return == 0			成功，指定任务状态返回
		   == -EINVAL	失败，参数非法

*/
#endif

relay.c

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <pthread.h>

#include "relay.h"

#define BUFSIZE 1024

enum 
{
	STATE_R=1,
	STATE_W,
	STATE_E,
	STATE_T
};

enum
{
	STATE_RUNNING=1,
	STATE_CANCELED,
	STATE_OVER
};

struct fsm_st
{
	int state;
	int sfd;
	int dfd;
	char buf[BUFSIZE];
	int len;
	int pos;
	char *errstr;
};

struct rel_job_st
{
	int fd1, fd2;
	int job_state;
	struct fsm_st fsm12, fsm21;
	int fd1_save, fd2_save;
	pthread_mutex_t mtx;  //互斥访问状态
	pthread_cond_t cond;
};

static struct rel_job_st *rel_job[REL_JOBMAX];
static pthread_mutex_t job_mtx = PTHREAD_MUTEX_INITIALIZER;
static pthread_once_t once_init=PTHREAD_ONCE_INIT;

void fsm_driver(struct fsm_st *fsm)
{
	int ret;
	switch(fsm->state)
	{
		case STATE_R:
			ret = read(fsm->sfd, fsm->buf, BUFSIZE);
			if(ret < 0)
			{
				if(errno == EAGAIN)
					fsm->state = STATE_R;
				else
				{
					fsm->errstr = "read()";
					fsm->state = STATE_E;
				}
			}
			else if(ret == 0)
			{
				fsm->state = STATE_T;
			}
			else{
				fsm->state = STATE_W;
				fsm->len = ret;
				fsm->pos = 0;
			}
			break;
		case STATE_W:
			ret = write(fsm->dfd, fsm->buf + fsm->pos, fsm->len);
			if(ret < 0)
			{
				if(errno == EAGAIN)
					fsm->state = STATE_W;
				else
				{
					fsm->errstr = "write()";
					fsm->state = STATE_E;
				}
			}
			else
			{
				 if(ret < fsm->len)
				 {
					 fsm->pos += ret;
					 fsm->len -= ret;
					 fsm->state = STATE_W;
				 }
				 else
					 fsm->state = STATE_R;
			}
			break;
		case STATE_E:
				perror(fsm->errstr);
				fsm->state = STATE_T;
			break;
		case STATE_T:
			break;
		default:
			abort();				
	}
	
}

static int get_pos_unlock()
{
	int i;
	for(i=0; i<REL_JOBMAX; i++)
	{
		if(rel_job[i] == NULL)
			return i;
	}
	return -1;
}

static void *thr_worker(void *arg)
{
	printf("%s:%d\n", __FUNCTION__, __LINE__);
	int i;
	while(1)
	{
		pthread_mutex_lock(&job_mtx);
		for(i=0; i<REL_JOBMAX; i++)
		{
			
			if(rel_job[i] != NULL)
			{
				pthread_mutex_lock(&rel_job[i]->mtx);
				if(rel_job[i]->job_state == STATE_RUNNING)
				{
					fsm_driver(&rel_job[i]->fsm12);
					fsm_driver(&rel_job[i]->fsm21);
					if(rel_job[i]->fsm12.state == STATE_T && rel_job[i]->fsm21.state == STATE_T)
					{
						rel_job[i]->job_state = STATE_OVER;
					}
				}
				pthread_cond_broadcast(&rel_job[i]->cond);
				pthread_mutex_lock(&rel_job[i]->mtx);
			}
		}
		pthread_mutex_unlock(&job_mtx);
	}
}

static void module_load(void)
{
	printf("%s:%d\n", __FUNCTION__, __LINE__);
	int err;
	pthread_t tid_relayer;
	err = pthread_create(&tid_relayer, NULL, thr_worker, NULL);
	if(err)
	{
		fprintf(stderr, "pthread_create():%s\n", strerror(err));
		exit(1);
	}
}

int rel_addjob(int fd1, int fd2)
{
	struct rel_job_st *me;
	int pos;
	
	pthread_once(&once_init, module_load);
	
	printf("%s:%d\n", __FUNCTION__, __LINE__);
	
	me = malloc(sizeof(*me));
	if(me == NULL)
		return -ENOMEM;
	
	me->fd1 = fd1;
	me->fd2 = fd2;
	me->job_state = STATE_RUNNING;
	
	me->fd1_save = fcntl(me->fd1, F_GETFL);
	fcntl(me->fd1, F_SETFL, me->fd1_save|O_NONBLOCK);
	me->fd2_save = fcntl(me->fd2, F_GETFL);
	fcntl(me->fd2, F_SETFL, me->fd2_save|O_NONBLOCK);
	
	me->fsm12.sfd = me->fd1;
	me->fsm12.dfd = me->fd2;
	me->fsm12.state = STATE_R;
	me->fsm21.sfd = me->fd2;
	me->fsm21.dfd = me->fd1;
	me->fsm21.state = STATE_R;
	
	pthread_mutex_init(&me->mut, NULL);
    pthread_cond_init(&me->cond, NULL);
	
	pthread_mutex_lock(&job_mtx);
	pos = get_pos_unlock();
	if(pos < 0)
	{
		pthread_mutex_unlock(&job_mtx);
		fcntl(me->fd1, F_SETFL, me->fd1_save);
		fcntl(me->fd2, F_SETFL, me->fd2_save);
		free(me);
		return -ENOSPC;
	}
	rel_job[pos] = me;
	pthread_mutex_unlock(&job_mtx);
	return pos;
}


int rel_canceljob(int id)
/*
	return == 0			成功，指定任务成功取消
		   == -EINVAL	失败，参数非法
		   == -EBUSY    失败，任务早已被取消
*/
{
	pthread_mutex_lock(&rel_job[id]->mtx);
	if(id > REL_JOBMAX || id < 0 || rel_job[id] == NULL)
	{
		pthread_mutex_unlock(&rel_job[id]->mtx);
		return -EINVAL;
	}
	if(rel_job[id]->state == STATE_CANCELED)
	{
		pthread_mutex_unlock(&rel_job[id]->mtx);
		return -EBUSY;
	}
	
	rel_job[id]->state = STATE_CANCELED;
	pthread_cond_broadcast(&rel_job[id]->cond);
	pthread_mutex_unlock(&rel_job[id]->mtx);
	return 0;
}
int rel_waitjob(int id, struct rel_stat_st* stat)
/*
	return == 0			成功，指定任务已终止并返回状态
		   == -EINVAL	失败，参数非法
		转念一想好像释放job点的时候，还是会访问修改rel_job里面的内容
*/
{
	pthread_mutex_lock(&rel_job[id]->mtx);
	
	if(id > REL_JOBMAX || id < 0 || rel_job[id] == NULL)
	{
		pthread_mutex_unlock(&job_mtx);
		return -EINVAL;
	}
	
	while(rel_job[id].state == STATE_RUNNING)
	{
		pthread_cond_wait(&rel_job[id]->cond, &rel_job[id]->mtx);  //解锁，等待
	}
		
	if (rel_job[id].state == STATE_CANCELED || rel_job[id].state == STATE_OVER)
    {
        free(rel_job[id]);
        rel_job[id] = NULL;
    }
	pthread_mutex_unlock(&rel_job[id]->mtx);
	return 0;
}
int rel_statjob(int id, struct rel_stat_st*)
/*

	return == 0			成功，指定任务状态返回
		   == -EINVAL	失败，参数非法

*/
{
	
}

main.c

#include <stdio.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>
#include "relay.h"

#define TTY1 "/dev/tty9"
#define TTY2 "/dev/tty8"

#define TTY3 "/dev/tty10"
#define TTY4 "/dev/tty11"
int main()
{
	int fd1, fd2, fd3, fd4;
	int job1, job2;
	
	fd1 = open(TTY1, O_RDWR);
	if(fd1 < 0)
	{
		perror("open()");
		exit(1);
	}
	
	write(fd1, "TTY1\n", 5);
	
	fd2 = open(TTY2, O_RDWR);
	if(fd2 < 0)
	{
		perror("open()");
		exit(1);
	}
	
	write(fd2, "TTY2\n", 5);
	
	job1 = rel_addjob(fd1, fd2);
	if(job1 <0)
	{
		fprintf(stderr, "rel_addjob():%s\n", strerror(-job1));
		exit(1);
	}
	
	//job2
	
	fd3 = open(TTY3, O_RDWR);
	if(fd3 < 0)
	{
		perror("open()");
		exit(1);
	}
	
	write(fd3, "TTY3\n", 5);
	
	fd4 = open(TTY4, O_RDWR);
	if(fd4 < 0)
	{
		perror("open()");
		exit(1);
	}
	
	write(fd4, "TTY4\n", 5);
	
	job2 = rel_addjob(fd3, fd4);
	if(job2 <0)
	{
		fprintf(stderr, "rel_addjob():%s\n", strerror(-job2));
		exit(1);
	}
	
	while (1)
		pause();
	
	close(fd1);
	close(fd2);
	close(fd3);
	close(fd4);
	exit(0);
	
}

lg20171009
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
linux编程 定时计数器,C++统计精确时间
weixin_39804329的博客
05-14 561
QueryPerformanceFrequency用法精确获取时间：QueryPerformanceFrequency() - 基本介绍类型：Win32API原型：BOOL QueryPerformanceFrequency(LARGE_INTEGER *lpFrequency);作用：返回硬件支持的高精度计数器的频率。返回值：非零，硬件支持高精度计数器；零，硬件不支持，读取失败。QueryPer...
Linux-----信号量
weixin_45599288的博客
03-11 3233
信号量信号量原理信号量概念信号量函数一级目录 信号量原理之前我们知道被多个执行流同时访问的公共资源叫做界资源，而临界资源不保护的话会造成数据不一性的问题。 之前我们用互斥锁保护临界资源是把这个临界资源当做一个整体，只能让1个执行流访问临界资源。现在我们把临界资源分割成多个区域，当多个执行流访问不同的区域，此时不会出现数据不一性的问题了。 信号量概念 信号量本质就是一个计数器，描述临界资源有效个数的计数器。 每个执行流先申请信号量，申请到信号量后同时访问临界资源，访问完后释放信号量。 信号量的P
redis实现计数器-防止刷单方法介绍
09-09
本文主要向大家介绍了redis实现计数器防止刷单的方法和有关代码，具有一定参考价值，需要的朋友可以了解下。
linux 程序计时,Linux系统中C语言计时器的使用
weixin_39600616的博客
05-01 873
在Linux中用C语言计时可以用很多方法。1. 如果是想使用秒级别的技术，可用使用C语言库自带的clock()进行计时。如：#include #include using namespace std;int main(){clock_t start = clock();//do some process hereclock_t end = (clock() - start)/CLOCKS_PER_...
linux 进程计数器,Linux下实现一个计算器程序
weixin_33622153的博客
04-29 404
(集体内容详见ChinaUnix社区)现在要在Linux下实现一个计算器程序， 它有如下的要求:1.能识别英文数字：比如 three hundred and ninety two， 要能转换为392.2.能识别英文的加减乘除： Add, minus, multiply, divide.3.能识别符号的加减乘除： +, -, *, /例子如下：输入：three hundred and n...
Linux下用c语言设计简易计算器
SeanXiao__的博客
10-11 1170
在Linux下使用c语言设计一个简易计算器，主要有显示界面、加、减、乘、取余、取模、幂指数等功能。用到了swtch、getcher、char*[][]（字符串数组）等知识。
C语言/C++随机数生成，程序运行时间计时器（含高精度计时器），包括Windows环境与Linux环境
勾栏听曲_0的博客
04-20 3394
随机数生成，一秒内生成多个不通过的随机数；计算程序运行时间，程序运行时间计时。有利用srand与rand简单生成随机数，也有利用Windows与Linux独有的环境在一秒内生成多个不同的随机数。有使用clock函数的通用计算程序运行时间的方法，也有利用Windows与Linux独有的环境对程序运行时间的高精度的计时。
linux数字计数器,linux 使用 jiffies 计数器
weixin_35027153的博客
05-15 310
这个计数器和来读取它的实用函数位于 , 尽管你会常常只是包含, 它会自动地将 jiffies.h 拉进来. 不用说, jiffies 和 jiffies_64 必须当作只读的.无论何时你的代码需要记住当前的 jiffies 值, 可以简单地存取这个 unsigned long 变 量, 它被声明做 volatile 来告知编译器不要优化内存读. 你需要读取当前的计数器, 无 论何时你的代码需要计算...
linux脚本写的计算器,Linux bc命令实现数学计算器
weixin_31487521的博客
04-30 359
Bash Shell 内置了对整数运算的支持，但是并不支持浮点运算，而 Linux bc 命令可以很方便的进行浮点运算，当然整数运算也不再话下。bc 甚至可以称得上是一种编程语言了，它支持变量、数组、输入输出、分支结构、循环结构、函数等基本的编程元素，所以 Linux 手册中是这样来描述 bc 的：An arbitrary precision calculator language翻译过来就是“一...
Linux_5 任务之间同步-信号量
qq_44177768的博客
11-15 420
linux系统编程学习
高速计数器计数-测量脉冲的频率Ver1.0
06-17
高速计数器计数-测量脉冲的频率Ver1.0 西门子1200； 库，添加到博图V14sp1的全局库文件夹中即可使用；
交换计数器实现试验报告四.pdf
07-14
交换计数器实现试验报告四.pdf交换计数器实现试验报告四.pdf交换计数器实现试验报告四.pdf交换计数器实现试验报告四.pdf交换计数器实现试验报告四.pdf交换计数器实现试验报告四.pdf
51单片机程序计数器计数-C语言版.zip
05-11
51单片机程序计数器计数-C语言版.zip
频率计-8_单片机实现频率计数器_
09-28
此程序实现频率测量。测量原理：根据频率定义，每秒变化的次数就是频率，所以用计数器计数变化次数，用定时器定时一秒，读取计数值就是频率值
Linux线程安全之---信号量
weixin_45897952的博客
05-14 806
目录 1.信号量： 1.1、信号量的原理 1.2、信号量的接口 1.2.1、初始化接口： 1.2.2、等待接口： 1.2.3、释放接口： 1.2.4、销毁接口： 2.生产者与消费者信号量代码实现： 3.线程池： 3.1、应用场景 3.2、原理： 3.3、构造线程池要完成的事情 3.4、代码实现 4.读写锁 4.1、应用场景： 4.2、读写锁的三种状态 4.3、读写锁的接口： 面试题： 1.信号量： 1.1、信号量的原理 资源计数器+PCB等待队列
数据结构——二叉树（C语言版）
最新发布
2302_80657849的博客
05-30 597
二叉树是一种非线性的数据结构。二叉搜索树、堆、红黑树等高阶数据结构都是依托于二叉树的基础实现的，所以我们有必要好好研究一下“二叉树”这种数据结构。本文只介绍二叉树的基础及中等用法，笔者能力有限，欠妥当之处欢迎批评指正。
二叉排序树简单实现【C风格】
weixin_45690131的博客
05-30 180
利用二叉排序树对数据进行保存、搜索、删除
Linux - 磁盘的分区和挂载
weixin_45735487的博客
05-27 751
逻辑分区只能在拓展分区上划分，编号5-15。拓展分区编号1-4，拓展分区不能格式化。rescue 恢复分区,对于误删的分区进行恢复,语法: rescue 起始 结束。rm 删除分区,后接要删除的分区编号。（L） 在主分区和拓展分区划分完之后，默认提示划分逻辑分区。n 进行磁盘分区，这里会默认MBR标签。（p） msdos下，会默认选择先划分主分区。
【Linux】升级GCC（版本9.3），补充：binutils
yannan20190313的博客
05-27 802
【Linux】升级GCC（版本9.3），补充：binutils
实现定时计数器输出方波信号图像怎么画
06-10
要画出定时计数器输出方波信号的图像，你可以按照以下步骤进行： 1. 确定计数器的定时周期和计数器的工作方式（比如是上升沿触发还是下降沿触发）。 2. 根据定时周期，计算出每个计数器计数周期的时间长度。 3. ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值