【数据结构】：二叉树与堆排序的实现

news2024/11/24 6:19:26

在这里插入图片描述

1.树概念及结构(了解)

1.1树的概念

树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的有一个特殊的结点，称为根结点，根节点没有前驱结点
除根节点外，其余结点被分成M(M>0)个互不相交的集合T1、T2、……、Tm，其中每一个集合Ti(1<= i <= m)又是一棵结构与树类似的子树。每棵子树的根结点有且只有一个前驱，可以有0个或多个后继
因此，树是递归定义的
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
节点的度：一个节点含有的子树的个数称为该节点的度； 如上图：A的为6
叶节点或终端节点：度为0的节点称为叶节点； 如上图：B、C、H、I…等节点为叶节点
非终端节点或分支节点：度不为0的节点； 如上图：D、E、F、G…等节点为分支节点
双亲节点或父节点：若一个节点含有子节点，则这个节点称为其子节点的父节点； 如上图：A是B的父节点
孩子节点或子节点：一个节点含有的子树的根节点称为该节点的子节点； 如上图：B是A的孩子节点
兄弟节点：具有相同父节点的节点互称为兄弟节点； 如上图：B、C是兄弟节点
树的度：一棵树中，最大的节点的度称为树的度； 如上图：树的度为6
节点的层次：从根开始定义起，根为第1层，根的子节点为第2层，以此类推；
树的高度或深度：树中节点的最大层次； 如上图：树的高度为4
节点的祖先：从根到该节点所经分支上的所有节点；如上图：A是所有节点的祖先
子孙：以某节点为根的子树中任一节点都称为该节点的子孙。如上图：所有节点都是A的子孙
森林：由m（m>0）棵互不相交的多颗树的集合称为森林；（数据结构中的学习并查集本质就是一个森林）

1.2树的表示

树结构相对线性表就比较复杂了，要存储表示起来就比较麻烦了，实际中树有很多种表示方式，
如：双亲表示法，孩子表示法、孩子兄弟表示法等等。我们这里就简单的了解其中最常用的孩子
兄弟表示法

typedef int DataType;
struct Node
{
    struct Node* _firstChild1;    // 第一个孩子结点
    struct Node* _pNextBrother;   // 指向其下一个兄弟结点
    DataType _data;               // 结点中的数据域
};

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
注意：在Linux中我们能够输入tree指令把我们电脑中的文件以多叉树的形式呈现

2.二叉树概念及结构

2.1概念

一棵二叉树是结点的一个有限集合，该集合或者为空，或者是由一个根节点加上两棵别称为左子
树和右子树的二叉树组成。

二叉树的特点：

  1. 每个结点最多有两棵子树，即二叉树不存在度大于2的结点。
  2. 二叉树的子树有左右之分，其子树的次序不能颠倒。

2.2现实中的二叉树：

在这里插入图片描述
在这里插入图片描述

2.3数据结构中的二叉树：

在这里插入图片描述

2.4特殊的二叉树：

  1. 满二叉树：一个二叉树，如果每一个层的结点数都达到最大值，则这个二叉树就是满二叉树。也就是说，如果一个二叉树的层数为K，且结点总数是(2^k) -1 ，则它就是满二叉树。
  2. 完全二叉树：完全二叉树是效率很高的数据结构，完全二叉树是由满二叉树而引出来的。对于深度为K的，有n个结点的二叉树，当且仅当其每一个结点都与深度为K的满二叉树中编号从1至n的结点一一对应时称之为完全二叉树。 要注意的是满二叉树是一种特殊的完全二叉树
    在这里插入图片描述

2.5 二叉树的存储结构

二叉树一般可以使用两种结构存储，一种顺序结构，一种链式结构。
二叉树的性质

  1. 若规定根节点的层数为1，则一棵非空二叉树的第i层上最多有2^(i-1) 个结点.
  2. 若规定根节点的层数为1，则深度为h的二叉树的最大结点数是2^h- 1.
  3. 对任何一棵二叉树, 如果度为0其叶结点个数为 n0, 度为2的分支结点个数为 n2,则有n0＝n2+1
  4. 若规定根节点的层数为1，具有n个结点的满二叉树的深度，h=LogN

