数据结构4——linuxC(二叉树和排序算法)

分类：Node.js作者：编程之家用户

对于二叉树而言，有如下特性：
1.第i层上，最多有2^(i-1)个节点。
2.高度为k的二叉树，最多有2^k-1个节点。
3.假设叶子数目为n0，度为2的节点数目为n2，则有：n0= n2+1

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述1.二叉树的插入

#include <stdio.h>
#include <stdlib.h>
#include "drawtree.h"

// 二叉树数据节点
typedef struct node
{
	int data;	// 数据域
	struct node *lchild;	//左子树指针
	struct node *rchild;	//右子树指针
}node;

//二叉树插入
node *bst_insert(node *root, int new_data);
// 前序遍历: 根节点 - 左子树 - 右子树
void pre_traval(node *root);
// 中序遍历：左子树 - 根节点 - 右子树
void mid_traval(node *root);
// 后序遍历：左子树 - 右子树 - 根节点
void lst_traval(node *root);

int main()
{
	// 1.初始化空二叉树
	node *root = NULL;

	// 插入数据
	root = bst_insert(root, 10);
	root = bst_insert(root, 5);
	root = bst_insert(root, 15);
	root = bst_insert(root, 3);
	root = bst_insert(root, 8);
	root = bst_insert(root, 7);
	root = bst_insert(root, 9);
	root = bst_insert(root, 20);
	root = bst_insert(root, 18);

	// 2.数据操作
	int cmd;
	while(1)
	{
		printf("Pls Input: ");
		scanf("%d", &cmd); while(getchar()!='\n');
		if(cmd != 0)	//二叉树插入
			root = bst_insert(root, cmd);
		else if(cmd == 0)	// 遍历
		{
			printf("pre_traval: ");
			pre_traval(root);	// 前序遍历
			printf("\n");
			
			printf("mid_traval: ");
			mid_traval(root);	// 中序遍历
			printf("\n");
			
			printf("lst_traval: ");
			lst_traval(root);	// 后序遍历
			printf("\n");
		}
		
		draw((_treenode *)root);
	}

	return 0;
}

// 前序遍历: 根节点-左子树-右子树
void pre_traval(node *root)
{
	if(root == NULL)
		return;
	
	printf("%d ", root->data);
	pre_traval(root->lchild);
	pre_traval(root->rchild);
}

// 中序遍历：左子树 - 根节点 - 右子树
void mid_traval(node *root)
{
	if(root == NULL)
		return;
	
	mid_traval(root->lchild);
	printf("%d ", root->data);
	mid_traval(root->rchild);
}

// 后序遍历：左子树 - 右子树 - 根节点
void lst_traval(node *root)
{
	if(root == NULL)
		return;
	
	lst_traval(root->lchild);
	lst_traval(root->rchild);
	printf("%d ", root->data);
}

//二叉树插入
node *bst_insert(node *root, int new_data)
{
	if(root == NULL)
	{
		// 如果当前根节点为NULL，说明找到了插入位置
		node *new = malloc(sizeof(node));
		new->data = new_data;
		new->lchild = NULL;
		new->rchild = NULL;
		return new;
	}
	else if(root->data > new_data)	// 如果新数据更小,往左子树插入
		root->lchild = bst_insert(root->lchild, new_data);
	else if(root->data < new_data)	// 如果新数据更大,往右子树插入
		root->rchild = bst_insert(root->rchild, new_data);
	else	// 如果相等，已存在，不作处理
		printf("已存在\n");
	
	return root;
}

2.二叉树查找

#include <stdio.h>
#include <stdlib.h>
#include "drawtree.h"

// 二叉树数据节点
typedef struct node
{
	int data;	// 数据域
	struct node *lchild;	//左子树指针
	struct node *rchild;	//右子树指针
}node;

