Given an array of integers, sort the array according to frequency of elements-优快云博客

本文介绍了一种使用二叉搜索树(BST)和快速排序来根据元素出现频率对整数数组进行排序的方法。该方法首先将数组中的元素插入到BST中，并记录每个元素的出现次数。然后遍历BST并将元素及其频次存入辅助数组中，接着对该数组进行排序，最后遍历排序后的数组并打印元素。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Given an array of integers, sort the array according to frequency of elements. For example, if the input array is {2, 3, 2, 4, 5, 12, 2, 3, 3, 3, 12}, then modify the array to {3, 3, 3, 3, 2, 2, 2, 12, 12, 4, 5}.

Following is detailed algorithm.
1) Create a BST and while creating BST maintain the count i,e frequency of each coming element in same BST. This step may take O(nLogn) time if a self balancing BST is used.
2) Do Inorder traversal of BST and store every element and count of each element in an auxiliary array. Let us call the auxiliary array as ‘count[]‘. Note that every element of this array is element and frequency pair. This step takes O(n) time.
3) Sort ‘count[]‘ according to frequency of the elements. This step takes O(nLohn) time if a O(nLogn) sorting algorithm is used.
4) Traverse through the sorted array ‘count[]‘. For each element x, print it ‘freq’ times where ‘freq’ is frequency of x. This step takes O(n) time.

Overall time complexity of the algorithm can be minimum O(nLogn) if we use a O(nLogn) sorting algorithm and use a self balancing BST with O(Logn) insert operation.

Following is C++ implementation of the above algorithm.

#include<iostream>
using namespace std;

typedef struct tree_node_s {
	int value;
	int freq;
	struct tree_node_s *lchild;
	struct tree_node_s *rchild;
}tree_node_t, *BSTree;

typedef struct data_s {
	int value;
	int freq;
}data_t;

int tree_search(BSTree T, int value, tree_node_t **p, tree_node_t *f) {
	if (NULL == T) {
		*p = f;
		return 0;
	}
	if (value == T->value) {
		*p = T;
		return 1;
	} else if (value < T->value) {
		return tree_search(T->lchild, value, p, T);
	} else {
		return tree_search(T->rchild, value, p, T);
	}
}

void tree_insert(BSTree *T, int value) {
	tree_node_t *p = NULL;
	if (!tree_search(*T, value, &p, NULL)) {
		tree_node_t *s = (tree_node_t*)malloc(sizeof(tree_node_t));
		s->value = value;
		s->freq = 1;
		s->lchild = NULL;
		s->rchild = NULL;
		if (NULL == (*T))
			*T = s;
		else if (value < p->value)
			p->lchild = s;
		else
			p->rchild = s;
	} else {
		p->freq++;
	}
}

int freq_compare(const void *a, const void *b) {
	return (*(const data_t*)b).freq - (*(const data_t*)a).freq;
}

void store_data(BSTree T, data_t *datas, int *index) {
	if (NULL == T)
		return;
	store_data(T->lchild, datas, index);
	datas[*index].value = T->value;
	datas[*index].freq = T->freq;
	(*index)++;
	store_data(T->rchild, datas, index);
}

void print_arr(int *arr, int n) {
	int i;
	for (i = 0; i < n; i++)
		cout << arr[i] << " ";
}

void sort_by_freq(int *arr, int n) {
	BSTree T = NULL;
	int i;
	for (i = 0; i < n; i++)
		tree_insert(&T, arr[i]);
	data_t *datas = (data_t*)malloc(n * sizeof(data_t));
	int index = 0;
	store_data(T, datas, &index);
	qsort(datas, index, sizeof(datas[0]), freq_compare);
	int j = 0;
	int k;
	for (i = 0; i < index; i++) {
		for (k = datas[i].freq; k > 0; k--)
			arr[j++] = datas[i].value;
	}
	free(datas);
}

int main(int argc, char *argv[]) {
	int arr[] = {2, 3, 2, 4, 5, 12, 2, 3, 3, 3, 12};
	int n = sizeof(arr) / sizeof(int);
	sort_by_freq(arr, n);
	print_arr(arr, n);
	cin.get();
	return 0;
}

连续碰到几个题目都用到bst，看来数据结构的灵活应用可以解决很多问题。