数据结构与算法习题：快排，堆排，计数排序，qsort对链表进行排序，哈希函数的使用，第K大数的单机查找和双机查找

最新推荐文章于 2024-04-13 08:00:00 发布
最新推荐文章于 2024-04-13 08:00:00 发布
阅读量279 收藏 1
点赞数
分类专栏： 数据结构与算法学习笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CLZHIT/article/details/104380521
版权

1、完成快排，堆排，计数排序算法，对比不同算法排序1亿数的时间

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <string.h>
#define NUM 100000000
#define M 100000000
#define SWAP(A, B) {int tmp; tmp = A; A = B; B = tmp;}

int find_pivot(int* arr, int left, int right);
void quick_sort(int* arr, int left, int right);
void adjust_heap_node(int* arr, int dad, int arrlen);
void heap_sort(int* arr, int N);

int find_pivot(int* arr, int left, int right)
{
	int pivot = right;    //以数组元素中最右端的元素作为基准
	int insertvalue = arr[right];
	int i = left, k = left, j;        //i和k相当于数组中的双指针
	for (j = left; j < right; j++)   //遍历数组中的元素
	{
		if (arr[k] <= insertvalue)  
		{
			k++;
			i++;
		}
		else {
			if (arr[i] <= insertvalue)
			{
				SWAP(arr[k], arr[i]);
				k++;
				i++;
				continue;
			}
			i++;
		}
	}
	SWAP(arr[k], arr[right]);
	return k;     //C语言在函数中可以返回一个局部变量嘛
}
void quick_sort(int* arr, int left, int right)
{
	if (left < right)
	{
		int pivot = find_pivot(arr, left, right);
		quick_sort(arr, left, pivot - 1);
		quick_sort(arr, pivot + 1, right);
	}
}
void adjust_heap_node(int* arr, int dad, int arrlen)
{
	int son = 2 * dad + 1;
	while (son < arrlen)
	{
		if (son + 1 < arrlen && arr[son] < arr[son + 1])
		{
			son++;
		}
		else if (arr[dad] < arr[son])
		{
			SWAP(arr[dad], arr[son]);
			dad = son;
			son = 2 * dad + 1;
			continue;
		}
		else {
			break;
		}
	}
	return;
}

void heap_sort(int* arr, int N)
{
	for (int dad = N / 2 - 1; dad >= 0; dad--)
	{
		adjust_heap_node(arr, dad, N-1);
	}
	SWAP(arr[0], arr[N - 1]);
	for (int i = N - 2; i > 1; i--)
	{
		adjust_heap_node(arr, 0, i);
		SWAP(arr[0], arr[i - 1]);
	}
	return;
}

void count_sort(int* arr)
{
	int i, j, k;
	int* count = (int*)calloc(1, M * sizeof(int));
	//int count[M] = { 0 };
	//memset(count, 0, sizeof(int));
	for (i = 0; i < NUM; i++)
	{
		count[arr[i]]++;
	}
	k = 0;
	for (i = 0; i < M; i++)
	{
		for (j = 0; j < count[i]; j++)
		{
			//printf("%d ", j);
			arr[k++] = i;
		}
	}
	//printf("\n");
}

void arr_print(int* arr, int N)
{
	for (int i = 0; i < N; i++)
	{
		printf("%3d", arr[i]);
	}
	printf("\n");
}
int main()
{
	int i;
	int* arr = (int*)malloc(NUM * sizeof(int));
	time_t start, end;
	srand(time(NULL));
	for (i = 0; i < NUM; i++)
	{
		arr[i] = rand() % M;
	}
	//arr_print(arr, NUM);
	//quick_sort(arr, 0, NUM - 1);
	//heap_sort(arr, NUM);
	//arr_print(arr, NUM);
	start = time(NULL);
	//heap_sort(arr, NUM);
	count_sort(arr);
	//arr_print(arr, NUM);
	end = time(NULL);
	printf("use time = %d\n", end - start);
	system("pause");
	return 0;
}

