【C++】priority_queue使用与模拟实现

news2024/12/23 14:04:25

认识priority_queue

1、priority_queue(优先级队列)是一种容器适配器，底层是一个完全二叉树的大堆（堆总是一颗完全二叉树，根结点最大的堆叫做大堆；根结点最小的堆叫做小堆），头文件在queue中，根据严格的弱排序标准，它的第一个元素总是它所包含的元素中最大的。不按照先进先出，优先级高的先出，默认数字大的优先级高。

2、类似于堆，在堆中可以随时插入元素，并且只能检索最大堆元素(优先队列中位于顶部的元素)。

3、优先队列被实现为容器适配器，容器适配器即将特定容器类封装作为其底层容器类，priority_queue提供一组特定的成员函数来访问其元素。元素从特定容器的尾部弹出，其称为优先队列的顶部。

4、底层容器可以是任何标准容器类模板，也可以是其他特定设计的容器类。容器应该可以通过随机访问迭代器访问，并支持以下操作：

  • empty()：检测容器是否为空
  • size()：返回容器中有效元素个数
  • front()：返回容器中第一个元素的引用
  • push_back()：在容器尾部插入元素
  • pop_back()：删除容器尾部元素

5、标准容器类vector和deque满足这些需求。默认情况下，如果没有为特定的priority_queue类实例化指定容器类，则使用vector。

6、需要支持随机访问迭代器，以便始终在内部保持堆结构。容器适配器通过在需要时自动调用算法函数make_heap、push_heap和pop_heap来自动完成此操作。

priority_queue的使用

优先级队列默认使用vector作为其底层存储数据的容器，在vector上又使用了堆算法将vector中元素构造成堆的结构，因priority_queue就是堆，所有需要用到堆的位置，都可以考虑使用priority_queue。注意：默认情况下priority_queue是大堆。

容器适配器都是不支持遍历的，不支持范围for。

函数声明接口说明
priority_queue()/priority_queue(first, last)构造一个空的优先级队列
empty( )检测优先级队列是否为空，是返回true，否则返回 false
top( )返回优先级队列中最大(最小元素)，即堆顶元素
push(val)在优先级队列中插入元素val
pop()删除优先级队列中最大(最小)元素，即堆顶元素

库中priority_queue的定义：

template <class T, class Container = vector<T>,  class Compare = less<typename Container::value_type> > class priority_queue;

默认使用vector作为底层容器。

使用：

#include <queue>
#include <iostream>
using namespace std;
int main()
{
	
	priority_queue<int> pq;
	//默认数字大的优先级高，即默认大堆
	//也可以通过指定模板参数从而让数字小的优先级高,即变成小堆
	//priority_queue<int, vector<int>, greater<int>> pq;
	for (int i = 0; i < 10; i++)
	{
		pq.push(i);
	}
	cout << pq.size() << endl;//输出队列中元素个数 10
	while (!pq.empty())//判断是否为空
	{
		cout << pq.top() << " ";//队头的元素
		pq.pop();//队头元素出队列
	}
	//输出9 8 7 6 5 4 3 2 1 0
	//如果用小堆实现输出0 1 2 3 4 5 6 7 8 9
	return 0;
}

如果想要使优先级队列中小的优先级更高，则可以借助仿函数**greater<int>**，包含在头文件functional中。

priority_queue<int, vector<int>, greater<int>> pq;

仿函数

仿函数都需要重载一个()。仿函数就是重载了一个()，让对象可以像函数一样去使用。

我们来定义一个仿函数：

template<class T>
struct Less {
	bool operator()(const T& l1, const T& l2)
	{
		return l1 < l2;
	}
};

在Less类中我们重载了()，使其成为了能够比较大小的一个运算符：

#include <iostream>
using namespace std;
template<class T>
struct Less {
	bool operator()(const T& l1, const T& l2)
	{
		return l1 < l2;
	}
};
int main()
{
	Less<int> LessFunc;
	cout << LessFunc(2, 3) << endl;//输出1
	return 0;
}

如果只看cout << LessFunc(2, 3) << endl，我们可能会认为LessFunc是一个函数或者函数指针，但是LessFunc是个Less<int>类型的对象，所以我们叫做仿函数。对象可以像函数一样去使用，本质是调用了operator()，运算符重载。