2.5.1 顺序存储：

顺序结构存储就是使用数组来存储，一般使用数组只适合表示完全二叉树，因为不是完全二叉树会有空间的浪费。而现实中使用中只有堆才会使用数组来存储，关于堆我们后面的章节会专门讲解。二叉树顺序存储在物理上是一个数组，在逻辑上是一颗二叉树
在这里插入图片描述

2.5.2 链式存储：

二叉树的链式存储结构是指，用链表来表示一棵二叉树，即用链来指示元素的逻辑关系。 通常的方法是链表中每个结点由三个域组成，数据域和左右指针域，左右指针分别用来给出该结点左孩子和右孩子所在的链结点的存储地址 。链式结构又分为二叉链和三叉链，当前我们学习中一般都是二叉链，后面课程学到高阶数据结构如红黑树等会用到三叉链
在这里插入图片描述
在这里插入图片描述

// 二叉链
struct BinaryTreeNode
{
    struct BinTreeNode* pLeft;   // 指向当前节点左孩子
    struct BinTreeNode* pRight; // 指向当前节点右孩子
    BTDataType _data; // 当前节点值域
}
// 三叉链
struct BinaryTreeNode
{
    struct BinTreeNode* pParent; // 指向当前节点的双亲
    struct BinTreeNode* pLeft;   // 指向当前节点左孩子
    struct BinTreeNode* pRight; // 指向当前节点右孩子
    BTDataType _data; // 当前节点值域
}；

3.二叉树链式结构的实现

3.1二叉树链式结构的遍历