//二叉树插入
node *bst_insert(node *root, int new_data);
// 二叉树搜索
int bst_search(node *root, int find_data);
// 前序遍历: 根节点 - 左子树 - 右子树
void pre_traval(node *root);
// 中序遍历：左子树 - 根节点 - 右子树
void mid_traval(node *root);
// 后序遍历：左子树 - 右子树 - 根节点
void lst_traval(node *root);

int main()
{
	// 1.初始化空二叉树
	node *root = NULL;

	// 插入数据
	root = bst_insert(root, 10);
	root = bst_insert(root, 5);
	root = bst_insert(root, 15);
	root = bst_insert(root, 3);
	root = bst_insert(root, 8);
	root = bst_insert(root, 7);
	root = bst_insert(root, 9);
	root = bst_insert(root, 20);
	root = bst_insert(root, 18);

	// 2.数据操作
	int cmd;
	while(1)
	{
		printf("Pls Input find_data: ");
		scanf("%d", &cmd); while(getchar()!='\n');
		if(cmd != 0)	//二叉树搜索
		{
			if(bst_search(root, cmd) == 0)
				printf("找到了\n");
			else
				printf("无此数据\n");
		}
		else if(cmd == 0)	// 遍历
		{
			printf("pre_traval: ");
			pre_traval(root);	// 前序遍历
			printf("\n");
			
			printf("mid_traval: ");
			mid_traval(root);	// 中序遍历
			printf("\n");
			
			printf("lst_traval: ");
			lst_traval(root);	// 后序遍历
			printf("\n");
		}
		
		draw((_treenode *)root);
	}

	return 0;
}

// 二叉树搜索
int bst_search(node *root, int find_data)
{
	if(root == NULL)	// 无此数据
		return -1;
	
	printf("find\n");
	if(root->data == find_data)	// 找到指定数据
		return 0;
	else if(find_data < root->data)
		return bst_search(root->lchild, find_data);
	else if(find_data > root->data)
		return bst_search(root->rchild, find_data);
}

// 前序遍历: 根节点-左子树-右子树
void pre_traval(node *root)
{
	if(root == NULL)
		return;
	
	printf("%d ", root->data);
	pre_traval(root->lchild);
	pre_traval(root->rchild);
}

// 中序遍历：左子树 - 根节点 - 右子树
void mid_traval(node *root)
{
	if(root == NULL)
		return;
	
	mid_traval(root->lchild);
	printf("%d ", root->data);
	mid_traval(root->rchild);
}

// 后序遍历：左子树 - 右子树 - 根节点
void lst_traval(node *root)
{
	if(root == NULL)
		return;
	
	lst_traval(root->lchild);
	lst_traval(root->rchild);
	printf("%d ", root->data);
}

//二叉树插入
node *bst_insert(node *root, int new_data)
{
	if(root == NULL)
	{
		// 如果当前根节点为NULL，说明找到了插入位置
		node *new = malloc(sizeof(node));
		new->data = new_data;
		new->lchild = NULL;
		new->rchild = NULL;
		return new;
	}
	else if(root->data > new_data)	// 如果新数据更小,往左子树插入
		root->lchild = bst_insert(root->lchild, new_data);
	else if(root->data < new_data)	// 如果新数据更大,往右子树插入
		root->rchild = bst_insert(root->rchild, new_data);
	else	// 如果相等，已存在，不作处理
		printf("已存在\n");
	
	return root;
}

drawtree.h

///
//
//  Copyright(C), 2013-2017, GEC Tech. Co., Ltd.
//
//  文件: lab/tree/headers/drawtree.h
//  日期: 2017-9
//  描述: 使用C语言写一页webpage展示二叉树
//
//  作者: Vincent Lin (林世霖)   微信公众号：秘籍酷
//  技术微店: http://weidian.com/?userid=260920190
//  技术交流: 260492823（QQ群）
//
///

#ifndef _DRAWTREE_H_
#define _DRAWTREE_H_

/* ↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓ 公共头文件 ↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓ */
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <unistd.h>
#include <string.h>
#include <strings.h>
#include <time.h>
#include <errno.h>

#include <sys/stat.h>
#include <sys/types.h>
#include <fcntl.h>

#include <sys/ipc.h>
#include <sys/sem.h>
#include <sys/shm.h>
#include <sys/msg.h>
#include <semaphore.h>
#include <fcntl.h>

#include <pthread.h>
/* ↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑ 公共头文件 ↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑ */

#define MAX(a, b) ({ \
		typeof(a) _a = a; \
		typeof(b) _b = b; \
		(void)(&_a == &_b);\
		_a > _b? _a : _b; \
		})


/* ↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓ 默认二叉树节点 ↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓ */
typedef struct _tree_node
{
	int data;
	struct _tree_node *lchild;
	struct _tree_node *rchild;

#ifdef AVL
	int height;
#endif

#ifdef RB
	struct _tree_node *parent;
	int color;
#endif
}_treenode, *_linktree;
/* ↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑ 默认二叉树节点 ↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑ */


/* ↓↓↓↓↓ 用户指定二叉树节点 ↓↓↓↓↓ */
#ifndef NODE
#define NODE _treenode
#endif
/* ↑↑↑↑↑ 用户指定二叉树节点 ↑↑↑↑↑ */



/* ↓↓↓↓↓↓↓↓↓↓↓↓↓ 画网页相关算法代码 ↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓ */

#ifndef QUEUE_NODE_DATATYPE
#define QUEUE_NODE_DATATYPE NODE *
#endif

typedef QUEUE_NODE_DATATYPE qn_datatype;

struct _queue_node
{
	qn_datatype data;
	struct _queue_node *next;

};

typedef struct
{
	struct _queue_node *front;
	struct _queue_node *rear;
#ifdef QUEUE_SIZE
	int size;
#endif
}_queuenode, *_linkqueue;


static _linkqueue init_queue(void)
{
    _linkqueue q = (_linkqueue)malloc(sizeof(_queuenode));
	q->front = q->rear =
		(struct _queue_node *)malloc(sizeof(struct _queue_node));
	q->rear->next = NULL;

	return q;
}

static bool is_empty_q(_linkqueue q)
{
	return (q->front == q->rear);
}

/* ↓↓↓↓↓↓↓↓↓↓↓↓↓ 画网页相关算法代码 ↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓ */
static bool out_queue(_linkqueue q, qn_datatype *pdata)
{
	if(is_empty_q(q))
		return false;

	struct _queue_node *p = q->front;

	q->front = q->front->next;
	free(p);
	*pdata = q->front->data;

	return true;
}

static bool en_queue(_linkqueue q, qn_datatype data)
{
	struct _queue_node *pnew;
	pnew = (struct _queue_node *)malloc(sizeof(struct _queue_node));
	if(pnew == NULL)
		return false;

	pnew->data = data;
	pnew->next = NULL;

	q->rear->next = pnew;
	q->rear = pnew;

	return true;
}

#ifdef QUEUE_SIZE
int queue_size(_linkqueue *q)
{
	return q->size;
}
#endif
/* ↓↓↓↓↓↓↓↓↓↓↓↓↓ 画网页相关算法代码 ↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓ */


static inline void pre_travel(NODE *root, void (*handler)(NODE *))
{
	if(root == NULL)
		return;
	
	handler(root);
	pre_travel(root->lchild, handler);
	pre_travel(root->rchild, handler);
}

static inline void mid_travel(NODE *root, void (*handler)(NODE *))
{
	if(root == NULL)
		return;
	
	mid_travel(root->lchild, handler);
	handler(root);
	mid_travel(root->rchild, handler);
}

static inline void post_travel(NODE *root, void (*handler)(NODE *))
{
	if(root == NULL)
		return;

	post_travel(root->lchild, handler);
	post_travel(root->rchild, handler);
	handler(root);
}