仿函数是为了解决函数指针void(*ptr)()太复杂的问题。

greater<int>和less<int>都是库里面写好的，priority_queue默认使用的是less<int>。

堆算法

**堆的底层是一个数组，**我们先认识两种堆的算法：向上调整法和向下调整法。

向上调整法

向上调整法基本思想（以大堆为例）：

将插入结点作为目标结点，将目标结点和其父结点比较，如果目标结点的值比父结点的值大，则交换目标结点和父结点的位置，交换之后目标结点就变为父结点，然后继续向上调整；如果目标结点的值比父结点的值小，停止调整说明此时该完全二叉树已经是大堆了。

例：我们在下面的大堆最后位置插入数据100，通过向上调整法调整之后使其仍然是一个大堆：

image-20230705164654763

此时目标结点就是刚插入的结点，值为100，比父结点值大，所以要将目标结点和父结点交换位置：

image-20230705164828199

继续比较并调整，此时目标结点值为100，比父结点值大，交换两者位置：

image-20230705164919608

此时调整完成，该树已经调整成大堆了。

向上调整代码如下：

//大堆的向上调整法
void adjust_up(vector<int>& v, int child)
{
	//找出父结点
	int parent = (child - 1) / 2;

	//当child大于0时一直循环，当child = 0时说明已经调整完
	while (child > 0)
	{
		if (v[parent] < v[child])//当parent值小于child值时调整
		{
			swap(v[parent], v[child]);//交换父结点和子结点位置
			child = parent;//此时child等于parent
			parent = (child - 1) / 2;//重新求父结点
		}
		//此时说明已经是大堆了，不需要调整了
		else
		{
			break;
		}
	}
}

向下调整法

使用堆的向下调整算法有一个前提条件：待向下调整的结点的左子树和右子树都必须为大堆。

向下调整法基本思想（以大堆为例）：

将目标结点与自己较大的子结点进行比较，如果目标结点的值比它较大的子结点的值小，则交换目标结点与其较大的子结点的位置，并将较大子结点当作新的目标结点继续向下调整；如果目标结点的值比它较大子结点的值大，则停止向下调整，说明该树已经是大堆。

例：使用向下调整法将下面的完全二叉树调整成大堆（根结点的左右子树已经是大堆）。

image-20230705171138567

通过上图我们可以看出其根结点小于右孩子，所以将根结点和右孩子交换：

image-20230705171354442

经过上次交换之后，值为60的结点还是小于自己的右孩子，再交换：

image-20230705171502735

此时已经调整为大堆。

向下调整法的代码：

//大堆的向下调整
void adjust_down(vector<int>& v,int n,int parent)
{
	int child = (parent * 2) + 1;//求出左孩子
	while (child < n)
	{
		//找到最大孩子结点且保证child合法
		if (child + 1 < n && v[child + 1] > v[child])
		{
			child++;
		}
		if (v[child] > v[parent])//判断孩子结点是否大于父结点
		{
			swap(v[child], v[parent]);//交换结点位置
			parent = child;//重新赋值
			child = (parent * 2) + 1;//重新求出孩子结点
		}
		//已经是大堆
		else
		{
			break;
		}
	}
}

模拟实现priority_queue

优先级队列默认给的容器vector，大堆，数字大的优先级高。

优先级队列底层实际上就是堆结构，通过堆算法实现优先级，堆的底层是一个数组。

我们知道了堆算法的实现，那么priority_queue的模拟实现就变得简单了，其他的操作直接复用容器的函数就可以实现，模拟实现代码如下：

