时间复杂度为O(n)的无序表去重算法(C语言)，计数排序

王道数据结构上有一道思考题，删除无序的线性表中重复元素，要求时间复杂度为O(n),我的思路是使用时间复杂度为O(n)的排序算法+时间复杂度为O(n)的删除算法结合来解决这道问题。

计数排序

我使用的排序方法为计数排序，参考：1.8 计数排序 | 菜鸟教程 (runoob.com)

算法思想：以空间换时间，以下是我对此算法的理解

算法的步骤如下：

1.找出待排序的无序表中最大和最小的元素
2.统计要排序的无序表中每个值为i的元素出现的次数，存入临时数组arr的第i项(此时arr中数组下标代表元素值，数组下标对应的元素值代表此元素的个数)
3.临时数组大小为无序表中元素的最大值 - 最小值 + 1（尽量缩小空间复杂度）
4.将临时数组中的存储的信息转化为数据存储进无序表中
计数排序伪代码如下:

int Calculation_sort(SqList *L) {
	//ElemType 是元素类型，我这里是int，其他类型我这里排不了
	ElemType min = L->elems[0];
	ElemType max = L->elems[0];

	//找出无序表中最大值和最小值
	for (int i = 1; i < L->Length; i++)
	{
		if (L->elems[i] < min) {
			min = L->elems;
		}
		else if (L->elems[i] > max) {
			max = L->elems;
		}
	}

	//计算临时数组的大小
	int size = max - min + 1;

	//calloc开辟空间，并将数组中所有值初始化为0，等同于下面两句代码
	// ElemType* arr=(ElemType*)malloc(size*sizeof(ElemType));
	//memset(arr, 0, sizeof(arr));库函数，一般用来初始化内存为0
	ElemType* arr=(ElemType*)calloc(size,sizeof(ElemType));
	if (arr == NULL) {
		return ERROR;
	}

	//统计要排序的无序表中每个值为i的元素出现的次数，存入临时数组arr的第i项
	//(此时arr中数组下标代表元素值，数组下标对应的元素值代表此元素的个数)
	for (int i = 0; i < L->Length; i++)
	{
		arr[L->elems[i]-min]++;
	}

	//将arr中的信息翻译成数据存储进原无序列表，自己理解，关键在于k上
	int k = 0;
	for (int i = 0; i < size; i++)
	{
		
		while (arr[i]) {
			L->elems[k] = i + min;
			arr[i]--;
			k++;
		}//while循环的是相同元素的个数，每循环一次相同元素数目减一，为0时进入下一元素输出
		
	}
	//释放内存
	free(arr);
	arr = NULL;
	return OK;
}

删除算法

删除算法很简单，但有一个前提必须是有序表，这里不做过多描述，直接上代码

int Delete_ordered_list_repeat_elem(SqList* L) {
	int count = 0;
	int cur=L->elems[0];
	for (int i = 1; i < L->Length; i++)
	{
		if (L->elems[i] ==cur) {
			count++;
		}
		else {
			cur = L->elems[i];
			L->elems[i - count] = L->elems[i];
		}

	}
	L->Length -= count;
	return OK;
}

全代码如下

#define _CRT_SECURE_NO_WARNINGS
#pragma once//防止头文件重复包含
#include
#include
#include
#define MAXSIZE 50
#define OK 1;
#define ERROR 0;
typedef int ElemType;

typedef struct {
    ElemType* elems;      
    int Length;      
    int Listsize;    
}SqList;
int InitList(SqList* L){
	L->elems=(ElemType*)malloc(MAXSIZE * sizeof(ElemType));
	if (L->elems == NULL)
	{
		printf("内存开辟失败\n");
		return ERROR;
	}
	L->Length = 0;
	L->Listsize = MAXSIZE;
	return OK;
}
int Append(SqList* L, ElemType e) {
	if (L->Length == MAXSIZE)
		return ERROR;
	L->elems[L->Length++] = e;
	return OK;
}
void PrintList(SqList L) {
	for (int i = 0; i < L.Length; i++)
	{
		printf("%d\n", L.elems[i]);
	}
};
int Delete_ordered_list_repeat_elem(SqList* L) {
	int count = 0;
	int cur=L->elems[0];
	for (int i = 1; i < L->Length; i++)
	{
		if (L->elems[i] ==cur) {
			count++;
		}
		else {
			cur = L->elems[i];
			L->elems[i - count] = L->elems[i];
		}

	}
	L->Length -= count;
	return OK;
}
int Calculation_sort(SqList *L) {
	//ElemType 是元素类型，我这里是int，其他类型我这里排不了
	ElemType min = L->elems[0];
	ElemType max = L->elems[0];

	//找出无序表中最大值和最小值
	for (int i = 1; i < L->Length; i++)
	{
		if (L->elems[i] < min) {
			min = L->elems;
		}
		else if (L->elems[i] > max) {
			max = L->elems;
		}
	}

	//计算临时数组的大小
	int size = max - min + 1;

	//calloc开辟空间，并将数组中所有值初始化为0，等同于下面两句代码
	// ElemType* arr=(ElemType*)malloc(size*sizeof(ElemType));
	//memset(arr, 0, sizeof(arr));库函数，一般用来初始化内存为0
	ElemType* arr=(ElemType*)calloc(size,sizeof(ElemType));
	if (arr == NULL) {
		return ERROR;
	}

	//统计要排序的无序表中每个值为i的元素出现的次数，存入临时数组arr的第i项
	//(此时arr中数组下标代表元素值，数组下标对应的元素值代表此元素的个数)
	for (int i = 0; i < L->Length; i++)
	{
		arr[L->elems[i]-min]++;
	}

	//将arr中的信息翻译成数据存储进原无序列表，自己理解，关键在于k上
	int k = 0;
	for (int i = 0; i < size; i++)
	{
		
		while (arr[i]) {
			L->elems[k] = i + min;
			arr[i]--;
			k++;
		}
		
	}
	//释放内存
	free(arr);
	arr = NULL;
	return OK;
}
int main() {
	SqList List;
	SqList* L = &List;
	InitList(L);
	for (int i = 0; i < 3; i++)
	{
		for (int i = 0; i < 10; i++)
		{
			Append(L, i + 1);
		}
	}
	
	Calculation_sort(L);
	Delete_ordered_list_repeat_elem(L);
	PrintList(List);
	return 0;
}