c语言中权是什么意思 权值在c语言算法中的特殊含义

#include <stdio.h>

#define MAX_NODES 100
#define INF 999999

// 图的邻接矩阵表示
int graph[MAX_NODES][MAX_NODES];

// 初始化图
void initGraph(int n) {
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            graph[i][j] = (i == j) ? 0 : INF;
        }
    }
}

// 添加带权边的函数
void addEdge(int u, int v, int weight) {
    graph[u][v] = weight;
    graph[v][u] = weight; // 如果是无向图
}

int main() {
    int n = 5; // 假设我们有一个5个节点的图
    initGraph(n);

    // 添加一些带权边
    addEdge(0, 1, 10);
    addEdge(0, 4, 3);
    addEdge(1, 2, 2);
    addEdge(1, 4, 4);
    addEdge(2, 3, 9);
    addEdge(3, 2, 7);
    addEdge(4, 1, 1);
    addEdge(4, 3, 2);

    // 打印图的邻接矩阵
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            if (graph[i][j] == INF) {
                printf("INF ");
            } else {
                printf("%d ", graph[i][j]);
            }
        }
        printf("\n");
    }

    return 0;
}

#include <stdio.h>

#define MAX_SIZE 100

// 优先队列的结构
struct PriorityQueue {
    int heap[MAX_SIZE];
    int size;
};

// 初始化优先队列
void initQueue(struct PriorityQueue *pq) {
    pq->size = 0;
}

// 插入元素到优先队列中
void insert(struct PriorityQueue *pq, int value) {
    if (pq->size >= MAX_SIZE) {
        printf("Priority queue is full\n");
        return;
    }

    int i = pq->size;
    pq->heap[i] = value;
    pq->size++;

    // 上浮操作，确保堆的性质
    while (i > 0 && pq->heap[(i - 1) / 2] < pq->heap[i]) {
        int temp = pq->heap[(i - 1) / 2];
        pq->heap[(i - 1) / 2] = pq->heap[i];
        pq->heap[i] = temp;
        i = (i - 1) / 2;
    }
}

// 从优先队列中删除并返回最大元素
int deleteMax(struct PriorityQueue *pq) {
    if (pq->size == 0) {
        printf("Priority queue is empty\n");
        return -1;
    }

    int max = pq->heap[0];
    pq->heap[0] = pq->heap[pq->size - 1];
    pq->size--;

    // 下沉操作，确保堆的性质
    int i = 0;
    while (2 * i + 1 < pq->size) {
        int child = 2 * i + 1;
        if (child + 1 < pq->size && pq->heap[child + 1] > pq->heap[child]) {
            child++;
        }

        if (pq->heap[i] >= pq->heap[child]) {
            break;
        }

        int temp = pq->heap[i];
        pq->heap[i] = pq->heap[child];
        pq->heap[child] = temp;
        i = child;
    }

    return max;
}

int main() {
    struct PriorityQueue pq;
    initQueue(&pq);

    insert(&pq, 3);
    insert(&pq, 1);
    insert(&pq, 4);
    insert(&pq, 1);
    insert(&pq, 5);

    printf("Max element: %d\n", deleteMax(&pq));
    printf("Max element: %d\n", deleteMax(&pq));
    printf("Max element: %d\n", deleteMax(&pq));

    return 0;
}

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

// 哈夫曼树节点的结构
struct Node {
    int weight;
    struct Node *left;
    struct Node *right;
};

// 比较函数，用于优先队列
int compare(const void *a, const void *b) {
    return ((struct Node *)a)->weight - ((struct Node *)b)->weight;
}

// 创建哈夫曼树
struct Node *createHuffmanTree(int *frequencies, int size) {
    struct Node **nodes = (struct Node **)malloc(size * sizeof(struct Node *));
    for (int i = 0; i < size; i++) {
        nodes[i] = (struct Node *)malloc(sizeof(struct Node));
        nodes[i]->weight = frequencies[i];
        nodes[i]->left = NULL;
        nodes[i]->right = NULL;
    }

    while (size > 1) {
        qsort(nodes, size, sizeof(struct Node *), compare);
        struct Node *left = nodes[0];
        struct Node *right = nodes[1];

        struct Node *parent = (struct Node *)malloc(sizeof(struct Node));
        parent->weight = left->weight + right->weight;
        parent->left = left;
        parent->right = right;

        nodes[0] = parent;
        nodes[1] = nodes[size - 1];
        size--;
    }

    struct Node *root = nodes[0];
    free(nodes);
    return root;
}

// 打印哈夫曼树（前序遍历）
void printHuffmanTree(struct Node *root) {
    if (root == NULL) {
        return;
    }
    printf("%d ", root->weight);
    printHuffmanTree(root->left);
    printHuffmanTree(root->right);
}

int main() {
    int frequencies[] = {5, 9, 12, 13, 16, 45};
    int size = sizeof(frequencies) / sizeof(frequencies[0]);

    struct Node *root = createHuffmanTree(frequencies, size);
    printf("Huffman Tree (preorder traversal): ");
    printHuffmanTree(root);
    printf("\n");

    return 0;
}