namespace Niu {
	template<class T,class Container = vector<T>>
	class priority_queue {
	public:
		//大堆的向上调整法
		void adjust_up(int child)
		{
			//找出父结点
			int parent = (child - 1) / 2;

			//当child大于0时一直循环，当child = 0时说明已经调整完
			while (child > 0)
			{
				if (_con[parent] < _con[child])//当parent值小于child值时调整
				{
					swap(_con[parent], _con[child]);//交换父结点和子结点位置
					child = parent;//此时child等于parent
					parent = (child - 1) / 2;//重新求父结点
				}
				//此时说明已经是大堆了，不需要调整了
				else
				{
					break;
				}
			}
		}
		//大堆的向下调整
		void adjust_down(int parent)
		{
			int child = (parent * 2) + 1;//求出左孩子
			while (child < _con.size())
			{
				//找到最大孩子结点且保证child合法
				if (child + 1 < _con.size() && _con[child + 1] > _con[child])
				{
					child++;
				}
				if (_con[parent] < _con[child])//判断孩子结点是否大于父结点
				{
					swap(_con[child], _con[parent]);//交换结点位置
					parent = child;//重新赋值
					child = (parent * 2) + 1;//重新求出孩子结点
				}
				//已经是大堆
				else
				{
					break;
				}
			}
		}
		//插入元素
		void push(const T& val)
		{
			_con.push_back(val);//尾插
			adjust_up(_con.size() - 1);//向上调整
		}
		//删除元素
		void pop()
		{
			swap(_con[0],_con[_con.size() - 1]);//交换第一个和最后一个结点位置
			_con.pop_back();//尾删，删除优先级最高的结点
			adjust_down(0);//向下调整
		}
		//返回优先级最高的元素
		const T& top()
		{
			return _con[0];
		}
		//返回数据个数
		size_t size()
		{
			return _con.size();
		}
		//判断是否为空
		bool empty()
		{
			return _con.empty();
		}
	private:
		Container _con;
	};
}

测试：

#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
#include "priority_queue.h"
int main()
{
	
	Niu::priority_queue<int> pq;
	//默认数字大的优先级高，即默认大堆
	for (int i = 0; i < 10; i++)
	{
		pq.push(i);
	}
	cout << pq.size() << endl;//输出队列中元素个数 10
	while (!pq.empty())//判断是否为空
	{
		cout << pq.top() << " ";//队头的元素
		pq.pop();//队头元素出队列
	}
	//输出9 8 7 6 5 4 3 2 1 0
	//如果用小堆实现输出0 1 2 3 4 5 6 7 8 9
	return 0;
}

数值大的优先级高，priority_queue是一个适配器，当我们将底层模板参数更改为deque<T>仍然能运行。

template<class T,class Container = deque<T>>

那此时默认的是数值大的优先级高，如果想让数值小的优先级高可以通过仿函数实现。

注意仿函数定义时>是小堆，<是大堆，定义仿函数的时候运算符要和类名保持一致。

在下面的代码中定义了两个仿函数，同时将向上调整法和向下调整法中的大小比较通过仿函数实现（还可以传一个匿名对象调用仿函数）：

namespace Niu {
    //定义大堆
	template<class T>
	struct less {
		bool operator()(const T& a, const T& b)
		{
			return a < b;
		}
	};
    //定义小堆
	template<class T>
	struct greater {
		bool operator()(const T& a, const T& b)
		{
			return a > b;
		}
	};
	template<class T,class Container = vector<T>,class Compare = less<T>>
	class priority_queue {
	public:
		//大堆的向上调整法
		void adjust_up(int child)
		{
			Compare com; //此时我们可以使用重载的运算符
			//找出父结点
			int parent = (child - 1) / 2;

			//当child大于0时一直循环，当child = 0时说明已经调整完
			while (child > 0)
			{
				//if (_con[parent] < _con[child])//当parent值小于child值时调整
				if(com(_con[parent],_con[child]))
				{
					swap(_con[parent], _con[child]);//交换父结点和子结点位置
					child = parent;//此时child等于parent
					parent = (child - 1) / 2;//重新求父结点
				}
				//此时说明已经是大堆了，不需要调整了
				else
				{
					break;
				}
			}
		}
		//大堆的向下调整
		void adjust_down(int parent)
		{
			Compare com; //此时我们可以使用重载的运算符
			int child = (parent * 2) + 1;//求出左孩子
			while (child < _con.size())
			{
				//找到最大孩子结点且保证child合法
				//if (child + 1 < _con.size() && _con[child + 1] > _con[child])
				if (child + 1 < _con.size() && com(_con[child], _con[child + 1]))
				{
					child++;
				}
                //if ( _con[parent] < _con[child])
				if (com(_con[parent], _con[child]))//判断孩子结点是否大于父结点
				//还可以传一个匿名对象调用if (com()(_con[parent] , _con[child]))
				{
					swap(_con[child], _con[parent]);//交换结点位置
					parent = child;//重新赋值
					child = (parent * 2) + 1;//重新求出孩子结点
				}
				//已经是大堆
				else
				{
					break;
				}
			}
		}
	private:
		Container _con;
	};
}