/* ↓↓↓↓↓↓↓↓↓↓↓↓↓ 画网页相关算法代码 ↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓ */
static inline void level_travel(NODE *root, void (*handler)(NODE *))
{
	if(root == NULL)
		return;

    _linkqueue q;
	q = init_queue();

	en_queue(q, root);

    NODE *tmp;
	while(1)
	{
		if(!out_queue(q, &tmp))
			break;

		handler(tmp);

		if(tmp->lchild != NULL)
			en_queue(q, tmp->lchild);
		if(tmp->rchild != NULL)
			en_queue(q, tmp->rchild);
	}
}
/* ↓↓↓↓↓↓↓↓↓↓↓↓↓ 画网页相关算法代码 ↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓ */
static char page_begin[] = "<html><head><title>tree map"
                           "</title></head><body>"
			   "<table border=0 cellspacing"
                           "=0 cellpadding=0>";
static char line_begin[] = "<tr>";
static char line_end  [] = "</tr>";
static char space     [] = "<td>&nbsp;</td>";
static char underline [] = "<td style=\"border-bottom:"
	 		   "1px solid #58CB64\">&nbsp;"
                           "</td>";

#ifdef RB
static char data_begin_red[] = "<td bgcolor=\"#FF0000\";style="
			       "\"border:1px sol"
                               "id #58CB64;background-colo"
                               "r:#DDF1D8;PADDING:2px;\" t"
                               "itle=\"level: 1\">";
static char data_begin_blk[] = "<td bgcolor=\"#000000\";style="
			       "\"border:1px sol"
                               "id #58CB64;background-colo"
                               "r:#DDF1D8;PADDING:2px;\" t"
                               "itle=\"level: 1\"><font color"
				"=\"#FFFFFF\">";
static char data_end_red[] = "</td>";
static char data_end_blk[] = "</font></td>";
#else
static char data_begin[] = "<td style=\"border:1px sol"
                           "id #58CB64;background-colo"
                           "r:#DDF1D8;PADDING:2px;\" t"
                           "itle=\"level: 1\">";
static char data_end  [] = "</td>";
#endif

static char page_end  [] = "</table></body></html>";

#define MAX_NODES_NUMBER 100
#define FILENAME 32

static int central_order[MAX_NODES_NUMBER];

static void putunderline(int fd, int num)
{
	int i;
	for(i=0; i<num; i++)
	{
		write(fd, underline, strlen(underline));
	}
}


static void putspace(int fd, int num)
{
	int i;
	for(i=0; i<num; i++)
	{
		write(fd, space, strlen(space));
	}
}
/* ↓↓↓↓↓↓↓↓↓↓↓↓↓ 画网页相关算法代码 ↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓ */
#ifdef RB
static void putdata(int fd, NODE * p)
{
	char s[50];
	bzero(s, 50);

	snprintf(s, 50, "%d", p->data);

	switch(p->color)
	{
	case RED:
		write(fd, data_begin_red, strlen(data_begin_red));
		write(fd, s, strlen(s));
		write(fd, data_end_red, strlen(data_end_red));
		break;
	case BLACK:
		write(fd, data_begin_blk, strlen(data_begin_blk));
		write(fd, s, strlen(s));
		write(fd, data_end_blk, strlen(data_end_blk));
	}
}
#else
static void putdata(int fd, int data)
{
	char s[50];
	bzero(s, 50);

	snprintf(s, 50, "%d", data);
	write(fd, data_begin, strlen(data_begin));
	write(fd, s, strlen(s));
	write(fd, data_end, strlen(data_end));
}
#endif

static int Index = 0;
static void create_index(NODE * root)
{
	if(Index >= MAX_NODES_NUMBER-1)
		return;

	central_order[Index++] = root->data;
}


static int get_index(int data)
{
	int i;
	for(i=0; i<100; i++)
	{
		if(central_order[i] == data)
			return i;
	}
	return -1;
}

