统计一个array中各个值出现的次数

可以使用一个哈希表（字典）来统计每个数出现的次数，遍历数组，将每个数作为 key，出现次数作为 value，记录在哈希表中。最后遍历哈希表，输出每个数和它出现的次数。

以下是一个Python实现的例子：

def count_nums(arr):
    counts = {}
    for num in arr:
        if num not in counts:
            counts[num] = 1
        else:
            counts[num] += 1
    return counts

arr = [1, 2, 3, 2, 1, 3, 1, 4, 2, 2]
counts = count_nums(arr)
for num, count in counts.items():
    print(num, "appears", count, "times")

输出：

1 appears 3 times
2 appears 4 times
3 appears 2 times
4 appears 1 times

相关问题

C语言统计一句话中各个字母的个数，将各字母作为节点，各字母出现的次数作为权值，构建哈夫曼树，并打印各个字母所对应的哈夫曼编码

下面是一个C语言程序，可以实现统计一句话中各个字母的个数，构建哈夫曼树并打印哈夫曼编码：

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

#define MAX_LEN 1000

typedef struct Node {
    char data;
    int freq;
    struct Node *left, *right;
} Node;

typedef struct MinHeap {
    int size;
    Node **array;
} MinHeap;

Node *newNode(char data, int freq)
{
    Node *node = (Node *) malloc(sizeof(Node));
    node->data = data;
    node->freq = freq;
    node->left = node->right = NULL;
    return node;
}

MinHeap *createMinHeap(int capacity)
{
    MinHeap *heap = (MinHeap *) malloc(sizeof(MinHeap));
    heap->size = 0;
    heap->array = (Node **) malloc(capacity * sizeof(Node *));
    return heap;
}

void swapNode(Node **a, Node **b)
{
    Node *temp = *a;
    *a = *b;
    *b = temp;
}

void minHeapify(MinHeap *heap, int idx)
{
    int smallest = idx;
    int left = 2 * idx + 1;
    int right = 2 * idx + 2;

    if (left < heap->size && heap->array[left]->freq < heap->array[smallest]->freq) {
        smallest = left;
    }

    if (right < heap->size && heap->array[right]->freq < heap->array[smallest]->freq) {
        smallest = right;
    }

    if (smallest != idx) {
        swapNode(&heap->array[smallest], &heap->array[idx]);
        minHeapify(heap, smallest);
    }
}

int isSizeOne(MinHeap *heap)
{
    return heap->size == 1;
}

Node *extractMin(MinHeap *heap)
{
    Node *temp = heap->array[0];
    heap->array[0] = heap->array[heap->size - 1];
    heap->size--;
    minHeapify(heap, 0);
    return temp;
}

void insertMinHeap(MinHeap *heap, Node *node)
{
    heap->size++;
    int i = heap->size - 1;

    while (i && node->freq < heap->array[(i - 1) / 2]->freq) {
        heap->array[i] = heap->array[(i - 1) / 2];
        i = (i - 1) / 2;
    }

    heap->array[i] = node;
}

void buildMinHeap(MinHeap *heap)
{
    int n = heap->size - 1;
    int i;

    for (i = (n - 1) / 2; i >= 0; i--) {
        minHeapify(heap, i);
    }
}

void printCodes(Node *root, int arr[], int top)
{
    if (root->left) {
        arr[top] = 0;
        printCodes(root->left, arr, top + 1);
    }

    if (root->right) {
        arr[top] = 1;
        printCodes(root->right, arr, top + 1);
    }

    if (!root->left && !root->right) {
        printf("%c: ", root->data);
        for (int i = 0; i < top; i++) {
            printf("%d", arr[i]);
        }
        printf("\n");
    }
}

void huffmanCodes(char data[], int freq[], int size)
{
    MinHeap *heap = createMinHeap(size);

    for (int i = 0; i < size; i++) {
        insertMinHeap(heap, newNode(data[i], freq[i]));
    }

    buildMinHeap(heap);

    while (!isSizeOne(heap)) {
        Node *left = extractMin(heap);
        Node *right = extractMin(heap);
        Node *node = newNode('$', left->freq + right->freq);
        node->left = left;
        node->right = right;
        insertMinHeap(heap, node);
    }

    int arr[MAX_LEN], top = 0;
    printCodes(heap->array[0], arr, top);
}

void countLetters(char sentence[], int freq[], int size)
{
    for (int i = 0; i < size; i++) {
        if (sentence[i] >= 'A' && sentence[i] <= 'Z') {
            freq[sentence[i] - 'A']++;
        } else if (sentence[i] >= 'a' && sentence[i] <= 'z') {
            freq[sentence[i] - 'a']++;
        }
    }
}