测试：

int main()
{	
	//通过指定模板参数从而让数字小的优先级高,即变成小堆
	Niu::priority_queue<int, vector<int>, greater<int>> pq;
	for (int i = 0; i < 10; i++)
	{
		pq.push(i);
	}
	cout << pq.size() << endl;//输出队列中元素个数 10
	while (!pq.empty())//判断是否为空
	{
		cout << pq.top() << " ";//队头的元素
		pq.pop();//队头元素出队列
	}
	//输出0 1 2 3 4 5 6 7 8 9
	return 0;
}

不是内置类型也可以用模板参数比较大小，但是我们要重载>和<运算符，方便在调用仿函数时调用，如下面的日期类代码：

class Date
{
    public:
    Date(int year = 1900, int month = 1, int day = 1)
        : _year(year)
            , _month(month)
            , _day(day)
        {}
    bool operator<(const Date& d)const
    {
        return (_year < d._year) ||
            (_year == d._year && _month < d._month) ||
            (_year == d._year && _month == d._month && _day < d._day);
    }
    bool operator>(const Date& d)const
    {
        return (_year > d._year) ||
            (_year == d._year && _month > d._month) ||
            (_year == d._year && _month == d._month && _day > d._day);
    }
    friend ostream& operator<<(ostream& _cout, const Date& d)
    {
        _cout << d._year << "-" << d._month << "-" << d._day;
        return _cout;
    }
    private:
    int _year;
    int _month;
    int _day;
};
void test_priority_queue2()
{
    // 大堆，需要用户在自定义类型中提供<的重载
    priority_queue<Date> q1;
    q1.push(Date(2018, 10, 29));
    q1.push(Date(2018, 10, 28));
    q1.push(Date(2018, 10, 30));
    cout << q1.top() << endl;
}

我们实现了>和<运算符重载，这样在自定义类型的优先级队列中，当我们push时，在push函数中调用adjust_up函数，而在adjust_up函数中有仿函数的使用，仿函数中有类型比较，整个过程如下图：

image-20230705204240242

那此时如果我们想比较两个Date*类型所指向的日期大小我们应该怎么办呢？

Date*可以比较大小，但是不是我们想要的，new出来的地址没有先大先小的概念，完全没有规律。所以我们也可以通过仿函数来比较。

实现两个日期类指针的仿函数（注意要在日期类下面定义）：

class PDateLess{
public:
    bool operator()(const Date* p1, const Date* p2)
    {
        return *p1 < *p2;
    }
};
class PDateGreater{
public:
    bool operator()(const Date* p1, const Date* p2)
    {
        return *p1 > *p2;
    }
};

测试：

void test_priority_queue2()
{
    // 大堆，需要用户在自定义类型中提供<的重载
    priority_queue<Date> q1;
    q1.push(Date(2018, 10, 29));
    q1.push(Date(2018, 10, 28));
    q1.push(Date(2018, 10, 30));
    cout << q1.top() << endl;
    //输出2018-10-30

    //priority_queue<Date*,vector<Date*>,PDateLess> q2;//大堆
    priority_queue<Date*, vector<Date*>, PDateGreater> q2;//小堆
    q2.push(new Date(2018, 10, 29));
    q2.push(new Date(2018, 10, 28));
    q2.push(new Date(2018, 10, 30));
    cout << *(q2.top()) << endl;//返回值为日期指针类型，所以要解引用
    //输出2018-10-28
}

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

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

相关文章

simple RNN pytorch代码实现

simple RNN pytorch代码实现

simple RNN pytorch代码实现 在写这篇博客之前&#xff0c;博主要说一件事情&#xff0c;网上的simple RNN代码很多都是错误的&#xff0c;博主的也是错误的&#xff0c;为什么呢&#xff1f; 因为simple RNN的梯度下降代码必须自己去写&#xff0c;simple RNN的梯度下降不能使…
阅读更多...
巧用浮动布局、解决高度塌陷实例分享

巧用浮动布局、解决高度塌陷实例分享

问题 如图所示&#xff0c;这种效果该怎么实现呢&#xff1f; 面包屑导航和按钮一行两端显示面包屑或编辑栏超出宽度则自动另行显示 实现 采用浮动&#xff0c;绿色块左浮&#xff0c;蓝色块右浮&#xff0c;利用浮动特性实现宽度超出另一行显示的效果&#xff0c;并是动态的…
阅读更多...
ModaHub魔搭社区：什么是非结构化数据？