所谓遍历(Traversal)是指沿着某条搜索路线，依次对树中每个结点均做一次且仅做一次访问。访问结点所做的操作依赖于具体的应用问 题。 遍历是二叉树上最重要的运算之一，是二叉树上进行其它运算之基础
在这里插入图片描述
前序/中序/后序的递归结构遍历：是根据访问结点操作发生位置命名

  1. NLR：前序遍历(Preorder Traversal 亦称先序遍历)——访问根结点的操作发生在遍历其左右子树之前
  2. LNR：中序遍历(Inorder Traversal)——访问根结点的操作发生在遍历其左右子树之中（间）
  3. LRN：后序遍历(Postorder Traversal)——访问根结点的操作发生在遍历其左右子树之后由于被访问的结点必是某子树的根，所以N(Node）、L(Left subtree）和R(Right subtree）又可解释为根、根的左子树和根的右子树。NLR、LNR和LRN分别又称为先根遍历、中根遍历和后根遍历
    在这里插入图片描述
    在这里插入图片描述
    层序遍历：除了先序遍历、中序遍历、后序遍历外，还可以对二叉树进行层序遍历。设二叉树的
    根节点所在层数为1，层序遍历就是从所在二叉树的根节点出发，首先访问第一层的树根节点，然
    后从左到右访问第2层上的节点，接着是第三层的节点，以此类推，自上而下，自左至右逐层访问
    树的结点的过程就是层序遍历
    在这里插入图片描述
    练习：请写出下面的前序/中序/后序/层序遍历
    在这里插入图片描述

实现推排序

堆排序(Heapsort)是指利用堆积树（堆）这种数据结构所设计的一种排序算法，它是选择排序的一种 它是通过堆来进行选择数据。需要注意的是排升序要建大堆，排降序建小堆
遵循最大堆与最小堆的原则
最大堆：每个节点的值都大于或者等于他的左右孩子节点的值
在这里插入图片描述
最小堆：每个节点的值都大于或者等于他的左右孩子节点的值
在这里插入图片描述
在这里插入图片描述

  1. 堆排序使用堆来选数，效率就高了很多
  2. 时间复杂度：O(N*logN)
  3. 空间复杂度：O(1)
  4. 稳定性：不稳定
    堆排序总的代码的实现
#pragma once
#include<stdio.h>
#include<assert.h>
#include<stdlib.h>
#include<stdbool.h>
typedef int HPDataType;
typedef struct Heap
{
	HPDataType* a;
	HPDataType _size;
	HPDataType _capacity;
}HP;
void HeapInit(HP* php);
void HeapDestroy(HP* php);
void HeapPush(HP* php, HPDataType x);
void HeapPop(HP* php);
bool HeapEmpty(HP* php);
HPDataType HeapTop(HP* php);

#include"Heap.h"
void HeapInit(HP* php)
{
	assert(php);
	php->a = NULL;
	php->_size = 0;
	php->_capacity = 0;
}

void HeapDestroy(HP* php)
{
	assert(php);
	free(php->a);
	php->a = NULL;
	php->_size = 0;
	php->_capacity = 0;
}

void AdJustUP(HPDataType* a, int child)
{
	int parent = (child - 1) / 2;
	while (child > 0)
	{
		if (a[child] < a[parent]) {
			Swap(&a[child], &a[parent]);//C语言交换函数可自行尝试解决
			child = parent;
			parent = (parent - 1) / 2;
		}
		else {
			break;
		}
	}
}

void AdjustDown(HPDataType* a, int n, int parent)
{
	int child = parent * 2 + 1;
	while (child < n)
	{
		// 找出小的那个孩子
		if (child + 1 < n && a[child + 1] > a[child])
		{
			++child;
		}

		if (a[child] > a[parent])
		{
			Swap(&a[child], &a[parent]);
			// 继续往下调整
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}

void HeapPush(HP* php, HPDataType x)
{
	assert(php);
	if (php->_capacity == php->_size)
	{
		int NewCapacity = php->_capacity = 0 ? 4 : php->_capacity * 2;
		HPDataType* temp = (HPDataType*)realloc(php->a, sizeof(HPDataType) * NewCapacity);
		if (temp == NULL) {
			perror("realloc fail");
			exit(-1);
		}
		php->a = temp;
		php->_capacity = NewCapacity;
	}
	php->a[php->_size] = x;
	php->_size++;
	AdJustUP(php->a, php->_size - 1);
}

void HeapPop(HP* php)
{
	assert(php);
	assert(php->_size > 0);

	Swap(&php->a[0], &php->a[php->_size - 1]);
	--php->_size;

	AdjustDown(php->a, php->_size, 0);
}

HPDataType HeapTop(HP* php)
{
	assert(php);
	assert(php->_size > 0);

	return php->a[0];
}

bool HeapEmpty(HP* php)
{
	assert(php);

	return php->_size == 0;
}

在这里插入图片描述
这里涉及一些数学知识 稍微想一下就能够理解各位老铁 等差数列和等比数列的知识

实现二叉树

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


// 不是增删查改，学习二叉树结构
typedef struct BinaryTreeNode
{
	struct BinaryTreeNode* left;
	struct BinaryTreeNode* right;
	int val;
}BTNode;

BTNode* BuyNode(int x)
{
	BTNode* node = (BTNode*)malloc(sizeof(BTNode));
	if (node == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}

	node->val = x;
	node->left = NULL;
	node->right = NULL;

	return node;
}

void PrevOrder(BTNode* root) {
	if (root == NULL) {
		printf("NULL ");

		return;
	}

	printf("%d ", root->val);
	PrevOrder(root->left);
	PrevOrder(root->right);
}

void InOrder(BTNode* root)
{
	if (root == NULL)
	{
		printf("NULL ");
		return;
	}

	InOrder(root->left);
	printf("%d ", root->val);
	InOrder(root->right);
}

void PostOrder(BTNode* root)
{
	if (root == NULL)
	{
		printf("NULL ");
		return;
	}

	PostOrder(root->left);
	PostOrder(root->right);
	printf("%d ", root->val);
}

// 节点个数
//int TreeSize(BTNode* root)
//{
//	static int size = 0;
//	if (root == NULL)
//		return 0;
//	else
//		++size;
//
//	TreeSize(root->left);
//	TreeSize(root->right);
//
//	return size;
//}

//int size = 0;
//int TreeSize(BTNode* root)
//{
//	if (root == NULL)
//		return 0;
//	else
//		++size;
//
//	TreeSize(root->left);
//	TreeSize(root->right);
//
//	return size;
//}

int TreeSize(BTNode* root)
{
	return root == NULL ? 0 : TreeSize(root->left) + TreeSize(root->right) + 1;
}

// 叶子节点个数
int TreeLeafSize(BTNode* root)
{
	if (root == NULL)
		return 0;

	if (root->left == NULL && root->right == NULL)
	{
		return 1;
	}

	return TreeLeafSize(root->left) + TreeLeafSize(root->right);
}

// 第k层的节点个数
int TreeKLevel(BTNode* root, int k)
{
	assert(k > 0);

	if (root == NULL)
		return 0;

	if (k == 1)
	{
		return 1;
	}

	return TreeKLevel(root->left, k - 1)
		+ TreeKLevel(root->right, k - 1);
}

int main()
{
	// 手动构建
	BTNode* node1 = BuyNode(1);
	BTNode* node2 = BuyNode(2);
	BTNode* node3 = BuyNode(3);
	BTNode* node4 = BuyNode(4);
	BTNode* node5 = BuyNode(5);
	BTNode* node6 = BuyNode(6);

	node1->left = node2;
	node1->right = node4;
	node2->left = node3;
	node4->left = node5;
	node4->right = node6;

	PrevOrder(node1);
	printf("\n");

	InOrder(node1);
	printf("\n");

	PostOrder(node1);
	printf("\n");

	printf("%d\n", TreeSize(node1));

	//size = 0;
	printf("%d\n", TreeSize(node1));


	return 0;
}

二叉树的本质是递归
这里二叉树的遍历又分为前中后序遍历
前面的图片已经给大家呈现出来了
下面给大家画一个二叉树前序遍历的递归展开图
在这里插入图片描述
中后序递归展开图大家可以下去自己画图试一试

总的代码实现如下

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


// 不是增删查改，学习二叉树结构
typedef struct BinaryTreeNode
{
	struct BinaryTreeNode* left;
	struct BinaryTreeNode* right;
	int val;
}BTNode;

BTNode* BuyNode(int x)
{
	BTNode* node = (BTNode*)malloc(sizeof(BTNode));
	if (node == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}

	node->val = x;
	node->left = NULL;
	node->right = NULL;

	return node;
}

void PrevOrder(BTNode* root) {
	if (root == NULL) {
		printf("NULL ");

		return;
	}

	printf("%d ", root->val);
	PrevOrder(root->left);
	PrevOrder(root->right);
}

void InOrder(BTNode* root)
{
	if (root == NULL)
	{
		printf("NULL ");
		return;
	}

	InOrder(root->left);
	printf("%d ", root->val);
	InOrder(root->right);
}

void PostOrder(BTNode* root)
{
	if (root == NULL)
	{
		printf("NULL ");
		return;
	}

	PostOrder(root->left);
	PostOrder(root->right);
	printf("%d ", root->val);
}

// 节点个数
//int TreeSize(BTNode* root)
//{
//	static int size = 0;
//	if (root == NULL)
//		return 0;
//	else
//		++size;
//
//	TreeSize(root->left);
//	TreeSize(root->right);
//
//	return size;
//}

//int size = 0;
//int TreeSize(BTNode* root)
//{
//	if (root == NULL)
//		return 0;
//	else
//		++size;
//
//	TreeSize(root->left);
//	TreeSize(root->right);
//
//	return size;
//}

int TreeSize(BTNode* root)
{
	return root == NULL ? 0 : TreeSize(root->left) + TreeSize(root->right) + 1;
}

// 叶子节点个数
int TreeLeafSize(BTNode* root)
{
	if (root == NULL)
		return 0;

	if (root->left == NULL && root->right == NULL)
	{
		return 1;
	}

	return TreeLeafSize(root->left) + TreeLeafSize(root->right);
}

// 第k层的节点个数
int TreeKLevel(BTNode* root, int k)
{
	assert(k > 0);

	if (root == NULL)
		return 0;

	if (k == 1)
	{
		return 1;
	}

	return TreeKLevel(root->left, k - 1)
		+ TreeKLevel(root->right, k - 1);
}

int main()
{
	// 手动构建
	BTNode* node1 = BuyNode(1);
	BTNode* node2 = BuyNode(2);
	BTNode* node3 = BuyNode(3);
	BTNode* node4 = BuyNode(4);
	BTNode* node5 = BuyNode(5);
	BTNode* node6 = BuyNode(6);

	node1->left = node2;
	node1->right = node4;
	node2->left = node3;
	node4->left = node5;
	node4->right = node6;

	PrevOrder(node1);
	printf("\n");

	InOrder(node1);
	printf("\n");

	PostOrder(node1);
	printf("\n");

	printf("%d\n", TreeSize(node1));

	//size = 0;
	printf("%d\n", TreeSize(node1));


	return 0;
}
#pragma once
#include<stdio.h>
#include<assert.h>
#include<stdlib.h>
#include<stdbool.h>
typedef int HPDataType;
typedef struct Heap
{
	HPDataType* a;
	HPDataType _size;
	HPDataType _capacity;
}HP;
void HeapInit(HP* php);
void HeapDestroy(HP* php);
void HeapPush(HP* php, HPDataType x);
void HeapPop(HP* php);
bool HeapEmpty(HP* php);
HPDataType HeapTop(HP* php);

#include"Heap.h"
void HeapInit(HP* php)
{
	assert(php);
	php->a = NULL;
	php->_size = 0;
	php->_capacity = 0;
}

void HeapDestroy(HP* php)
{
	assert(php);
	free(php->a);
	php->a = NULL;
	php->_size = 0;
	php->_capacity = 0;
}

void AdJustUP(HPDataType* a, int child)
{
	int parent = (child - 1) / 2;
	while (child > 0)
	{
		if (a[child] < a[parent]) {
			Swap(&a[child], &a[parent]);//C语言交换函数可自行尝试解决
			child = parent;
			parent = (parent - 1) / 2;
		}
		else {
			break;
		}
	}
}

void AdjustDown(HPDataType* a, int n, int parent)
{
	int child = parent * 2 + 1;
	while (child < n)
	{
		// 找出小的那个孩子
		if (child + 1 < n && a[child + 1] > a[child])
		{
			++child;
		}

		if (a[child] > a[parent])
		{
			Swap(&a[child], &a[parent]);
			// 继续往下调整
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}

void HeapPush(HP* php, HPDataType x)
{
	assert(php);
	if (php->_capacity == php->_size)
	{
		int NewCapacity = php->_capacity = 0 ? 4 : php->_capacity * 2;
		HPDataType* temp = (HPDataType*)realloc(php->a, sizeof(HPDataType) * NewCapacity);
		if (temp == NULL) {
			perror("realloc fail");
			exit(-1);
		}
		php->a = temp;
		php->_capacity = NewCapacity;
	}
	php->a[php->_size] = x;
	php->_size++;
	AdJustUP(php->a, php->_size - 1);
}

void HeapPop(HP* php)
{
	assert(php);
	assert(php->_size > 0);

	Swap(&php->a[0], &php->a[php->_size - 1]);
	--php->_size;

	AdjustDown(php->a, php->_size, 0);
}

HPDataType HeapTop(HP* php)
{
	assert(php);
	assert(php->_size > 0);

	return php->a[0];
}

bool HeapEmpty(HP* php)
{
	assert(php);

	return php->_size == 0;
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1091108.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

湖南省人才档案查询

湖南省人才档案查询

湖南省人才档案查询 微信中查询智慧人社公众号 进入智慧人社公众号&#xff0c;点击智慧人社按钮 点击人才档案查询 查看档案信息
阅读更多...
chapter8 Dimensionality Reduction（降维）

chapter8 Dimensionality Reduction（降维）

设置 首先&#xff0c;确保代码在python2和python3中都能正常工作&#xff0c;导入一些通用模块&#xff0c;确保MatplotLib以内联方式绘制图形&#xff0c;并准备一个函数来保存这些图形: from __future__ import division,print_function,unicode_literalsimport numpy as …
阅读更多...
负载均衡（LoadBanlance）

负载均衡（LoadBanlance）

阅读更多...
异星工场入门笔记-01

异星工场入门笔记-01

两年前玩过一点&#xff0c;不看教程&#xff0c;单纯地开放世界自己探索&#xff0c;没有同类游戏经验&#xff0c;因此很难有获得感所以放弃了。现在正版游戏涨到130&#xff0c;看在逆势上涨的份上&#xff0c;我倒想继续探索下这个游戏的价值。 玩魔方&#xff0c;记教程步…
阅读更多...
深度学习之使用CSDN的InsCode的服务器

深度学习之使用CSDN的InsCode的服务器

CSDN开启了一个InsCode的栏目&#xff0c;在里面可以部署自己的项目&#xff0c;同时可以租赁GPU服务器&#xff1a; 由于博主在CSDN有些积蓄&#xff0c;因此便来测评一下&#xff0c;博主购买了3090这个型号 接下来便是登录使用了&#xff0c;博主使用的是Mobaxterm这个软件&…
阅读更多...
彻底解决Qt中文乱码以及汉字编码的问题(UTF-8/GBK)

彻底解决Qt中文乱码以及汉字编码的问题(UTF-8/GBK)

彻底解决Qt中文乱码以及汉字编码的问题&#xff08;UTF-8/GBK&#xff09; Chapter1 (彻底解决Qt中文乱码以及汉字编码的问题&#xff08;UTF-8/GBK&#xff09;一、Qt Creator环境设置二、编码知识科普Qt常见的两种编码是:UTF-8和GBK 三、编码转换四、QString显示中文乱码的原…
阅读更多...
铜死亡+多组机器学习+WGCNA+分型

铜死亡+多组机器学习+WGCNA+分型

今天给同学们分享一篇铜死亡多组机器学习WGCNA分型的生信文章“Machine learning screening for Parkinsons disease-related cuproptosis-related typing development and validation and exploration of personalized drugs for cuproptosis genes”&#xff0c;这篇文章于20…
阅读更多...
3.3 封装性

3.3 封装性

思维导图&#xff1a; 3.3.1 为什么要封装 ### 3.3.1 为什么要封装 **封装**&#xff0c;在Java的面向对象编程中&#xff0c;是一个核心的思想。它主要是为了保护对象的状态不被外部随意修改&#xff0c;确保数据的完整性和安全性。 #### **核心思想&#xff1a;** - 保护…
阅读更多...
TSINGSEE青犀智能分析网关如何助力别墅区域监控智能化信息化发展？

TSINGSEE青犀智能分析网关如何助力别墅区域监控智能化信息化发展？

谈到别墅&#xff0c;大家一般都会想到花园、草坪、泳池等等&#xff0c;联想到的都是舒适放松的环境。别墅优美环境是不可否认的&#xff0c;但是别墅占地大、空间广、人员稀少也使得常常被盗贼“光顾”&#xff0c;即使别墅一般都会配备保安进行巡逻检查&#xff0c;但传统人…
阅读更多...
【python编程】python无法import模块的一种原因分析

【python编程】python无法import模块的一种原因分析

python系统路径添加错误 报错原因原因分析解决办法补充 最近写代码的时候遇到一个问题&#xff0c;就是想添加工程下fu_convert文件夹下自己编写的convert_fw.py模块&#xff0c;但是出现报错&#xff0c;是个比较低级的问题&#xff0c;但还是简单记录一下 报错原因 无法找到…
阅读更多...
PHP遇见错误了看不懂？这些错误提示你必须搞懂

PHP遇见错误了看不懂？这些错误提示你必须搞懂

&#x1f3ac; 鸽芷咕&#xff1a;个人主页 &#x1f525; 个人专栏:《速学数据结构》 《C语言进阶篇》 ⛺️生活的理想&#xff0c;就是为了理想的生活! 文章目录 一、错误分类二、系统错误&#xff1a;2.1 编译错误2.2 致命错误2.3 警告错误2.4 通知错误 三、用户错误3.1 错…
阅读更多...
GitLab使用步骤

GitLab使用步骤

GitLab使用步骤 1 注册用户 1 访问&#xff1a;http://10.0.0.203/users/sign_up地址 2 填入注册信息&#xff0c;注册成功&#xff0c;需要管理员审核 3 用root登录&#xff0c;地址&#xff1a;http://10.0.0.203/users/sign_in账号&#xff1a;root密码&#xff1a;xxxx…
阅读更多...
接口测试总结及其用例设计方法

接口测试总结及其用例设计方法

接口测试的总结文档 第一部分&#xff1a;主要从问题出发&#xff0c;引入接口测试的相关内容并与前端测试进行简单对比&#xff0c;总结两者之前的区别与联系。但该部分只交代了怎么做和如何做&#xff1f;并没有解释为什么要做&#xff1f; 第二部分&#xff1a;主要介绍为什…
阅读更多...
指针（2）

指针（2）

1.数组名的理解 一般数组名就是数组首元素的地址 但是有2个例外&#xff1a;1.sizeof&#xff08;数组名&#xff09; 这里面数组名表示的是整个数组&#xff0c;计算整个数组的大小&#xff0c;单位为字节。 …
阅读更多...
51 爬楼梯

51 爬楼梯

爬楼梯 题解1 dp省点空间——斐波那契数列 题解2 矩阵快速幂&#xff08;适合n小&#xff0c;重点学习方法&#xff09; 假设你正在爬楼梯。需要 n 阶你才能到达楼顶。 每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢&#xff1f; 示例 1&#xff1a; 输入…
阅读更多...
C++特性——命名空间、I/O流以及缺省参数

C++特性——命名空间、I/O流以及缺省参数

C特性 文章目录 C特性1. 写在前面2. 命名空间2.1 命名空间的嵌套2.2 命名空间的完全展开2.3 命名空间的指定展开 3. C的I/O流4. 缺省参数4.1 使用缺省参数的注意事项 1. 写在前面 可以认为&#xff0c;C的语法和语义基本上包含了C语言的所有内容。二者之间的关系大致可以用下图…
阅读更多...
十六、代码校验（4）

十六、代码校验（4）

本章概要 调试 使用 JDB 调试图形化调试器 调试 尽管聪明地使用 System.out 或日志信息能给我们带来对程序行为的有效见解&#xff0c;但对于困难问题来说&#xff0c;这种方式就显得笨拙且耗时了。 你也可能需要更加深入地理解程序&#xff0c;仅依靠打印日志做不到。此时…
阅读更多...
【牛客面试必刷TOP101】Day8.BM33 二叉树的镜像和BM36 判断是不是平衡二叉树

【牛客面试必刷TOP101】Day8.BM33 二叉树的镜像和BM36 判断是不是平衡二叉树

作者简介&#xff1a;大家好&#xff0c;我是未央&#xff1b; 博客首页&#xff1a;未央.303 系列专栏&#xff1a;牛客面试必刷TOP101 每日一句&#xff1a;人的一生&#xff0c;可以有所作为的时机只有一次&#xff0c;那就是现在&#xff01;&#xff01;&#xff01;&…
阅读更多...
2015架构案例（五十一）

2015架构案例（五十一）

第5题 【说明】某信息技术公司计划开发一套在线投票系统&#xff0c;用于为市场调研、信息调查和销售反馈等业务提供服务。该系统计划通过大量宣传和奖品鼓励的方式快速积累用户&#xff0c;当用户规模扩大到一定程度时&#xff0c;开始联系相关企业提供信息服务&#xff0c;并…
阅读更多...
关于RNNoise、webrtc_ns、三角带通滤波器、对数能量

关于RNNoise、webrtc_ns、三角带通滤波器、对数能量

语音特征参数MFCC提取过程详解 其中讲解了&#xff1a;三角带通滤波器 、计算每个滤波器组输出的对数能量、对数能量、经离散余弦变换&#xff08;DCT&#xff09;得到MFCC系数 推荐阅读某乎这位大佬的全部文章&#xff1a; 下面是几篇出自这位大佬的很好的文章&#xff1a; …
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023