2、使用qsort对一个链表进行排序

#define _CRT_SECURE_NO_WARNINGS
#define N 100
#include <stdio.h>
#include <stdlib.h>
typedef struct Node
{
	int data;
	struct Node* pnext;
}Node_t, *pNode_t;
int compare(const void* p1, const void* p2)      //一级指针强转成二级指针
{
	pNode_t* pNode1 = (pNode_t*)p1;
	pNode_t* pNode2 = (pNode_t*)p2;
	return (*pNode1)->data - (*pNode2)->data;
}
void ListPrint(pNode_t phead)
{
	if (NULL == phead)
	{
		return;
	}
	while (phead)
	{
		printf("%d ", phead->data);
		phead = phead->pnext;
	}
	printf("\n");
}
int main()
{
	pNode_t arr[N];
	int value;
	int cnt = 0;
	pNode_t phead = NULL;
	pNode_t ptail = NULL;

	while (scanf("%d", &value) != EOF)
	{
		pNode_t pnew = (pNode_t)calloc(1, sizeof(Node_t));
		pnew->data = value;
		if (NULL == phead)
		{
			phead = pnew;
			ptail = pnew;
		}
		else
		{
			ptail->pnext = pnew;
			ptail = pnew;
		}
		cnt++;
	}
	ListPrint(phead);
	for (int i = 0; i < cnt; i++)
	{
		arr[i] = phead;
		phead = phead->pnext;
	}
	qsort(arr, cnt, sizeof(pNode_t), compare);
	for (int i = 0; i < cnt; i++)
	{
		printf("%d ", arr[i]->data);
	}
	printf("\n");
	return 0;

3、使用哈希函数，将20个不同姓名的同学的插入数组，并且输入一个姓名，判断该姓名是否是已知的姓名

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAXKEY 1000
#define N 10
int hash(char* key)
{
	int h = 0, g;
	while (*key)
	{
		h = (h << 4) + *key++;
		g = h & 0xf0000000;
		if (g)
			h ^= g >> 24;
		h &= ~g;
	}
	return h % MAXKEY;
}
int main()
{
	char* pStr[N];
	char name[N][20] = { 0 };
	char str[20] = { 0 };
	char* hashTable[MAXKEY] = { NULL };
	for (int i = 0; i < N; i++)
	{
		fgets(name[i], 20, stdin);
		if (name[i][strlen(name[i]) - 1] == '\n')
		{
			name[i][strlen(name[i]) - 1] = '\0';
		}
		pStr[i] = name[i];
	}
	for (int i = 0; i < N; i++)
	{
		printf("%5s hashValue=%d\n", pStr[i], hash(pStr[i]));
		hashTable[hash(pStr[i])] = pStr[i];
	}
	printf("need to find name:\n");
	while (gets(str) != NULL)
	{
		if (hashTable[hash(str)] == NULL)
		{
			printf("It is not exist.\n");
		}
		else
		{
			printf("It is in array number: %d\n", hash(str));
		}
		printf("need to find name again:\n");
	}
	system("pause");
}

4、实现找第K大的数的单机查找和双机查找

//该段代码只实现了第K大的数的单机查找
//我先实现了小顶堆对数组中前K个元素进行排序，从大到小，第k位即为现在的第k大
//然后实现了将k-N-1个元素和第k个元素进行对比，若大于第k个元素，则替换掉第k个元素，再对
//前K个数组元素建立最小堆并进行调整，最后结果输出arr[k-1]
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <string.h>
#define NUM 10
#define M 100
#define SWAP(A, B) {int tmp; tmp = A; A = B; B = tmp;}

void adjust_heap_node(int* arr, int dad, int arrlen);
void heap_sort(int* arr, int k);

void adjust_heap_node(int* arr, int dad, int arrlen)
{
	int son = 2 * dad + 1;
	while (son < arrlen)
	{
		if (son + 1 < arrlen && arr[son] > arr[son + 1])
		{
			son++;
		}
		else if (arr[dad] > arr[son])
		{
			SWAP(arr[dad], arr[son]);
			dad = son;
			son = 2 * dad + 1;
			continue;
		}
		else {
			break;
		}
	}
	return;
}
void heap_sort(int* arr, int k)
{
	for (int dad = k / 2 - 1; dad >= 0; dad--)
	{
		adjust_heap_node(arr, dad, k);
	}
	SWAP(arr[0], arr[k - 1]);
	for (int i = k - 1; i > 1; i--)
	{
		adjust_heap_node(arr, 0, i);
		SWAP(arr[0], arr[i-1]);
	}
	return;
}
void arr_print(int* arr, int N)
{
	for (int i = 0; i < N; i++)
	{
		printf("%3d", arr[i]);
	}
	printf("\n");
}
int main()
{
	int i;
	int k;
	int* arr = (int*)malloc(NUM * sizeof(int));
	time_t start, end;
	srand(time(NULL));
	for (i = 0; i < NUM; i++)
	{
		arr[i] = rand() % M;
	}
	arr_print(arr, NUM);
	printf("please input the kth big number:\n");
	scanf("%d", &k);
	//quick_sort(arr, 0, NUM - 1);
	//heap_sort(arr, NUM);
	//arr_print(arr, NUM);
	start = time(NULL);
	heap_sort(arr,k);
	for (int i = k; i < NUM; i++)
	{
		if (arr[i] > arr[k - 1])
		{
			SWAP(arr[i], arr[k - 1]);
			heap_sort(arr, k);
		}
	}
	arr_print(arr, NUM);
	printf("the kth big number: %d\n", arr[k - 1]);
	end = time(NULL);
	printf("use time = %d\n", end - start);
	system("pause");
	return 0;

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<time.h>
#define N 1000
#define SWAP(a,b) {int tmp = a; a = b; b = tmp;}
int singleFind(int* arr, int k);
int doubleFind(int* arr1, int* arr2, int k);
void adjust_heap_node(int* arr, int dad, int arrlen);
int compare(const void* p1, const void* p2)
{
	return *(int*)p2 - *(int*)p1;
}
int main()
{
	int arr1[N] = { 0 };
	int arr2[N] = { 0 };
	int arr3[N] = { 0 };
	srand(time(NULL));
	for (int i = 0; i < N; ++i)
	{
		arr1[i] = rand() % N;
		arr2[i] = arr1[i];
		arr3[i] = arr1[i];
	}
	qsort(arr1, N, sizeof(int), compare);
	int res1 = singleFind(arr2, 10);
	int* p1 = arr3;
	int* p2 = arr3 + N / 2;
	qsort(p1, N / 2, sizeof(int), compare);
	qsort(p2, N - N / 2, sizeof(int), compare);
	int res2 = doubleFind(p1, p2, 10);
	return 0;
}
void adjust_heap_node(int* arr, int dad, int arrlen)
{
	int son = 2 * dad + 1;
	while (son < arrlen)
	{
		if (son + 1 < arrlen && arr[son] > arr[son + 1])
		{
			son++;
		}
		else if (arr[dad] > arr[son])
		{
			SWAP(arr[dad], arr[son]);
			dad = son;
			son = 2 * dad + 1;
			continue;
		}
		else {
			break;
		}
	}
}
int singleFind(int* arr, int k)   
{
	//所有数据的下标范围0~N-1
	//所有堆元素的下标范围0~k-1
	//对前k个数字建堆
	for (int dad = (k - 2) / 2; dad >= 0; --dad)
	{
		adjust_heap_node(arr, dad, k);
	}
	//剩余的元素，比较、取代，然后重建堆
	for (int i = k; i < N; ++i)
	{
		if (arr[0] < arr[i])
		{
			arr[0] = arr[i];
			adjust_heap_node(arr, 0, k);
		}
	}
	return arr[0];
}
int doubleFind(int* arr1, int* arr2, int k)
{
	if (k == 1)
	{
		return arr1[0] > arr2[0] ? arr1[0] : arr2[0];
	}
	else
	{
		int num = k / 2;    //要查找的数量
		if (arr1[num - 1] > arr2[num - 1])
		{
			return doubleFind(arr1 + num, arr2, k - num);
		}
		else if (arr1[num - 1] < arr2[num - 1])
		{
			return doubleFind(arr1, arr2 + num, k - num);
		}
		else
		{
			if (k % 2 == 0)
			{
				return arr1[num - 1];
			}
			else
			{
				return doubleFind(arr1 + num, arr2 + num, 1);
			}
		}
	}
}
不会code的菜鸟
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构65：快速排序算法（QSort，快排）
weixin_30588827的博客
05-23 313
上节介绍了如何使用起泡排序的思想对无序表中的记录按照一定的规则进行排序，本节再介绍一种排序算法——快速排序算法（Quick Sort）。 C语言中自带函数库中就有快速排序——qsort函数 ，包含在 <stdlib.h> 头文件中。 快速排序算法是在起泡排序的基础上进行改进的一种算法，其实现的基本思想是：通过一次排序将整个无序表分成相互独立的两部分，其中一部分...
数据结构7.1 - 排序 库函数 sort、qsort
qq_1403034144的博客
04-26 310
1 写在前面： com函数 和 cmp函数 的函数列表形式对于 一维数组 不可改动！ 对于不同数据类型的数组，改动函数内部的数据类型即可 com函数 的函数列表形式 对于结构体 要改动！ cmp函数 的函数列表形式 对于结构体 仍不能改动！ 2 sort() 2.1 一维数组排序： sort(数组名, 数组名 + 长度, com) com 控制 升序 和 降序 可不写com，这时 默认升序 sor...
C++学习笔记——简单哈希表
最新发布
qq_23311271的博客
04-13 849
自定义哈希表
使用qsort函数进行快速排序以及链表的冒泡排序
weixin_45841983的博客
05-25 736
使用qsort函数进行快速排序以及链表的冒泡排序qsort函数快速排序qsort快速排序二维数组qsort快速排序结构体数组qsort快速排序指针数组（malloc申请空间的二维数组）链表内容的冒泡排序 文章参考传送门： 参考博客1 参考博客2 qsort函数快速排序 qsort快速排序二维数组 对应回调函数如下 int cmp_int(const void* a, const void* b) { return ((int*)a)[2] - ((int*)b)[2]; //从小到大排序 return
qsort用法
Jcy
10-31 1256
在我们平时排序的时候，莫不过是sort，stable_sort……这些STL里面的排序模版了，在C中也有一个很厉害的排序算法：qsort，今天简单说说他的一个用法。 #include #include #include using namespace std; inline int intcmp(const void* a,const void* b) { int aa
七、排序(4)——qsort()
盛夏光年
10-28 678
一、回顾 时间复杂度 是稳定排序 是原地排序 冒泡排序 O(n2) √ √ 插入排序 O(n2) √ √
c语言链表的排序算法-排序链表最快的算法是什么？.pdf
04-07
在我们的实验中，我们使用了C语言来实现链表排序算法，并使用clock()函数来测量排序所需的时间。我们比较了三个不同的链表排序算法：合并排序、快速排序和内置的qsort算法。结果表明，合并排序和快速排序在链表中的...
快排函数的调用qsort();
01-06
1.快排函数的介绍： 快速排序（Quicksort）是对冒泡排序的一种改进。也是最快的一种排序算法。 2.核心思想： 快速排序算法通过多次比较和交换来实现排序，其排序流程如下：  (1)首先设定一个分界值，通过该分界值将...
C语言快速排序函数用法（qsort）
08-29
C语言快速排序函数用法（qsort） C语言中的快速排序函数qsort是C标准库中的一部分，提供了对数...* 了解如何使用qsort函数对各种类型的数组进行排序。 通过学习qsort函数，可以提高自己的编程技能和解决问题的能力。
c语言学习之排序 数据结构 链表 堆排序 希尔排序 快速排序 递归排序
06-23
"C语言学习之排序数据结构链表堆排序希尔排序快速排序递归排序" 本资源主要介绍了C语言中的排序算法，包括链表、堆排序、希尔排序、快速排序和递归排序等五种方法。同时，文章还提供了每种排序方法的原理、流程图和...
C语言中使用快速排序算法对元素排序的实例详解
01-20
调用C语言的快速排序算法qsort(); #include #include #include #define SIZE 100 //从小到大排序 int comp1(const void *x,const void *y) { return *(int *)x - *(int *)y; } //从大到小排序 int comp2(const ...
牛客网：C++面试宝典——算法与数据结构（3）数组 （4）排序 （5）哈希
Vermouth_Su的博客
04-27 267
● 请你回答一下Array&List， 数组和链表的区别 区别 数组 链表 内存 在内存中，数组是一块连续的区域。 在内存中可以存在任何地方，不要求连续。 数组需要预留空间，在使用前要先申请占内存的大小，可能会浪费内存空间。 不指定大小 插入、删除 插入数据和删除数据效率低，插入数据时，这个位置后面的数据在内存中都要向后移。删除...
哈希之数组作为哈希key值-力扣49
blank_koko的博客
08-15 182
这样，每个元素的哈希值都会被依次加入到累加结果中。最终，累加结果将作为这个数组的哈希值返回。给你一个字符串数组，请你将 字母异位词 组合在一起。，以满足unordered_map或unordered_set等数据结构的要求。字母异位词 是由重新排列源单词的所有字母得到的一个新单词。类型的数组作为参数，并返回一个size_t类型的哈希值。算法对数组元素进行累加，并执行自定义的哈希算法。调用哈希函数对象来获取其哈希值，然后将累加结果左移一位。的哈希函数对象，用于对数组元素执行哈希操作。表示累加结果的初始值，
【力扣刷题笔记】中级算法
qq_42885227的博客
08-22 354
力扣中级算法精选题目笔记
《LeetCode之每日一题》:94.面试题 10.02. 变位词组
MerryMaking7946的博客
07-18 292
面试题 10.02. 变位词组有关题目题解 题目链接：面试题 10.02. 变位词组 有关题目 题解
LeetCode系列49—字母异位词分组
fkuner的博客
09-01 174
题意 49. 字母异位词分组 题解 方法一：排序 class Solution { public: vector<vector<string>> groupAnagrams(vector<string>& strs) { unordered_map<string, vector<string>> mp; for (string& str: strs) { string
qsort()
你就是根号四的博客
02-04 4860
qsort用法--完整版(解释了cmp)【转】 原文地址：http://hi.baidu.com/xuhanqiu/item/99505e41aeef4eae61d7b916 用qsort快两年的时候了,却一直没有真正弄懂cmp函数的返回值1,-1,0的函数. 今天在做凸包时,郁闷了....所以请教了snoopy,终于弄懂了cmp返回值的意识: int cmp(const v
比较器-各个数据结构的应用（c语言中的qsort函数）
jeanlu的博客
03-28 827
 qsort()函数实现的是c语言库的快排功能，由于额外空间的处理，相比自己写的更为优化。  注释：自己写的快排由于额外空间冗余，实际运行时会出现超出限制的报错。 一、 一维 qsort调用所包含的头文件 & 函数原型： #include <stdlib.h> void qsort(void* base, size_t num, size_t size, int (*com...
C语言使用qsort函数对链表排序
05-18
C语言的qsort函数只能对数组进行排序，对于链表的排序可以使用其他算法，比如插入排序或归并排序。 以下是使用插入排序对链表进行排序的示例代码： ```c #include #include typedef struct Node { int value; ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值