ModaHub魔搭社区：什么是非结构化数据？

目录 概览 区分结构化、半结构化和非结构化数据 结构化数据示例 欢迎来到向量数据库 101 系列教程。 概览 这是向量数据库 101 系列教程第一课，主要向大家介绍一下非结构化数据。 现在我们每天都会产生新的数据，这无疑是全球一体化和全球经济的关键动力。从腕部佩戴的…
阅读更多...
【NLP】国外新动态--LLM模型

【NLP】国外新动态--LLM模型

一、说明 NLP走势如何&#xff1f;这是关于在实践中使用大型语言模型&#xff08;LLM&#xff09;的系列文章中的一篇文章。在这里&#xff0c;我将介绍LLM&#xff0c;并介绍使用它们的3个级别。未来的文章将探讨LLM的实际方面&#xff0c;例如如何使用OpenAI的公共API&#x…
阅读更多...
面试题更新之-css中link和@import的区别

面试题更新之-css中link和@import的区别

文章目录 导文link是什么&#xff1f;import是什么&#xff1f;css中link和import的区别 导文 面试题更新之-css中link和import的区别 link是什么&#xff1f; CSS Link是用于将外部CSS文件链接到HTML文档中的HTML标签。通过使用CSS Link标签&#xff0c;可以将外部的CSS样式表…
阅读更多...
游戏测试与策划的那些事儿

游戏测试与策划的那些事儿

作为一个游戏测试员&#xff0c;和程序、前端、策划之间的沟通交流在所难免。今天就来吐槽一下子啦~ 作为游戏测试的核心机密&#xff0c;可不能被他们知道我们在背后吐槽啦~ 游戏测试&#xff1a;XXX&#xff0c;刚测完这数据怎么和之前的不一样了&#xff1f; 策划&#xff1…
阅读更多...
Python分布式任务队列Celery

Python分布式任务队列Celery

一、分布式任务队列Celery介绍 Python celery是一个基于Python的分布式任务队列&#xff0c;主要用于任务的异步执行、定时调度和分布式处理。它采用了生产者/消费者模式&#xff0c;通过消息中间件实现多个工作者进程之间的协作。 Python celery的架构主要包括以下组件&…
阅读更多...
new和不用new调用构造函数，有什么区别?

new和不用new调用构造函数，有什么区别?