/* ↓↓↓↓↓↓↓↓↓↓↓↓↓ 画网页相关算法代码 ↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓ */
static void data_leftside(int fd, NODE * root, int spaces)
{
	if(root == NULL)
		return;

	int s_line=0;

	if(root->lchild != NULL)
	{
		s_line = get_index(root->data)-
			 get_index(root->lchild->data)-1;
	}
	putspace(fd, spaces-s_line);
	putunderline(fd, s_line);
}


static int data_rightside(int fd, NODE * root)
{
	if(root == NULL)
		return 0;

	int s_line=0;

	if(root->rchild != NULL)
	{
		s_line = get_index(root->rchild->data)-
			 get_index(root->data)-1;
	}

	putunderline(fd, s_line);
	return s_line;
}


static void start_page(int fd)
{
	write(fd, page_begin, strlen(page_begin));
}

/* ↓↓↓↓↓↓↓↓↓↓↓↓↓ 画网页相关算法代码 ↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓ */
static void end_page(int fd)
{
	write(fd, page_end, strlen(page_end));
}


static void draw(NODE * root)
{
	if(root == NULL)
		return;

	time_t t;
	time(&t);
	static char filename[FILENAME];
	bzero(filename, FILENAME);
	snprintf(filename, FILENAME, "1.html");
	int fd = open(filename, O_CREAT | O_TRUNC | O_RDWR, 0644);
	if(fd == -1)
	{
		perror("open() failed");
		exit(1);
	}

	Index = 0;
	mid_travel(root, create_index);

    _linkqueue q = init_queue();

	NODE * tmp = root;
	int ndata = 1;

	start_page(fd);
	while(1)
	{
		write(fd, line_begin, strlen(line_begin));

		int i, n = 0;
		int nextline = 0;
		for(i=0; i<ndata; i++)
		{
			int index = get_index(tmp->data);

			data_leftside(fd, tmp, index-n);

			#ifdef RB
			putdata(fd, tmp);
			#else
			putdata(fd, tmp->data);
			#endif
			int rightline = data_rightside(fd, tmp);

			if(tmp->lchild != NULL)
			{
				nextline++;
				en_queue(q, tmp->lchild);
			}
			if(tmp->rchild != NULL)
			{
				nextline++;
				en_queue(q, tmp->rchild);
			}
			if(!out_queue(q, &tmp))
				return;

			n = index + rightline;
			n++;
		}
		write(fd, line_end, strlen(line_end));
		ndata = nextline;
	}
	end_page(fd);
	close(fd);
}
#endif

在这里插入图片描述

冒泡排序

#include <stdio.h>

void show_array(int len, int *a)
{
	int i;
	for(i=0; i<len; i++)
		printf("%d ", a[i]);
	printf("\n");
}

void bubble_sort(int len, int *a)
{
	// 遍历次数：len-1
	int i, j;
	int temp;
	int flag;
	for(i=0; i<len-1; i++)
	{
		flag=0;
		// 两两对比，左数大于右数则交换（次数: len-i-1）
		for(j=0; j<len-i-1; j++)
		{
			if(a[j] > a[j+1])
			{
				temp = a[j];
				a[j] = a[j+1];
				a[j+1] = temp;
				flag = 1;
			}
		}

		printf("%d: ", i+1);
		show_array(5, a);
		
		// 如果没有发生数据交换，则说明已经是有序列
		if(flag == 0)
			break;
	}
}

int main()
{
	int arr[5] = {5, 4, 3, 2, 1};
	show_array(5, arr);

	bubble_sort(5, arr);

	show_array(5, arr);

	return 0;
}

插入排序-额外空间

#include <stdio.h>

void show_array(int len, int *a)
{
	int i;
	for(i=0; i<len; i++)
		printf("%d ", a[i]);
	printf("\n");
}

