用c语言实现:遍历数组的每一个元素,找出最小元素并输出,同时将该元素赋值为无穷大,再次遍历数组,找到此时的最小值并输出,并将该元素赋值无穷大,以此类推,直到数组元素按从小到大输出一遍
时间: 2024-01-07 09:05:34 浏览: 51
好的,这是一个经典的选择排序算法,我可以帮你用 C 语言实现。以下是代码:
```c
#include <stdio.h>
#include <limits.h> // 包含INT_MAX
int main()
{
int arr[] = {5, 2, 8, 3, 1, 9, 4, 6, 7}; // 待排序数组
int n = sizeof(arr) / sizeof(arr[0]); // 数组长度
for (int i = 0; i < n; i++) {
int min_index = i;
for (int j = i + 1; j < n; j++) {
// 找到未排序部分的最小值
if (arr[j] < arr[min_index]) {
min_index = j;
}
}
// 输出最小值
printf("%d ", arr[min_index]);
// 将最小值赋值为无穷大
arr[min_index] = INT_MAX;
}
return 0;
}
```
这个程序会输出数组元素按从小到大排序的结果,输出为:
```
1 2 3 4 5 6 7 8 9
```
相关问题
用c语言实现邻接矩阵创建一个带权有向图并实现计算各顶点的入度,深度优先遍历,广度优先遍历
好的,下面是基于邻接矩阵的带权有向图的实现和相关操作的代码(使用 C 语言实现):
```c
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <limits.h> // 定义一个无穷大的数
#define MAX_SIZE 100 // 最大顶点数
#define INF INT_MAX // 定义一个无穷大的数
typedef struct {
int vertex_num; // 顶点数
int edge_num; // 边数
int matrix[MAX_SIZE][MAX_SIZE]; // 邻接矩阵
} Graph;
// 创建一个新的图
Graph* createGraph(int n, int m) {
Graph* graph = (Graph*)malloc(sizeof(Graph));
graph->vertex_num = n;
graph->edge_num = m;
// 初始化邻接矩阵
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
graph->matrix[i][j] = INF;
}
}
return graph;
}
// 添加一条从 u 到 v 的边,权值为 w
void addEdge(Graph* graph, int u, int v, int w) {
graph->matrix[u][v] = w;
}
// 计算各个顶点的入度
void calcInDegree(Graph* graph) {
int in_degree[MAX_SIZE] = {0};
for (int j = 1; j <= graph->vertex_num; j++) {
for (int i = 1; i <= graph->vertex_num; i++) {
if (graph->matrix[i][j] != INF) {
in_degree[j]++;
}
}
}
for (int i = 1; i <= graph->vertex_num; i++) {
printf("顶点 %d 的入度为 %d\n", i, in_degree[i]);
}
}
// 深度优先遍历
void dfs(Graph* graph, int u, bool visited[]) {
visited[u] = true;
printf("%d ", u);
for (int v = 1; v <= graph->vertex_num; v++) {
if (graph->matrix[u][v] != INF && !visited[v]) {
dfs(graph, v, visited);
}
}
}
// 从顶点 s 开始进行深度优先遍历
void dfsTraversal(Graph* graph, int s) {
bool visited[MAX_SIZE] = {false};
dfs(graph, s, visited);
printf("\n");
}
// 广度优先遍历
void bfsTraversal(Graph* graph, int s) {
bool visited[MAX_SIZE] = {false};
int queue[MAX_SIZE];
int front = 0, rear = 0;
queue[rear++] = s;
visited[s] = true;
while (front < rear) {
int u = queue[front++];
printf("%d ", u);
for (int v = 1; v <= graph->vertex_num; v++) {
if (graph->matrix[u][v] != INF && !visited[v]) {
queue[rear++] = v;
visited[v] = true;
}
}
}
printf("\n");
}
int main() {
int n, m;
printf("请输入顶点数和边数:");
scanf("%d%d", &n, &m);
Graph* graph = createGraph(n, m);
printf("请依次输入边的起点、终点和权值:\n");
for (int i = 1; i <= m; i++) {
int u, v, w;
scanf("%d%d%d", &u, &v, &w);
addEdge(graph, u, v, w);
}
printf("各个顶点的入度为:\n");
calcInDegree(graph);
printf("深度优先遍历结果为:");
dfsTraversal(graph, 1);
printf("广度优先遍历结果为:");
bfsTraversal(graph, 1);
return 0;
}
```
示例输入:
```
请输入顶点数和边数:5 6
请依次输入边的起点、终点和权值:
1 2 1
1 3 2
2 4 3
2 5 4
3 5 5
4 5 6
```
示例输出:
```
各个顶点的入度为:
顶点 1 的入度为 0
顶点 2 的入度为 1
顶点 3 的入度为 1
顶点 4 的入度为 1
顶点 5 的入度为 3
深度优先遍历结果为:1 2 4 5 3
广度优先遍历结果为:1 2 3 4 5
```
用c语言写一个求解无向图遍历完所有点走过的最短路径问题,并打印出最短路径
好的,我可以为您提供一个基于 Dijkstra 算法的 C 语言程序来解决无向图遍历完所有点走过的最短路径问题。这里假设图是不带权的。
代码如下:
```c
#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
#define MAX_VERTICES 100
#define INFINITY INT_MAX
int graph[MAX_VERTICES][MAX_VERTICES];
int distance[MAX_VERTICES];
int visited[MAX_VERTICES];
int num_vertices;
void dijkstra(int start_vertex) {
int i, j, min_distance, next_vertex;
// 初始化距离为无穷大,visited 为 false
for (i = 0; i < num_vertices; i++) {
distance[i] = INFINITY;
visited[i] = 0;
}
// 设置起始点的距离为 0
distance[start_vertex] = 0;
// 计算最短路径
for (i = 0; i < num_vertices; i++) {
min_distance = INFINITY;
// 找到距离起始点最近的点
for (j = 0; j < num_vertices; j++) {
if (!visited[j] && distance[j] < min_distance) {
min_distance = distance[j];
next_vertex = j;
}
}
// 标记该点为 visited
visited[next_vertex] = 1;
// 更新相邻点的距离
for (j = 0; j < num_vertices; j++) {
if (!visited[j] && graph[next_vertex][j] != 0) {
if (distance[next_vertex] + graph[next_vertex][j] < distance[j]) {
distance[j] = distance[next_vertex] + graph[next_vertex][j];
}
}
}
}
}
int main() {
int i, j, total_distance = 0;
printf("请输入无向图的顶点数:");
scanf("%d", &num_vertices);
printf("请输入无向图的邻接矩阵:\n");
for (i = 0; i < num_vertices; i++) {
for (j = 0; j < num_vertices; j++) {
scanf("%d", &graph[i][j]);
}
}
// 从第一个点开始计算最短路径
dijkstra(0);
// 计算总距离
for (i = 0; i < num_vertices; i++) {
total_distance += distance[i];
}
printf("最短路径为:");
for (i = 0; i < num_vertices; i++) {
printf("%d ", distance[i]);
}
printf("\n");
printf("总距离为:%d\n", total_distance);
return 0;
}
```
在程序中,我们首先输入无向图的顶点数和邻接矩阵,然后调用 dijkstra 函数计算最短路径。最后,我们输出最短路径和总距离。
需要注意的是,这个程序假设图是不带权的,如果需要处理带权图,只需要将邻接矩阵中的 0 替换为相应的边权值即可。
相关推荐
![rar](https://img-home.csdnimg.cn/images/20210720083606.png)
![-](https://csdnimg.cn/download_wenku/file_type_column_c1.png)
![](https://csdnimg.cn/download_wenku/file_type_ask_c1.png)
![](https://csdnimg.cn/download_wenku/file_type_ask_c1.png)
![](https://csdnimg.cn/download_wenku/file_type_ask_c1.png)
![](https://csdnimg.cn/download_wenku/file_type_ask_c1.png)
![](https://csdnimg.cn/download_wenku/file_type_ask_c1.png)
![](https://csdnimg.cn/download_wenku/file_type_ask_c1.png)
![](https://csdnimg.cn/download_wenku/file_type_ask_c1.png)
![](https://csdnimg.cn/download_wenku/file_type_ask_c1.png)
![](https://csdnimg.cn/download_wenku/file_type_ask_c1.png)
![](https://csdnimg.cn/download_wenku/file_type_ask_c1.png)
![](https://csdnimg.cn/download_wenku/file_type_ask_c1.png)
![](https://csdnimg.cn/download_wenku/file_type_ask_c1.png)