- 使用 Spring Initializr 创建 Spring Boot 应用程序
- 在Spring Boot中配置Cassandra
- 在 Spring Boot 上配置 Tomcat 连接池
- 将Camel消息路由到嵌入WildFly的Artemis上
大家好,我是【1+1=王】, 热爱java的计算机(人工智能)渣硕研究生在读。
如果你也对java、人工智能等技术感兴趣,欢迎关注,抱团交流进大厂!!!
Good better best, never let it rest, until good is better, and better best.
近期会把自己本科阶段的一些课程设计、实验报告等分享出来,供大家参考,希望对大家有帮助。
博客更新至专栏【课程设计实验报告】:https://blog.csdn.net/weixin_43598687/category_11640051.html
(1)创建哈希表
(2)利用Di jkstra算法寻找图的最短路径
1) 数据输入(输入哪些数据、个数、类型、来源、输入方式)
输入哈希表的关键数key(int 整型)
图的顶点数据(data)char字符型;
图的边关系(v1,v2)int 整型;
各边的权值(w)int 整型
2) 数据存储(输入数据在内存中的存储)
定义结构体Hash(key,si)
以数组HashList[i]存储各条数据
采用邻接矩阵存储图
3) 数据处理(说明处理步骤。若不是非常简单,需要绘制流程图)
(1)
①哈希表的查找
储存数据时,将数据存入通过哈希函数所得的地址里,使用同一个哈希函数通过关键字key计算出储存地址,通过该地址访问到查找的记录
②冲突解决
使用线性探测再散列法(冲突发生时,顺序查看表中下一单元,直到找出一个空单元或查遍全表)
(2)
在所有从源点出发的弧中选取一条权值最小的弧,即为第一条最短路径;
设置一个顶点集合S,存放最短路径的终点。顶点k为当前最短路径的终点,将Vk加入集合S中,而Dist[k]为最短路径的长度;
每次从集合V-S中取出具有最短特殊路径长度的顶点u,将u加到S中,同时对数组Dist做必要的修改,若Dist[u]+G.arcs[u][k]<Dist[k]则将Dist[k]改为Dist[u]+arcs[u][k]。其中,特殊路径指从源点到u中间只经过S中顶点的路径;
重复操作2)、3)共n-1次1
4) 数据输出
#include <stdio.h>
#include<iostream>
using namespace std;
#define MaxSize 100 //定义最大哈希表长度
#define NULLKEY -1 //定义空关键字值
#define DELKEY -2 //定义被删关键字值
typedef int KeyType; //关键字类型
typedef char *InfoType; //其他数据类型
typedef struct{
KeyType key; //关键字域
InfoType data; //其他数据域
int count; //探查次数域
}HashTable[MaxSize]; //哈希表类型
void InsertHT(HashTable ha, int &n, KeyType k, int p);
void CreateHT(HashTable ha, KeyType x[], int n, int m, int p);
int SearchHT(HashTable ha, int p, KeyType k);
int DeleteHT(HashTable ha, int p, int k, int &n);
void DispHT(HashTable ha, int n, int m);
void CompASL(HashTable ha, int m);
void main()
{
int x[] = { 16, 74, 60, 43, 54, 90, 46, 31, 29, 88, 77 };
int n = 11, m = 13, p = 13, i, k = 29;
HashTable ha;
CreateHT(ha, x, n, m, p);
cout << endl;
DispHT(ha, n, m);
i = SearchHT(ha, p, k);
if (i != -1)
printf(" ha[%d].key=%d\n", i, k);
else
cout << "未找到" << k << endl;
k = 77;
printf(" 删除关键字%d\n", k);
DeleteHT(ha, p, k, n);
DispHT(ha, n, m);
i = SearchHT(ha, p, k);
if (i != -1)
printf(" ha[%d].key=%d\n", i, k);
else
printf(" 未找到%d\n", k);
printf(" 插入关键字%d\n", k);
InsertHT(ha, n, k, p);
DispHT(ha, n, m);
cout << endl;
system("pause");
}
//将关键字k插入到哈希表中
void InsertHT(HashTable ha, int &n, KeyType k, int p)
{
int i, adr;
adr = k%p;
if (ha[adr].key == NULLKEY || ha[adr].key == DELKEY)
{
ha[adr].key = k;
ha[adr].count = 1;
}
else //发生冲突时,采用线性探查法解决冲突
{
i = 1;
do
{
adr = (adr + 1) % p;
i++;
} while (ha[adr].key != NULLKEY && ha[adr].key != DELKEY);
ha[adr].key = k;
ha[adr].count = i;
}
n++;
}
//创建哈希表
void CreateHT(HashTable ha, KeyType x[], int n, int m, int p)
{
int i, n1 = 0;
for (i = 0; i<m; i++) //哈希表置初值
{
ha[i].key = NULLKEY;
ha[i].count = 0;
}
for (i = 0; i<n; i++)
InsertHT(ha, n1, x[i], p);
}
//在哈希表中查找关键字k
int SearchHT(HashTable ha, int p, KeyType k)
{
int i = 0, adr;
adr = k%p;
while (ha[adr].key != NULLKEY && ha[adr].key != k)
{
i++; //采用线性探查法找下一个地址
adr = (adr + 1) % p;
}
if (ha[adr].key == k) //查找成功
return adr;
else //查找失败
return -1;
}
//删除哈希表中关键字k
int DeleteHT(HashTable ha, int p, int k, int &n)
{
int adr;
adr = SearchHT(ha, p, k);
if (adr != -1) //在哈希表中找到关键字
{
ha[adr].key = DELKEY;
n--; //哈希表长度减1
return 1;
}
else //在哈希表中未找到该关键字
return 0;
}
//输出哈希表
void DispHT(HashTable ha, int n, int m)
{
float avg = 0;
int i;
cout<<" 哈希表地址:";
for (i = 0; i<m; i++)
cout<<i<<" ";
cout << endl;
cout<<" 哈希表关键字:";
for (i = 0; i<m; i++)
if (ha[i].key == NULLKEY || ha[i].key == DELKEY)
cout<<" ";
else
cout<<ha[i].key<<" ";
cout<<endl;
cout<<" 搜索次数:\t";
for (i = 0; i<m; i++)
if (ha[i].key == NULLKEY || ha[i].key == DELKEY)
cout<<" ";
else
cout<<ha[i].count<<" ";
cout << endl;
for (i = 0; i<m; i++)
if (ha[i].key != NULLKEY && ha[i].key != DELKEY)
avg = avg + ha[i].count;
avg = avg / n;
cout << " 平均搜索长度ASL=" << avg << endl;
}
//查找成功时,平均查找长度
void CompASL(HashTable ha, int m)
{
int i;
int s = 0, n = 0;
for (i = 0; i<m; i++)
if (ha[i].key != DELKEY && ha[i].key != NULLKEY)
{
s = s + ha[i].count;
n++;
}
printf(" 查找成功的ASL=%.3g\n", s*1.0 / n);
}
#include <stdio.h>
#include <stdlib.h>
#include<iostream>
#include <string.h>
using namespace std;
#define MAX 100 // 矩阵最大容量
#define INF 65535 // 最大值65535
#define LENGTH(a) (sizeof(a)/sizeof(a[0]))
// 图的邻接矩阵存储
typedef struct _graph
{
char vexs[MAX]; // 顶点集合
int vexnum; // 顶点数
int edgnum; // 边数
int matrix[MAX][MAX]; // 邻接矩阵
}Graph, *PGraph;
// 边的结构体
typedef struct _EdgeData
{
char start; // 边的起点
char end; // 边的终点
int weight; // 边的权重
}EData;
Graph* create_graph();
void print_graph(Graph G);
void dijkstra(Graph G, int vs, int prev[], int dist[]);
int main()
{
int vs;
int prev[MAX] = { 0 };
int dist[MAX] = { 0 };
Graph* pG;
pG = create_graph();
print_graph(*pG); // 打印图
cout << "从第几个节点开始寻找最短路径:";
cin >> vs;
dijkstra(*pG, vs, prev, dist);
system("pause");
return 0;
}
/*
* 创建图(用已提供的矩阵)
*/
Graph* create_graph()
{
char vexs[] = { 'A', 'B', 'C', 'D', 'E', 'F', 'G' };
int matrix[][9] = {
/*A*//*B*//*C*//*D*//*E*//*F*//*G*/
/*A*/{ 0, 12, INF, INF, INF, 16, 14 },
/*B*/{ 12, 0, 10, INF, INF, 7, INF },
/*C*/{ INF, 10, 0, 3, 5, 6, INF },
/*D*/{ INF, INF, 3, 0, 4, INF, INF },
/*E*/{ INF, INF, 5, 4, 0, 2, 8 },
/*F*/{ 16, 7, 6, INF, 2, 0, 9 },
/*G*/{ 14, INF, INF, INF, 8, 9, 0 } };
int vlen = LENGTH(vexs);
int i, j;
Graph* pG;
pG = (Graph*)malloc(sizeof(Graph));
pG->vexnum = vlen;
for (i = 0; i < pG->vexnum; i++)
pG->vexs[i] = vexs[i];
for (i = 0; i < pG->vexnum; i++)
{
for (j = 0; j < pG->vexnum; j++)
pG->matrix[i][j] = matrix[i][j];
}
for (i = 0; i < pG->vexnum; i++)
{
for (j = 0; j < pG->vexnum; j++)
if (i != j && pG->matrix[i][j] != INF)
pG->edgnum++;
}
pG->edgnum /= 2;
return pG;
}
/*
* 打印矩阵队列图
*/
void print_graph(Graph G)
{
int i, j;
cout << "Martix Graph:" << endl;;
for (i = 0; i < G.vexnum; i++)
{
for (j = 0; j < G.vexnum; j++)
printf("%10d ", G.matrix[i][j]);
cout << endl;
}
}
/*
* Dijkstra最短路径。
* 统计图(G)中"顶点vs"到其它各个顶点的最短路径。
*
* 参数说明:
* G -- 图
* vs -- 起始顶点(start vertex)。计算"顶点vs"到其它顶点的最短路径。
* prev -- 前驱顶点数组。
* dist -- 长度数组。
*/
void dijkstra(Graph G, int vs, int prev[], int dist[])
{
int i, j, k;
int min;
int tmp;
int flag[MAX]; // flag[i]=1表示"顶点vs"到"顶点i"的最短路径已成功获取。
// 初始化
for (i = 0; i < G.vexnum; i++)
{
flag[i] = 0; // 顶点i的最短路径还没获取到。
prev[i] = 0; // 顶点i的前驱顶点为0。
dist[i] = G.matrix[vs][i];// 顶点i的最短路径为"顶点vs"到"顶点i"的权。
}
// 对"顶点vs"自身进行初始化
flag[vs] = 1;
dist[vs] = 0;
// 遍历G.vexnum-1次;每次找出一个顶点的最短路径。
for (i = 1; i < G.vexnum; i++)
{
// 寻找当前最小的路径;
min = INF;
for (j = 0; j < G.vexnum; j++)
{
if (flag[j] == 0 && dist[j]<min)
{
min = dist[j];
k = j;
}
}
// 标记"顶点k"为已经获取到最短路径
flag[k] = 1;
// 修正当前最短路径和前驱顶点
// 即,当已经"顶点k的最短路径"之后,更新"未获取最短路径的顶点的最短路径和前驱顶点"。
for (j = 0; j < G.vexnum; j++)
{
tmp = (G.matrix[k][j] == INF ? INF : (min + G.matrix[k][j])); // 防止溢出
if (flag[j] == 0 && (tmp < dist[j]))
{
dist[j] = tmp;
prev[j] = k;
}
}
}
// 打印dijkstra最短路径的结果
printf("dijkstra(%c): \n", G.vexs[vs]);
for (i = 0; i < G.vexnum; i++)
printf(" shortest(%c, %c)=%d\n", G.vexs[vs], G.vexs[i], dist[i]);
}
博客更新至专栏【课程设计实验报告】:https://blog.csdn.net/weixin_43598687/category_11640051.html
滑动窗口限流 滑动窗口限流是一种常用的限流算法,通过维护一个固定大小的窗口,在单位时间内允许通过的请求次数不超过设定的阈值。具体来说,滑动窗口限流算法通常包括以下几个步骤: 初始化:设置窗口
表达式求值:一个只有+,-,*,/的表达式,没有括号 一种神奇的做法:使用数组存储数字和运算符,先把优先级别高的乘法和除法计算出来,再计算加法和减法 int GetVal(string s){
【算法】前缀和 题目 先来看一道题目:(前缀和模板题) 已知一个数组A[],现在想要求出其中一些数字的和。 输入格式: 先是整数N,M,表示一共有N个数字,有M组询问 接下来有N个数,表示A[1]..
1.前序遍历 根-左-右的顺序遍历,可以使用递归 void preOrder(Node *u){ if(u==NULL)return; printf("%d ",u->val);
先看题目 物品不能分隔,必须全部取走或者留下,因此称为01背包 (只有不取和取两种状态) 看第一个样例 我们需要把4个物品装入一个容量为10的背包 我们可以简化问题,从小到大入手分析 weightva
我最近在一次采访中遇到了这个问题: 给出以下矩阵: [[ R R R R R R], [ R B B B R R], [ B R R R B B], [ R B R R R R]] 找出是否有任
我正在尝试通过 C++ 算法从我的 outlook 帐户发送一封电子邮件,该帐户已经打开并记录,但真的不知道从哪里开始(对于 outlook-c++ 集成),谷歌也没有帮我这么多。任何提示将不胜感激。
我发现自己像这样编写了一个手工制作的 while 循环: std::list foo; // In my case, map, but list is simpler auto currentPoin
我有用于检测正方形的 opencv 代码。现在我想在检测正方形后,代码运行另一个命令。 代码如下: #include "cv.h" #include "cxcore.h" #include "high
我正在尝试模拟一个 matlab 函数“imfill”来填充二进制图像(1 和 0 的二维矩阵)。 我想在矩阵中指定一个起点,并像 imfill 的 4 连接版本那样进行洪水填充。 这是否已经存在于
我正在阅读 Robert Sedgewick 的《C++ 算法》。 Basic recurrences section it was mentioned as 这种循环出现在循环输入以消除一个项目的递
我正在思考如何在我的日历中生成代表任务的数据结构(仅供我个人使用)。我有来自 DBMS 的按日期排序的任务记录,如下所示: 买牛奶(18.1.2013) 任务日期 (2013-01-15) 任务标签(
输入一个未排序的整数数组A[1..n]只有 O(d) :(d int) 计算每个元素在单次迭代中出现在列表中的次数。 map 是balanced Binary Search Tree基于确保 O(nl
我遇到了一个问题,但我仍然不知道如何解决。我想出了如何用蛮力的方式来做到这一点,但是当有成千上万的元素时它就不起作用了。 Problem: Say you are given the followin
我有一个列表列表。 L1= [[...][...][.......].......]如果我在展平列表后获取所有元素并从中提取唯一值,那么我会得到一个列表 L2。我有另一个列表 L3,它是 L2 的某个
我们得到二维矩阵数组(假设长度为 i 和宽度为 j)和整数 k我们必须找到包含这个或更大总和的最小矩形的大小F.e k=7 4 1 1 1 1 1 4 4 Anwser是2,因为4+4=8 >= 7,
我实行 3 类倒制,每周换类。顺序为早类 (m)、晚类 (n) 和下午类 (a)。我固定的订单,即它永远不会改变,即使那个星期不工作也是如此。 我创建了一个函数来获取 ISO 周数。当我给它一个日期时
假设我们有一个输入,它是一个元素列表: {a, b, c, d, e, f} 还有不同的集合,可能包含这些元素的任意组合,也可能包含不在输入列表中的其他元素: A:{e,f} B:{d,f,a} C:
我有一个子集算法,可以找到给定集合的所有子集。原始集合的问题在于它是一个不断增长的集合,如果向其中添加元素,我需要再次重新计算它的子集。 有没有一种方法可以优化子集算法,该算法可以从最后一个计算点重新
我有一个包含 100 万个符号及其预期频率的表格。 我想通过为每个符号分配一个唯一(且前缀唯一)的可变长度位串来压缩这些符号的序列,然后将它们连接在一起以表示序列。 我想分配这些位串,以使编码序列的预
我是一名优秀的程序员,十分优秀!