用c实现上面的算法

以下是用C语言实现的代码：

#include <stdio.h>

int main(void) {
    int n, m;
    scanf("%d %d", &n, &m);
    int a[n][m], b[m][n];
    for(int i=0; i<n; i++) {
        for(int j=0; j<m; j++) {
            scanf("%d", &a[i][j]);
            b[j][i] = a[i][j];
        }
    }
    for(int i=0; i<m; i++) {
        for(int j=0; j<n; j++) {
            printf("%d ", b[i][j]);
        }
        printf("\n");
    }
    return 0;
}

这份代码通过scanf函数读入矩阵的行数和列数，然后使用双重循环分别读入矩阵元素并将其转置后存储到另一个数组中。最后再次使用双重循环输出转置后的矩阵。

相关问题

c 用栈实现括号匹配算法

括号匹配算法是指检查给定字符串中的括号是否匹配的算法。其中，栈是实现该算法的常用数据结构。在遍历字符串时，我们可以将左括号入栈，当遇到右括号时，再将栈顶元素弹出。如果弹出的左括号与当前右括号不匹配，或者栈已空而遇到右括号，则说明括号不匹配。

以下是使用 C 语言实现括号匹配算法的代码：

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

#define MAX_SIZE 100

// 定义栈结构体
typedef struct {
    char data[MAX_SIZE];
    int top;
} Stack;

// 初始化栈
void initStack(Stack* s) {
    s->top = -1;
}

// 判断栈是否为空
bool isEmpty(Stack* s) {
    return s->top == -1;
}

// 判断栈是否已满
bool isFull(Stack* s) {
    return s->top == MAX_SIZE - 1;
}

// 入栈
void push(Stack* s, char c) {
    if (isFull(s)) {
        fprintf(stderr, "Stack is full!\n");
        exit(EXIT_FAILURE);
    }
    s->data[++s->top] = c;
}

// 出栈
char pop(Stack* s) {
    if (isEmpty(s)) {
        fprintf(stderr, "Stack is empty!\n");
        exit(EXIT_FAILURE);
    }
    return s->data[s->top--];
}

// 括号匹配算法
bool checkBrackets(char* str) {
    Stack s;
    initStack(&s);

    for (int i = 0; str[i] != '\0'; i++) {
        if (str[i] == '(' || str[i] == '[' || str[i] == '{') {
            push(&s, str[i]);
        } else if (str[i] == ')' || str[i] == ']' || str[i] == '}') {
            if (isEmpty(&s)) {
                return false;
            }
            char c = pop(&s);
            if ((str[i] == ')' && c != '(') || (str[i] == ']' && c != '[') || (str[i] == '}' && c != '{')) {
                return false;
            }
        }
    }

    return isEmpty(&s);
}

// 测试括号匹配算法
int main() {
    char str[MAX_SIZE];
    printf("Enter a string with brackets: ");
    scanf("%s", str);

    if (checkBrackets(str)) {
        printf("Brackets are matched!\n");
    } else {
        printf("Brackets are not matched!\n");
    }

    return 0;
}

在上面的代码中，我们首先定义了一个栈结构体，包含一个字符数组和一个栈顶指针。然后，我们定义了几个用于操作栈的函数，包括初始化栈、入栈、出栈、判断栈是否为空或已满等。最后，我们实现了括号匹配算法，使用栈来判断字符串中的括号是否匹配。在 main 函数中，我们通过用户输入一个字符串来测试括号匹配算法的正确性。

用C实现DBSCAN算法，不要使用递归算法

好的，您的要求我已经了解了。接下来我将介绍如何用 C 语言实现 DBSCAN 算法，不使用递归算法。

DBSCAN 算法是一种基于密度的聚类算法，它可以将数据点分为核心点、边界点和噪声点三类。其基本思路是，对于每个核心点，找到其密度可达的所有点，将它们归为同一个簇中。而边界点则被归为与其关联的核心点所在的簇中，噪声点则被单独归为一个簇中。

下面是用 C 语言实现 DBSCAN 算法的大致步骤：

1. 定义数据结构：需要定义数据点的结构体，存储每个点的坐标、所属簇的编号等信息。

2. 读入数据：从文件中读入数据点的坐标信息。

3. 计算距离：根据数据点的坐标信息，计算每两个点之间的距离。

4. 确定核心点：对于每个数据点，计算其邻域内的点的数量，如果大于等于一个给定的阈值，则将其标记为核心点。

5. 构建簇：遍历所有核心点，找到其密度可达的所有点，将它们归为同一个簇中，同时将边界点归为与其关联的核心点所在的簇中，噪声点则被单独归为一个簇中。

6. 输出结果：输出每个数据点所属的簇编号。

下面是一个简单的 C 语言代码实现：

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

#define MAX_POINTS 1000
#define EPS 2.0
#define MIN_POINTS 5

typedef struct {
    double x, y;
    int cluster_id;
} Point;

double distance(Point p1, Point p2) {
    double dx = p1.x - p2.x;
    double dy = p1.y - p2.y;
    return sqrt(dx * dx + dy * dy);
}

void dbscan(Point points[], int n) {
    int i, j, k, cluster_id = 1;
    for (i = 0; i < n; i++) {
        if (points[i].cluster_id == 0) {
            int count = 0;
            for (j = 0; j < n; j++) {
                if (distance(points[i], points[j]) <= EPS) {
                    count++;
                }
            }
            if (count >= MIN_POINTS) {
                points[i].cluster_id = cluster_id;
                for (k = 0; k < n; k++) {
                    if (distance(points[i], points[k]) <= EPS) {
                        if (points[k].cluster_id == 0 || points[k].cluster_id == -1) {
                            points[k].cluster_id = cluster_id;
                        }
                    }
                }
                cluster_id++;
            } else {
                points[i].cluster_id = -1;
            }
        }
    }
}

int main() {
    int i, n;
    Point points[MAX_POINTS];
    FILE *fp = fopen("data.txt", "r");
    if (fp == NULL) {
        printf("Failed to open data file!\n");
        return 1;
    }
    fscanf(fp, "%d", &n);
    for (i = 0; i < n; i++) {
        fscanf(fp, "%lf %lf", &points[i].x, &points[i].y);
    }
    fclose(fp);
    dbscan(points, n);
    for (i = 0; i < n; i++) {
        printf("%.2lf %.2lf %d\n", points[i].x, points[i].y, points[i].cluster_id);
    }
    return 0;
}

在上面的代码中，我们定义了一个 Point 结构体来存储每个数据点的信息，包括坐标和所属簇的编号。我们采用了一个简单的双重循环来计算每两个点之间的距离，并判断每个点是否为核心点。然后我们使用一个三重循环来构建簇，遍历所有核心点，找到其密度可达的所有点，并将它们归为同一个簇中。最后我们输出每个数据点的坐标和所属簇的编号。

需要注意的是，上面的代码实现只是一个简单的示例，实际情况下需要根据具体应用场景进行修改和优化。例如，可以使用 K-D 树等数据结构来加速计算距离，或者使用多线程等技术来提高效率。