void insertion_sort(int len, int *a)
{
	// 1.定义有序列数组，将第1个数据放入
	int b[len];
	b[0] = a[0];

	// 2.将原始数据的每个数据与有序列中数据对比，找到插入位置pos
	int i;		// 原始数据操作下标
	int j;		// 向后移动变量
	int pos;	// 有序列对比下标
	for(i=1; i<len; i++)
	{
		// 2.1 在有序列中循环找到插入位置pos后，break结束
		for(pos=0; pos<i; pos++)	
		{
			if(a[i] < b[pos])
				break;
		}
		// 2.2 将pos后续数据向后移动（从最后开始）
		for(j=i; j>pos; j--)
			b[j] = b[j-1];
		// 2.3 数据放入有序列中pos位置
		b[pos] = a[i];

		// 把中间过程的数据打印出来
		printf("%d: ", i);
		show_array(5, b);
	}

	// 3.将有序列数据覆盖无序列
	for(i=0; i<len; i++)
		a[i] = b[i];
}

int main()
{
	int arr[5] = {2, 5, 3, 1, 4};
	show_array(5, arr);

	insertion_sort(5, arr);

	show_array(5, arr);

	return 0;
}

插入排序

#include <stdio.h>

void show_array(int len, int *a)
{
	int i;
	for(i=0; i<len; i++)
		printf("%d ", a[i]);
	printf("\n");
}

void insertion_sort(int len, int *a)
{
	int swap;	//无序列数下标
	int pos;
	int i;
	// 逐个循环取得无序数
	for(swap=1; swap<len; swap++)
	{
		// 1.暂存当前无序数
		int temp = a[swap];

		// 2.该无序数与有序列每个数据对比，找到插入位置pos
		for(pos=0; pos<swap; pos++)
		{
			if(temp < a[pos])
				break;
		}

		// 3.将pos后续数据逐个向后移动（从后开始）
		int i;
		for(i=swap; i>pos; i--)
			a[i] = a[i-1];
		
		// 4.将该无序数写入有序列
		a[pos] = temp;
	}
}

int main()
{
	int arr[5] = {2, 5, 3, 1, 4};
	show_array(5, arr);

	// 不使用额外内存
	insertion_sort(5, arr);

	show_array(5, arr);

	return 0;
}

原文地址：https://blog.csdn.net/weixin_43233219/article/details/123238428

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 dio@foxmail.com 举报，一经查实，本站将立刻删除。

相关推荐