int main()
{
    char sentence[MAX_LEN];
    int freq[26] = {0};

    printf("请输入一句英语句子:\n");
    fgets(sentence, MAX_LEN, stdin);
    int len = strlen(sentence);

    countLetters(sentence, freq, len);

    huffmanCodes("abcdefghijklmnopqrstuvwxyz", freq, 26);

    return 0;
}

这个程序中定义了一个 `Node` 结构体表示哈夫曼树的节点，包含了字符数据、出现频率以及左右子节点。还定义了一个 `MinHeap` 结构体表示最小堆，用于构建哈夫曼树。程序中使用了最小堆来实现哈夫曼树的构建，具体实现细节可以参考代码中的注释。

程序首先读入一个字符串，然后统计其中各个字母出现的次数。接着调用 `huffmanCodes` 函数，将各个字母作为节点，各字母出现的次数作为权值，构建哈夫曼树，并打印各个字母所对应的哈夫曼编码。

注意，由于哈夫曼编码的长度不确定，因此在实现中需要使用动态数组或链表等数据结构来存储编码。在这个程序中，我们使用了一个长度为 `MAX_LEN` 的数组 `arr` 来存储哈夫曼编码，其中 `top` 变量表示当前编码的长度。

php判断数组中的值是否都一样？

### 回答1：
可以使用 array_count_values() 函数统计数组中每个值出现的次数，再使用 count() 函数统计数组中元素个数，如果数组中元素个数等于每个值出现的次数，说明数组中的值都一样。

代码示例:

$arr = array(1, 1, 1);
$counts = array_count_values($arr);
if (count($arr) === count($counts)) {
    echo 'All values are the same.';
} else {
    echo 'Values are not the same.';
}

如果需要更高效地判断，可以记录第一个元素的值然后使用foreach循环依次判断是否都相等。

$arr = array(1, 1, 1);
$first = $arr[0];
$equal = true;
foreach($arr as $val){
    if($val != $first){
        $equal = false;
        break;
    }
}
if ($equal) {
    echo 'All values are the same.';
} else {
    echo 'Values are not the same.';
}

### 回答2：
判断数组中的值是否都一样，可以使用php中的array_count_values()函数和count()函数进行判断。

首先，我们可以使用array_count_values()函数统计数组中各个值的出现次数，然后利用count()函数获取数组元素个数，如果统计出的不同值的个数等于1且数组元素个数大于0，则说明数组中的值都一样。

具体实现代码如下所示：

function isAllValuesSame($arr) {
    $count = array_count_values($arr); // 统计数组中各个值的出现次数
    $distinctValuesCount = count($count); // 不同值的个数
    $elementsCount = count($arr); // 数组元素个数

    if ($distinctValuesCount === 1 && $elementsCount > 0) {
        return true;
    } else {
        return false;
    }
}

// 测试示例
$arr1 = [1, 1, 1, 1];
$arr2 = [2, 2, 3, 2];
$arr3 = [];

var_dump(isAllValuesSame($arr1)); // true
var_dump(isAllValuesSame($arr2)); // false
var_dump(isAllValuesSame($arr3)); // false

以上代码将会输出：

bool(true)
bool(false)
bool(false)

说明第一个数组$arr1中的值都一样，而第二个数组$arr2中的值不都一样，第三个数组$arr3为空数组，也不满足条件。

### 回答3：
可以通过以下代码来判断PHP数组中的值是否都一样：

1. 首先，可以使用PHP的array_unique()函数将数组中的重复值去除。这个函数会返回一个新的数组，其中只包含了原数组中不重复的值。

2. 然后，可以使用PHP的count()函数来获取去重后的数组长度。如果长度为1，则说明数组中的值都一样；如果长度大于1，则说明数组中的值不都一样。

下面是一个例子代码：

function isAllValuesSame($arr) {
    $uniqueArr = array_unique($arr);
    $length = count($uniqueArr);
    
    if($length == 1) {
        return true;
    } else {
        return false;
    }
}

$arr1 = [1, 1, 1, 1, 1];
$result1 = isAllValuesSame($arr1);
echo "第一个数组中的值是否都一样：";
echo $result1 ? "是" : "否";
echo "\n";

$arr2 = [1, 2, 3, 4, 5];
$result2 = isAllValuesSame($arr2);
echo "第二个数组中的值是否都一样：";
echo $result2 ? "是" : "否";
echo "\n";

输出结果：

第一个数组中的值是否都一样：是
第二个数组中的值是否都一样：否

在上面的示例中，`isAllValuesSame()`函数可以判断一个数组中的值是否都一样。通过传入不同的数组测试，可以得出不同的结果。