new和不用new的构造函数&#xff0c;有什么区别&#xff1f; 下面从有return和无return,如果在有return的情况下&#xff0c;return原始类型数据和return引用应用类型数据等几方面进行论述&#x1f44d;&#x1f44d;&#x1f44d; 区别1&#xff1a;当没有return时 functio…
阅读更多...
Bus消息总线(在Spring Cloud整合Bus(idea19版本)

Bus消息总线(在Spring Cloud整合Bus(idea19版本)

Bus消息总线 所谓消息总线Bus&#xff0c;即我们经常会使用MQ消息代理构建一个共用的Topic&#xff0c;通过这个Topic连接各个微服务实例,MQ广播的消息会被所有在注册中心的微服务实例监听和消费。换言之就是通过一个主题连接各个微服务&#xff0c;打通脉络 Spring Cloud Bus …
阅读更多...
FastDDS 源码剖析：DataWriter分析

FastDDS 源码剖析：DataWriter分析

目录 DataWriter分析 DataWriter 类分析 DataWriterImpl 类分析 关键函数分析 DataWriter分析 DataWriter 类分析 DataWriter 类是 Fast DDS 库中的一个重要类&#xff0c;它用于实现 DDS&#xff08;Data Distribution Service&#xff09;发布-订阅通信模型中的数据写入…
阅读更多...
Git #01 操作记录

Git #01 操作记录

本篇内容 0. 前期配置1. 仓库1.1 上传本地代码到远程仓库 0. 前期配置 请提前配置好 git 的全局用户名&#xff1a; # xin&#xff1a;账号名 $ git config --global user.name "xin" # xin163.com&#xff1a;账号绑定的邮箱地址 $ git config --global user.emai…
阅读更多...
单片机能否替代PLC实现控制和自动化系统？

单片机能否替代PLC实现控制和自动化系统？

是的&#xff0c;单片机可以在某些情况下替代PLC&#xff0c;但在其他情况下可能并不适用。以下是对这个问题的详细解释&#xff1a; 我这里刚好有嵌入式、单片机、plc的资料需要可以私我或在评论区扣个6 灵活性和可编程性&#xff1a;PLC相对于单片机来说更具有灵活性和可编…
阅读更多...
DolphinScheduler minio(S3支持)开启资源中心

DolphinScheduler minio(S3支持)开启资源中心

DolphinScheduler 如果是在3.0.5 及之前的版本&#xff0c;没办法支持 S3 的协议的 当你按照文档配置之后&#xff0c;运行启动之后&#xff0c;在master 和 worker 节点&#xff0c;都会出现 缺包的依赖问题。 那这个问题在什么版本修复了呢&#xff1f; 3.0.6... 那 3.0.6 …
阅读更多...
每个前端开发者都应知道的10个实用网站

每个前端开发者都应知道的10个实用网站

微信搜索 【大迁世界】, 我会第一时间和你分享前端行业趋势&#xff0c;学习途径等等。 本文 GitHub https://github.com/qq449245884/xiaozhi 已收录&#xff0c;有一线大厂面试完整考点、资料以及我的系列文章。 快来免费体验ChatGpt plus版本的&#xff0c;我们出的钱 体验地…
阅读更多...
sprinboot企业客户信息反馈平台

sprinboot企业客户信息反馈平台

企业客户信息反馈平台的开发运用java技术&#xff0c;MIS的总体思想&#xff0c;以及MYSQL等技术的支持下共同完成了该平台的开发&#xff0c;实现了企业客户信息反馈管理的信息化&#xff0c;使用户体验到更优秀的企业客户信息反馈管理&#xff0c;管理员管理操作将更加方便&a…
阅读更多...
canal番外篇-otter

canal番外篇-otter

前置知识点 主从复制binlogcanal正则dockerjava 前置工具 dockerotter-all 场景描述&#xff08;增量同步&#xff09; 目前项目中使用的是mysql5.5&#xff0c;计划升级为mysql8.1&#xff0c;版本跨度较大&#xff0c;市面上可靠工具选择较少。otter符合预期&#xff0c…
阅读更多...
3Ds max入门教程：为男性角色创建服装T 恤

3Ds max入门教程：为男性角色创建服装T 恤

推荐&#xff1a; NSDT场景编辑器助你快速搭建可二次开发的3D应用场景 3ds Max 角色服装教程 在本 3ds Max 教程中&#xff0c;我们将为角色模型创建一个简单的 T 恤。我们提供了一个“human_figure.obj”文件供您导入模型。因此&#xff0c;本教程将重点介绍的是创建服装&…
阅读更多...
【VTK】VTK 显示小球例子，在 Windows 上使用 Visual Studio 配合 Qt 构建 VTK

【VTK】VTK 显示小球例子，在 Windows 上使用 Visual Studio 配合 Qt 构建 VTK

知识不是单独的&#xff0c;一定是成体系的。更多我的个人总结和相关经验可查阅这个专栏&#xff1a;Visual Studio。 关于更多此例子的资料&#xff0c;可以参考&#xff1a;【Visual Studio】在 Windows 上使用 Visual Studio 配合 Qt 构建 VTK。 文章目录 版本环境VTKTest.…
阅读更多...
【机器人模拟-01】使用URDF在中创建模拟移动机器人

【机器人模拟-01】使用URDF在中创建模拟移动机器人

一、说明 在本教程中，我将向您展示如何使用通用机器人描述格式 （URDF）（机器人建模的标准 ROS 格式）创建模拟移动机器人。 机器人专家喜欢在构建机器人之前对其进行模拟，以测试不同的算法。您可以想象，使用物理机器人犯错的成本可能很高（例如，将移动机器人高速…
阅读更多...
SPSS方差分析

SPSS方差分析

参考文章 导入准备好的数据 选择分析方法 选择参数 选择对比&#xff0c;把组别放入因子框中&#xff0c;把红细胞增加数放进因变量列表 勾选“多项式”&#xff0c;等级取默认“线性” &#xff0c;继续 接着点击“事后比较”&#xff0c;弹出对话框&#xff0c;勾选“LSD” …
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023