基于nodejs的ssh2怎么实现自动化部署
这篇文章主要介绍“基于nodejs的ssh2怎么实现自动化部署”的相关知识，小编通过实际案例向大家展示操作过程，操作方法简单快捷，实用性强，希望这篇“基于nodejs...
nodejs怎么实现目录不存在自动创建
本文小编为大家详细介绍“nodejs怎么实现目录不存在自动创建”，内容详细，步骤清晰，细节处理妥当，希望这篇“nodejs怎么实现目录不存在自动创建”文章能帮助大...
如何把nodejs数据传到前端
这篇“如何把nodejs数据传到前端”文章的知识点大部分人都不太理解，所以小编给大家总结了以下内容，内容详细，步骤清晰，具有一定的借鉴价值，希望大家阅读完这...
nodejs如何实现定时删除文件
本文小编为大家详细介绍“nodejs如何实现定时删除文件”，内容详细，步骤清晰，细节处理妥当，希望这篇“nodejs如何实现定时删除文件”文章能帮助大家解决疑惑...
nodejs安装模块卡住不动怎么解决
这篇文章主要讲解了“nodejs安装模块卡住不动怎么解决”，文中的讲解内容简单清晰，易于学习与理解，下面请大家跟着小编的思路慢慢深入，一起来...
如何检测nodejs有没有安装成功
今天小编给大家分享一下如何检测nodejs有没有安装成功的相关知识点，内容详细，逻辑清晰，相信大部分人都还太了解这方面的知识，所以分享这篇文...
怎么安装Node.js的旧版本
本篇内容主要讲解“怎么安装Node.js的旧版本”，感兴趣的朋友不妨来看看。本文介绍的方法操作简单快捷，实用性强。下面就让小编来带大家学习“怎...
node中的Express框架怎么安装使用
这篇“node中的Express框架怎么安装使用”文章的知识点大部分人都不太理解，所以小编给大家总结了以下内容，内容详细，步骤清晰，具有一定的借鉴价值，希望大家...
nodejs如何实现搜索引擎
这篇文章主要介绍“nodejs如何实现搜索引擎”的相关知识，小编通过实际案例向大家展示操作过程，操作方法简单快捷，实用性强，希望这篇“nodejs如何实现搜索引擎...
nodejs中间层如何设置
这篇文章主要介绍“nodejs中间层如何设置”的相关知识，小编通过实际案例向大家展示操作过程，操作方法简单快捷，实用性强，希望这篇“nodejs中间层如何设置”文...
nodejs多线程怎么实现
这篇文章主要介绍“nodejs多线程怎么实现”，在日常操作中，相信很多人在nodejs多线程怎么实现问题上存在疑惑，小编查阅了各式资料，整理出简单好用的操作方法...
nodejs怎么分布式
这篇文章主要讲解了“nodejs怎么分布式”，文中的讲解内容简单清晰，易于学习与理解，下面请大家跟着小编的思路慢慢深入，一起来研究和学习“nodejs怎么分布式”...
nodejs字符串怎么转换为数组
本篇内容介绍了“nodejs字符串怎么转换为数组”的有关知识，在实际案例的操作过程中，不少人都会遇到这样的困境，接下来就让小编带领大家学习一下如何处理这些情...
nodejs如何运行在php服务器
这篇文章主要介绍了nodejs如何运行在php服务器的相关知识，内容详细易懂，操作简单快捷，具有一定借鉴价值，相信大家阅读完这篇nodejs如何运行在php服务器文章都...
nodejs单线程如何处理事件
本篇内容主要讲解“nodejs单线程如何处理事件”，感兴趣的朋友不妨来看看。本文介绍的方法操作简单快捷，实用性强。下面就让小编来带大家学习“nodejs单线程如何...
nodejs怎么安装ws模块
这篇文章主要介绍“nodejs怎么安装ws模块”，在日常操作中，相信很多人在nodejs怎么安装ws模块问题上存在疑惑，小编查阅了各式资料，整理出简单好用的操作方法...
怎么打包nodejs代码
本篇内容介绍了“怎么打包nodejs代码”的有关知识，在实际案例的操作过程中，不少人都会遇到这样的困境，接下来就让小编带领大家学习一下如何处理这些情况吧！
nodejs接收到的汉字乱码怎么解决
本文小编为大家详细介绍“nodejs接收到的汉字乱码怎么解决”，内容详细，步骤清晰，细节处理妥当，希望这篇“nodejs接收到的汉字乱码怎么解决”文章能帮助大家解...
nodejs怎么同步删除文件
这篇“nodejs怎么同步删除文件”文章的知识点大部分人都不太理解，所以小编给大家总结了以下内容，内容详细，步骤清晰，具有一定的借鉴价值，希望大家阅读完这篇...
nodejs怎么设置淘宝镜像
今天小编给大家分享一下nodejs怎么设置淘宝镜像的相关知识点，内容详细，逻辑清晰，相信大部分人都还太了解这方面的知识，所以分享这篇文章给大家参考一下，希
pythonJavaScriptjavaHTMLPHPreactjsC#AndroidCSSNode.jssqlrpython-3.xMysqLjQueryc++pandasFlutterangularIOSdjangolinuxswifttypescript路由器JSON路由器设置无线路由器h3c华三华三路由器设置华三路由器电脑软件教程arraysdocker软件图文教程Cvue.jslaravelspring-boot