数据结构 最短路径课设（源码+实验报告+视频讲解）（用了自取）

news2024/9/21 4:34:17

XI`AN TECHNOLOGICAL UNIVERSITY

课程设计报告

实验课程名称   算法与数据结构   

专    业：         

班    级：              

姓    名：               

学    号：         

实验学时：                        

指导教师：                     

成    绩：                        

        

    2023    年  1  月 7  日

目录

一、实验报告

        一、绪论

        二、基本要求

        三、信息描述

        五、详细设计

        六、调试与测试：

        八、总结

 源码：

视频上传比较麻烦，需要的同学可以联系我

一、实验报告

一、绪论

迪杰特斯拉算法思想：

设G=（V,E）是一个带权有向图，把顶点集合V分成两组，求出最短路径的顶点集合（用S表示，初始时S中只有一个源点，以后每求得一条最短路径，就将加入到集合S中。直到全部顶点都加入到S中，算法就结束了）。第二组为其余未确定最短路径的顶点集合（用U表示），按最短路径长度的递增次序依次把第二组的顶点加入S中。在加入的过程中，总保持从源点V到S中各顶点的最短路径长度大于从源点V到V中任何顶点的最短路径长度。此外，每个顶点对应一个距离，S中的顶点的距离就是从V到此顶点的最短路径长度，V中的顶点的距离是从V到此顶点只包括S中的顶点为中间顶点的当前最短路径长度。

二、基本要求

(1)设计最短路径，包含以下方面：

1、用邻接矩阵存储一张带权有向图。

2、对图进行从某一源点到其他各顶点的最短路径

3、输出最后结果（路径名称、路径长度）。

三、信息描述

邻接矩阵建立包括：用二维数组存储信息。没有直达路径的为无穷。

用循环来判断最小值。

最终结果用一维数组存储。D[]存放源点到其他顶点的最短路径的长度，P[]存放该顶点最短路径的前驱顶点下标，visit[]为访问标识。初始全部值设为F，先把源点的标识设为T，后面每找到一个源点到其余顶点的最短路径，就将该顶点下标对应的标识置为T。直到全部顶点执行完毕。

输出一维数组D[]和P[]，显示最终结果。

  • 总体设计

五、详细设计

  • 第一部分，进行对邻接矩阵的初始化，首先自己到自己的距离肯定为0，然后到其余结点初始化为MAX，然后通过一个for循环，对边进行数据存入，打印函数用来验证。

  • 第二部分对于结点类的创建（构造、拷贝构造、赋值运算符重载、比较方式的重载）类中存放每一个结点的下标、最短路径长度、前驱结点。

  •  第三部分：打印结果函数

  •  迪杰斯特拉算法部分（核心）

完成好邻接矩阵的初始化工作以后，输入我们的起点坐标，对于起点来说，从起点到达起点的距离肯定是0，然后将起点坐标置入优先队列中，进入循环，循环退出条件是优先队列为空

每次取堆顶元素，使用cur进行保存，之后就将此结点pop

利用cur找出所有可以从cur出发到达的所有结点，将这些结点保存到集合S中，对于集合中的所有结点进行：

newlength = node[Index]._length + Graph[Index][back];

// 如果新距离小于cur之前的最小距离，就将cur重新赋值，并入队列

   if (newlength < node[back]._length)

   {

    node[back]._length = newlength;

    node[back]._prev = Index;

    q.push(node[back]);

   }

六、调试与测试：

在我写代码的时候大部分问题都可以查资料解决，如何使用vector,如果使用优先级队列，以及思路的来源也是借助于网上的资料查看，视频讲解，耗费时间最多的应该就是对于自定义类型优先级队列第三个参数比较方式的确定，本来我的代码是这样通过结构体与函数指针来实现，不过也出现了类型不匹配的问题，最后通过使用类中对比较关系的重载写出了bool类型关于>符号的重载（因为要建大堆）。

七、程序清单和执行结果：清单中应有足够的注释

运行结果：

源码：

//(1)设计最短路径，包含以下方面:

//1、用邻接矩阵存储一张带权有向图。

//2、对图进行从某一源点到其他各顶点的最短路径

//了、输出最后结果(路径名称、路径长度)。

//三、信息描述

//邻接矩阵建立包括 : 用二维数组存储信息。没有直达路径的为无

//穷

//用循环来判断最小值

//最终结果用一维数组存储。D[]存放源点到其他顶点的最短路径的

//长度，P[]存放该顶点最短路径的前驱顶点下标

// 0 1 2   0 4 10  1 2 3  1 4 7  2 0 4  2 3 4  3 4 5  4 2 3

#include<functional>

#include<stdlib.h>

#include<iostream>

using namespace std;

#include<vector>

#include<queue>

#define MAX 1000 // 不可到达

int V, E, S; // 顶点数、边数、起点

vector<vector<int>> Graph;

void CreatMyGraph() // 初始化邻接矩阵

{

    cout << "请输入顶点数、边数" << endl;

    cin >> V >> E;

    Graph.resize(V);

    for (int i = 0; i < V; i++)

    {

        Graph[i].resize(V);

        for (int j = 0; j < V; j++)

        {

            if (i == j)

                Graph[i][j] = 0; // 自己到自己赋值为0

            else

                Graph[i][j] = MAX;   // 默认初始化到其余顶点均为MAX

        }

    }

    /*Graph[0][1] = 2;

    Graph[0][3] = 1;

    Graph[1][3] = 3;

    Graph[1][4] = 7;

    Graph[2][0] = 4;

    Graph[3][2] = 2;

    Graph[3][4] = 2;

    Graph[3][5] = 8;

    Graph[3][6] = 4;

    Graph[4][6] = 1;

    Graph[6][5] = 1;

    Graph[2][5] = 5;*/

    int begin, end;

    int length;

    for (int i = 0; i < E; i++)

    {

        cout << "请输入第" << i + 1 << "条边的起点、终点、权值：" << endl;

        cin >> begin >> end >> length;

        Graph[begin][end] = length;   // 初始化邻接矩阵

    }

}

void PrintMyGraph()

{

    cout << "图的邻接矩阵存储为：" << endl;

    for (int i = 0; i < V; i++)

    {

        for (int j = 0; j < V; j++)

        {

            cout << Graph[i][j] << " ";

        }

        cout << endl;

    }

}

//typedef struct DjNode

//{

//  int _index;

//  int _length;

//  int _prev;

//}Node;

//Node BuyNode(int index, int length)

//{

//  Node* newnode = (Node*)malloc(sizeof(Node));

//  newnode->_index = index;

//  newnode->_length = length;

//  newnode->_prev = 0;

//  return newnode;

//}

//typedef bool (*PCOM)(const Node& left, const Node& right);

//bool Compare(const Node left, const Node right)

//{

//  return left._length > right._length;

//}

class Node

{

public:

    Node(int index, int length, int prev)

        : _index(index)

        , _length(length)

        , _prev(prev)

    {}

    Node(const Node& d)

    {

        _index = d._index;

        _length = d._length;

        _prev = d._prev;

    }

    Node& operator=(const Node& node)

    {

        if (this != &node)

        {

            _index = node._index;

            _length = node._length;

            _prev = node._prev;

        }

        return *this;

    }

    bool operator>(const Node& d)const

    {

        return _length > d._length;

    }

    bool operator<(const Node& d)const

    {

        return _length < d._length;

    }

    int _index;

    int _length;

    int _prev;

};

class Com

{

public:

    bool operator()(const Node&left, const Node&right)const

    {

        return left._length > right._length;

    }

};

void Print_output(int start, vector<Node> node)

{

    cout << "由" << start << "到其余各顶点距离分别为" << endl;

    for (int i = 0; i < V; i++)

    {

        if (i == start)

            continue;

        else

            cout << start << "->" << i << ": " << node[i]._length << endl;

    }

}

void Dijkstra_Algorithm()

{

    // 1、初始化输出数组D、P

    //vector<int> D(V, MAX);  // 初始化最短长度数组D

    //vector<int> P(V, 0); // 初始化前驱结点数组P

    vector<Node> node(V, Node(0,0,0));

    for (int i = 0; i < V; i++)

    {

        //node[i] = BuyNode(i, MAX); // 结点初始化

        node[i]._index = i;

        node[i]._length = MAX;

        node[i]._prev = 0;

    }

    // 2、初始化顶点D[S]

    cout << "请输入起点" << endl;

    cin >> S;

    node[S]._length = 0;

    // 3、创建优先队列，起点元素入队列

    priority_queue<Node, vector<Node>, greater<Node>> q;

    q.push(node[S]);

    while (!q.empty())

    {

        Node cur = q.top();

        q.pop(); // 取出堆顶元素并进行保存

        vector<int> pre_next;

        int Index = cur._index;

        for (int i = 0; i < V; i++) // 将所有可以一步到达当前结点的元素下标全部保存到pre_next中

        {

            if (Graph[Index][i] > 0 && Graph[Index][i] != MAX)

                pre_next.push_back(i);

        }

        while (!pre_next.empty()) // 对于每一个可以到达cur的结点

        {

            int back = pre_next.back();   //访问一个取出一个

            pre_next.pop_back();

            // 新距离就为 从源点到back距离  加上  back到cur的距离

            int newlength = node[Index]._length + Graph[Index][back];

            // 如果新距离小于cur之前的最小距离，就将cur重新赋值，并入队列

            if (newlength < node[back]._length)

            {

                node[back]._length = newlength;

                node[back]._prev = Index;

                q.push(node[back]);

            }

        }

    }

    cout << endl;

    Print_output(S, node);

}

void _Dijkstra_Algorithm()

{

    cout << "Dijkstra_Algorithm :" << endl;

    int choice;

    while (1)

    {

        cout << "请输入：" << "[1]开始" << "[0]结束" << endl;

        cin >> choice;

        switch (choice)

        {

        case 1:

            Dijkstra_Algorithm();

            break;

        case 0:

            exit(0);

            break;

        }

    }

}

int main()

{

    int choice;

    while (1)

    {

        cout << "*******************************************" << endl;

        cout << "***************请输入请求：****************" << endl;

        cout << "***************[1]初始化数据***************" << endl;

        cout << "***************[2]迪杰斯特拉算法***********" << endl;

        cout << "***************[0]退出*********************" << endl;

        cout << "*******************************************" << endl;

        cin >> choice;

        switch (choice)

        {

        case 1:

            CreatMyGraph();

            break;

        case 2:

            _Dijkstra_Algorithm();

            break;

        case 0:

            exit(0);

            break;

        default:

            cout << "输入错误,请重新输入" << endl;

            break;

        }

    }

    return 0;

}

八、总结

通过这次课设，进一步提高了对于数据结构的认知，提升了自己的编程能力，了解了迪杰斯特拉算法在使用优先级队列来解决问题的便利之处。

 源码：

//(1)设计最短路径，包含以下方面:
//1、用邻接矩阵存储一张带权有向图。
//2、对图进行从某一源点到其他各顶点的最短路径
//了、输出最后结果(路径名称、路径长度)。
//三、信息描述
//邻接矩阵建立包括 : 用二维数组存储信息。没有直达路径的为无
//穷
//用循环来判断最小值
//最终结果用一维数组存储。D[]存放源点到其他顶点的最短路径的
//长度，P[]存放该顶点最短路径的前驱顶点下标
// 0 1 2   0 4 10  1 2 3  1 4 7  2 0 4  2 3 4  3 4 5  4 2 3
#include<functional>
#include<stdlib.h>
#include<iostream>
using namespace std;
#include<vector>
#include<queue>
#define MAX 1000 // 不可到达
int V, E, S; // 顶点数、边数、起点

vector<vector<int>> Graph;

void CreatMyGraph() // 初始化邻接矩阵
{
	cout << "请输入顶点数、边数" << endl;
	cin >> V >> E;
	Graph.resize(V);
	for (int i = 0; i < V; i++)
	{
		Graph[i].resize(V);
		for (int j = 0; j < V; j++)
		{
			if (i == j)
				Graph[i][j] = 0;	// 自己到自己赋值为0
			else
				Graph[i][j] = MAX;	// 默认初始化到其余顶点均为MAX
		}
	}
	/*Graph[0][1] = 2;
	Graph[0][3] = 1;
	Graph[1][3] = 3;
	Graph[1][4] = 7;
	Graph[2][0] = 4;
	Graph[3][2] = 2;
	Graph[3][4] = 2;
	Graph[3][5] = 8;
	Graph[3][6] = 4;
	Graph[4][6] = 1;
	Graph[6][5] = 1;
	Graph[2][5] = 5;*/
	int begin, end;
	int	length;
	for (int i = 0; i < E; i++)
	{
		cout << "请输入第" << i + 1 << "条边的起点、终点、权值：" << endl;
		cin >> begin >> end >> length;
		Graph[begin][end] = length;	// 初始化邻接矩阵
	}
}

void PrintMyGraph()
{
	cout << "图的邻接矩阵存储为：" << endl;
	for (int i = 0; i < V; i++)
	{
		for (int j = 0; j < V; j++)
		{
			cout << Graph[i][j] << " ";
		}
		cout << endl;
	}
}

//typedef struct DjNode
//{
//	int _index;
//	int _length;
//	int _prev;
//}Node;

//Node BuyNode(int index, int length)
//{
//	Node* newnode = (Node*)malloc(sizeof(Node));
//	newnode->_index = index;
//	newnode->_length = length;
//	newnode->_prev = 0;
//	return newnode;
//}

//typedef bool (*PCOM)(const Node& left, const Node& right);
//bool Compare(const Node left, const Node right)
//{
//	return left._length > right._length;
//}

class Node
{
public:
	Node(int index, int length, int prev)
		: _index(index)
		, _length(length)
		, _prev(prev)
	{}
	Node(const Node& d)
	{
		_index = d._index;
		_length = d._length;
		_prev = d._prev;
	}
	Node& operator=(const Node& node)
	{
		if (this != &node)
		{
			_index = node._index;
			_length = node._length;
			_prev = node._prev;
		}
		return *this;
	}
	bool operator>(const Node& d)const
	{
		return _length > d._length;
	}
	bool operator<(const Node& d)const
	{
		return _length < d._length;
	}
	int _index;
	int _length;
	int _prev;
};

class Com
{
public:
	bool operator()(const Node&left, const Node&right)const
	{
		return left._length > right._length;
	}
};

void Print_output(int start, vector<Node> node)
{
	cout << "由" << start << "到其余各顶点距离分别为" << endl;
	for (int i = 0; i < V; i++)
	{
		if (i == start)
			continue;
		else
			cout << start << "->" << i << ": " << node[i]._length << endl;
	}
}

void Dijkstra_Algorithm()
{
	// 1、初始化输出数组D、P
	//vector<int> D(V, MAX);	// 初始化最短长度数组D
	//vector<int> P(V, 0);	// 初始化前驱结点数组P
	vector<Node> node(V, Node(0,0,0));
	for (int i = 0; i < V; i++)
	{
		//node[i] = BuyNode(i, MAX); // 结点初始化
		node[i]._index = i;
		node[i]._length = MAX;
		node[i]._prev = 0;
	}

	// 2、初始化顶点D[S]
	cout << "请输入起点" << endl;
	cin >> S;
	node[S]._length = 0;

	// 3、创建优先队列，起点元素入队列
	priority_queue<Node, vector<Node>, greater<Node>> q; 
	q.push(node[S]);
	while (!q.empty())
	{
		Node cur = q.top();
		q.pop(); // 取出堆顶元素并进行保存
		vector<int> pre_next;
		int Index = cur._index;
		for (int i = 0; i < V; i++) // 将所有可以一步到达当前结点的元素下标全部保存到pre_next中
		{
			if (Graph[Index][i] > 0 && Graph[Index][i] != MAX)
				pre_next.push_back(i);
		}
		while (!pre_next.empty())	// 对于每一个可以到达cur的结点
		{
			int back = pre_next.back();	//访问一个取出一个
			pre_next.pop_back();

			// 新距离就为 从源点到back距离  加上  back到cur的距离
			int newlength = node[Index]._length + Graph[Index][back];

			// 如果新距离小于cur之前的最小距离，就将cur重新赋值，并入队列
			if (newlength < node[back]._length)
			{
				node[back]._length = newlength;
				node[back]._prev = Index;
				q.push(node[back]);
			}
		}
	}
	cout << endl;
	Print_output(S, node);
}

void _Dijkstra_Algorithm()
{
	cout << "Dijkstra_Algorithm :" << endl;
	int choice;
	while (1)
	{
		cout << "请输入：" << "[1]开始" << "[0]结束" << endl;
		cin >> choice;
		switch (choice)
		{
		case 1:
			Dijkstra_Algorithm();
			break;
		case 0:
			exit(0);
			break;
		}
	}
}

int main()
{
	int choice;
	while (1)
	{
		cout << "*******************************************" << endl;
		cout << "***************请输入请求：****************" << endl;
		cout << "***************[1]初始化数据***************" << endl;
		cout << "***************[2]迪杰斯特拉算法***********" << endl;
		cout << "***************[0]退出*********************" << endl;
		cout << "*******************************************" << endl;
		cin >> choice;
		switch (choice)
		{
		case 1:
			CreatMyGraph();
			break;
		case 2:
			_Dijkstra_Algorithm();
			break;
		case 0:
			exit(0);
			break;
		default:
			cout << "输入错误,请重新输入" << endl;
			break;
		}
	}
	return 0;
}

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

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

相关文章

插入排序实现

插入排序实现

场景&#xff1a; 插入排序&#xff0c;一般也被称为直接插入排序。 对于少量元素的排序&#xff0c;它是一个有效的算法 。 插入排序是一种最简单的排序方法&#xff0c;它的基本思想是将一个记录插入到已经排好序的有序表中&#xff0c;从而一个新的、记录数增1的有序表。在…
阅读更多...
分享135个ASP源码，总有一款适合您

分享135个ASP源码，总有一款适合您

ASP源码 分享135个ASP源码&#xff0c;总有一款适合您 下面是文件的名字&#xff0c;我放了一些图片&#xff0c;文章里不是所有的图主要是放不下...&#xff0c; 135个ASP源码下载链接&#xff1a;https://pan.baidu.com/s/1rHFniMK56P-_qXNY9kKihg?pwdl95g 提取码&#x…
阅读更多...
day11文件夹导航条+文件从数据库和cos删除

day11文件夹导航条+文件从数据库和cos删除

获取临时凭证&&上传文件 1创建COS_OBJECT对象 new一个&#xff0c;然后就会向你写的url地址获取临时凭证&#xff08;需要引入一个JS&#xff09; 2.写url地址和url的函数&#xff0c;后台写函数获取到临时凭证&#xff0c;有文档直接调用就可&#xff0c;然后后台返回…
阅读更多...
【C++】右值引用和移动语义 | 新的类功能 | 可变参数模板

【C++】右值引用和移动语义 | 新的类功能 | 可变参数模板

​&#x1f320; 作者&#xff1a;阿亮joy. &#x1f386;专栏&#xff1a;《吃透西嘎嘎》 &#x1f387; 座右铭&#xff1a;每个优秀的人都有一段沉默的时光&#xff0c;那段时光是付出了很多努力却得不到结果的日子&#xff0c;我们把它叫做扎根 目录&#x1f449;左值引用…
阅读更多...
HTTPS 是这样握手的

HTTPS 是这样握手的

HTTP协议默认是明文传输&#xff0c;存在一定的安全隐患&#xff0c;容易被中间人窃听和攻击&#xff0c;在 加密解决HTTP协议带来的安全问题 中提到使用哈希、对称加密、非对称加密等方式对数据加密&#xff0c;能解决数据安全的问题。 以上加密方式需要我们手动的使用加密算…
阅读更多...
python基础——列表切片操作

python基础——列表切片操作

python基础——列表切片操作 文章目录python基础——列表切片操作一、实验目的二、实验原理三、实验环境四、实验内容五、实验步骤一、实验目的 掌握列表切片操作 二、实验原理 1、列表是写在方括号[]之间、用逗号分隔开的元素列表。列表可以完成大多数集合类的数据结构实现…
阅读更多...
23种设计模式（二十三）——解释器模式【邻域问题】

23种设计模式（二十三）——解释器模式【邻域问题】

文章目录 意图什么时候使用解释器真实世界类比解释器模式的实现文法抽象语法树解释器模式的优缺点亦称：Interpreter 意图 给定一个语言，定义它的文法表示，并定义一个解释器，这个解释器使用该标识来解释语言中的句子。 在软件系统中，如果有一些特殊的领域问题较为复杂，疑…
阅读更多...
基于springboot物资管理系统源码含论文

基于springboot物资管理系统源码含论文

摘要 目前&#xff0c;大型物资作为社会零售业态中最为重要的组成部分&#xff0c;处于社会零售商业 进入高速发展的轨道阶段&#xff0c;其在社会经济发展的作用日益明显。国内各大大型基本 上都拥有自己的社会网&#xff0c;将社会物资管理纳入网络管理系统&#xff0c;实现…
阅读更多...
JDK8 新特性之并行的Stream流

JDK8 新特性之并行的Stream流

目录 一&#xff1a;串行的Stream流 二&#xff1a;并行的Stream流 获取并行Stream流的两种方式 小结 三&#xff1a;并行和串行Stream流的效率对比 四&#xff1a;parallelStream线程安全问题 五&#xff1a;parallelStream背后的技术 Fork/Join框架介绍 Fork/Join原理…
阅读更多...
RK3399平台开发系列讲解（内存篇）访问虚拟内存的物理内存过程

RK3399平台开发系列讲解（内存篇）访问虚拟内存的物理内存过程

🚀返回专栏总目录 文章目录 一、虚拟地址的表示二、虚拟地址到物理地址的转换三、Linux页表沉淀、分享、成长，让自己和他人都能有所收获！😄 📢虚拟内存这一概念给进程带来错觉，使它认为内存大到几乎无限，有时甚至超过系统的实际内存。每次访问内存位置时，由CPU完成从…
阅读更多...
static_cast，dynamic_cast，const_cast详解

static_cast，dynamic_cast，const_cast详解

目录 一.static_cast&#xff08;静态转换&#xff09; 二.dynamic_cast&#xff08;动态转换&#xff09; 三.const_cast 一.static_cast&#xff08;静态转换&#xff09; 1.语法&#xff1a; static_cast<new_type>(expression); newtype dataname static_cast…
阅读更多...
分享133个ASP源码，总有一款适合您

分享133个ASP源码，总有一款适合您

ASP源码 分享133个ASP源码&#xff0c;总有一款适合您 下面是文件的名字&#xff0c;我放了一些图片&#xff0c;文章里不是所有的图主要是放不下...&#xff0c; 133个ASP源码下载链接&#xff1a;https://pan.baidu.com/s/1l_8UHQkosNF3HHTu8AFq5A?pwdyxvw 提取码&#x…
阅读更多...
欧几里得与扩展欧几里得算法(含推导过程及代码)

欧几里得与扩展欧几里得算法(含推导过程及代码)

文章目录前言一、欧几里得算法二、扩展欧几里得算法2.1、认识裴蜀定理2.2、推导axbygcd(a, b)得到x与y2.2.1、推导过程2.2.2、代码实现2.3、推导axbygcd(a, b)的所有解及a或者b的最小值&#xff08;结论验证&#xff09;参考文章前言 在学习Acwing c蓝桥杯辅导课第八讲数论-Ac…
阅读更多...
Spark 常用算子02

Spark 常用算子02

常用Action算子 1、countByKey算子 功能&#xff1a;统计key出现的次数&#xff08;一般适用于KV型的RDD&#xff09; 用法&#xff1a; result rdd1.countByKey() print(result)代码示例&#xff1a; # coding:utf8from pyspark import SparkConf, SparkContextif __name…
阅读更多...
破解五角大楼3.0漏洞赏金计划专注于设施控制系统

破解五角大楼3.0漏洞赏金计划专注于设施控制系统

国防部正在计划其“黑掉五角大楼”计划的第三次迭代&#xff0c;重点是找出维持标志性建筑和地面运行的操作技术中的漏洞。 国防部于 2016 年启动了黑客入侵五角大楼计划&#xff0c;供应商 HackerOne 协调了该部门公共网站上的漏洞赏金计划。 超过 1,400 名黑客参加了第一轮…
阅读更多...
绝对空前!!!互联网史上的最大ddos攻击惊艳登场

绝对空前!!!互联网史上的最大ddos攻击惊艳登场

美国遭遇史上最大黑客攻击&#xff0c;知名网站全部瘫痪。全世界一半的网络被黑客攻陷&#xff0c;大网站无一幸免。就在&#xff08;10月22日&#xff09;&#xff0c;美国早上我们见证了互联网建立以来的最大ddos攻击&#xff0c;twitter、netflix、paypal、reddit、pinteres…
阅读更多...
【MySQL】锁

【MySQL】锁

文章目录基础MyISAM表锁并发插入锁调度策略InnoDB事务并发事务行锁行锁争用情况行锁实现方式恢复和复制对InnoDB锁机制的影响死锁MVCC底层实现和原理悲观锁和乐观锁基础 锁是计算机协调多个进程或线程并发访问某一资源的机制&#xff08;避免争抢&#xff09;。在数据库中&…
阅读更多...
一文打通java线程

一文打通java线程

基本概念&#xff1a;程序、进程、线程 程序(program) 是为完成特定任务、用某种语言编写的一组指令的集合。即指一 段静态的代码&#xff0c;静态对象。 进程(process) 是程序的一次执行过程&#xff0c;或是正在运行的一个程序。是一个动态的过程&#xff1a;有它自身的产…
阅读更多...
Linux常用命令——sort命令

Linux常用命令——sort命令

在线Linux命令查询工具(http://www.lzltool.com/LinuxCommand) sort 将文件进行排序并输出 补充说明 sort命令是在Linux里非常有用&#xff0c;它将文件进行排序&#xff0c;并将排序结果标准输出。sort命令既可以从特定的文件&#xff0c;也可以从stdin中获取输入。 语法…
阅读更多...
文本情感分类TextCNN原理+IMDB数据集实战

文本情感分类TextCNN原理+IMDB数据集实战

1.任务背景 情感分类&#xff1a; 发展历程&#xff1a; 2.数据集 本次使用IMDB数据集进行训练。 3.模型结构 3.1 CNN基础 卷积&#xff1a; 单通道卷积&#xff1a;每组卷积核只包含一个。 单通道输入 单输出&#xff1a;设置一组卷积核。 单通道输入 多输出&#xff1a;…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023