循环队列 链式队列 哈希表 折半查找

最新推荐文章于 2024-08-05 17:54:35 发布
最新推荐文章于 2024-08-05 17:54:35 发布
阅读量50 收藏
点赞数
文章标签： 散列表 c++ c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_49024667/article/details/129676258
版权

head.h

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAXSIZE 10
typedef int datatype;
typedef struct
{
	datatype data[MAXSIZE];
	int front;
	int rear;
}* queue,queuelist;
queue create();
typedef struct Node
{
	union
	{
		int len;
		datatype data;
	};
	struct Node * next;
}*Linklist;
typedef struct
{
	Linklist front;
	Linklist rear;
}*Linkque,Queue;

void menu1(queue q);
void menu2(queue q);
void menu3(Linkque que);
int enqueue(queue q,datatype e);
int dequeue(queue q);
void Output1(queue q);
int loop_enqueue(queue q,datatype e);
int loop_dequeue(queue q);
void loop_Output1(queue q);
Linkque Create_Node();
Linklist Create_node();
int Linkque_enhead(Linkque que,datatype e);
int Linkque_de(Linkque que);
void Linkque_Output(Linkque que);
int search_half(int arr[],int low,int high,int key);

main.c

include "head8.h"
int main(int argc, const char *argv[])
{
	queue q=create();
	Linkque que=Create_Node();
	while(1)
	{
		puts("\t-------------------------");
		puts("\t1,顺序队列");
		puts("\t2,循环队列");
		puts("\t3,链式对列");
		puts("\t4,折半查找");
		puts("\t0,退出程序");
		int num;
		printf("请输入你的选择:");
		scanf("%d",&num);
		switch(num)
		{
		case 1:q->front=q->rear;
			menu1(q);
			break;
		case 2:q->front=q->rear;
			menu2(q);
			break;
		case 3: 
			menu3(que);
			int que=free_space(que);
			break;
		case 4:
			{
			int arr[]={10,20,1,11,31,45,12};
			int len;
			len=sizeof(arr)/sizeof(int);
				int key;
			printf("请输入需要查找的值");
			scanf("%d",&key);
	    	int sub=search_half(arr,0,len-1,key);
		   if(sub==-1)
	    	{
			printf("查找不存在");
	    	}
	    	else
	     	{
			printf("下标为%d\n",sub);
		    }
			}
			break;
		case 0:
			return 0;
		default:printf("输入错误,请重新输入:");
			break;
		}
			
	}
	return 0;
}

test.c

#include "head8.h"
queue create()
{
	queue q=(queue)malloc(sizeof(queuelist));
	if(q==NULL)
		return NULL;
	q->front=q->rear=0;
	return q;
}
void menu1(queue q)
{
	datatype e; 
	while(1)
	{
		puts("\t---------------------------");
		puts("\t1,顺序队列入队");
		puts("\t2,顺序队列删除");
		puts("\t3,顺序队列遍历");
		puts("\t0,返回上一级菜单");
		int num;
		printf("请输入你的选择");
		scanf("%d",&num);
		switch(num)
		{

		case 1:	printf("请输入值");
				scanf("%d",&e);
		     	enqueue(q,e);
			  	break;
		case 2:dequeue(q);
			break;
		case 3:Output1(q);
			break;
		case 0:
			return;
		default:printf("输入错误,请重新输入:");
			break;
		}

	}
}
void menu2(queue q)
{
	datatype e;
	while(1)
	{
		puts("\t---------------------------");
		puts("\t1,循环队列入队");
		puts("\t2,循环队列删除");
		puts("\t3,循环队列遍历");
		puts("\t0,返回上一级菜单");
		int num;
		printf("请输入你的选择");
		scanf("%d",&num);
		switch(num)
		{
		case 1:printf("请输入要输入的值:");
			   scanf("%d",&e);
			loop_enqueue(q,e);
			break;
		case 2:loop_dequeue(q);
			break;
		case 3: loop_Output1(q);
			break;
		case 0:
			return;
		default:printf("输入错误,请重新输入:");
			break;
		}
	}
}
void menu3(Linkque que)
{
	datatype e;
	while(1)
	{
		puts("\t---------------------------");
		puts("\t1,链式队列入队");
		puts("\t2 链式队列删除");
		puts("\t3 链式队列遍历");
		puts("\t0,返回上一级菜单");
		int num;
		printf("请输入你的选择");
		scanf("%d",&num);
		switch(num)
		{
		case 1:
			printf("请输入要输入的值");
			scanf("%d",&e);
			Linkque_enhead(que,e);
			break;
		case 2:Linkque_de(que);
			break;
		case 3:Linkque_Output(que);
			break;
		case 0:
			return;
		default:printf("输入错误,请重新输入:");
			break;
		}
	}
}
//顺序队列入队
int enqueue(queue q,datatype e)
{
	if(q->rear==MAXSIZE||q==NULL)
	{
		printf("队列已满\n");
		return -1;
	}
	q->data[q->rear++]=e;
	return 0;
}
//顺序队列删除(出队)
int dequeue(queue q)
{
	if(q->front==q->rear||q==NULL)
	{
		printf("队列为空\n");
		return -1;
	}
	printf("出队的元素是:%d\n",q->data[q->front++]);
	return 0;
}
//顺序队列遍历
void Output1(queue q)
{
	if(q->front==q->rear)
	 	printf("遍历为空");
	for(int i=q->front;i<q->rear;i++)
	{
		printf("%d\t",q->data[i]);
	}
	printf("\n");
}
//循环队列入队
int loop_enqueue(queue q,datatype e)
{
	if((q->rear+1)%MAXSIZE==q->front||q==NULL)
	{
		printf("队列已满\n");
		return -1;
	}
	q->data[q->rear]=e;
	q->rear=(q->rear+1)%MAXSIZE;
	return 0;
}
//循环队列删除(出队)
int loop_dequeue(queue q)
{
	if(q->front==q->rear||q==NULL)
	{
		printf("队列为空\n");
		return -1;
	}
	printf("出队的元素是:%d\n",q->data[q->front]);
	q->front=(q->front+1)%MAXSIZE;
	return 0;
}
//循环队列遍历
void loop_Output1(queue q)
{
	if(q->front==q->rear)

	{
	 	printf("遍历为空");
		return;
	}
	for(int i=q->front;i!=q->rear;i=(i+1)%MAXSIZE)
	{
		printf("%d\t",q->data[i]);
	}
	printf("\n");
}
//申请堆区空间
Linkque Create_Node()
{
	Linkque que=(Linkque)malloc(sizeof(Queue));
	if(que==NULL)
		return NULL;
	Linklist L=(Linklist)malloc(sizeof(struct Node));
	if(L==NULL)
		return NULL;
	L->len=0;
	L->next=NULL;
	que->front=L;
	que->rear=L;

	return que;
}
Linklist Create_node()
{
	Linklist p=(Linklist)malloc(sizeof(struct Node));
	if(p==NULL)
		return NULL;
	p->data=0;
	p->next=NULL;
	return p;
}
//链式队列入队
int Linkque_enhead(Linkque que,datatype e)
{
	if(que==NULL)
		return -1;
	Linklist p=Create_node();
	if(p==NULL)
		return -1;
	p->data=e;
	que->rear->next=p;
	que->rear=p;
	que->front->len++;
	return 0;
}
//链式队列删除
int Linkque_de(Linkque que)
{
	if(que==NULL||que->front==que->rear)
		return -1;
	if(que->front->next==que->rear)
		que->rear=que->front;
	Linklist s=que->front->next;
	printf("出队的元素是%d\n",s->data);
	que->front->next=s->next;
	free(s);
	s=NULL;
	que->front->len--;
	return 0;
}
//链式队列的遍历
void Linkque_Output(Linkque que)
{
	if(que->front==que->rear)
	{
		printf("遍历为空");
		return;
	}
	Linklist p=que->front;
	while(p->next!=NULL)
	{
		p=p->next;
		printf("%d\t",p->data);
	}
}
//折半查找
int search_half(int arr[],int low,int high,int key)
{
	int mid;
	while(low<=high)
	{
		mid=(low+high)/2;
		if(arr[mid]<key)
		{
			low=mid+1;
		}
		else if(arr[mid]>key)
		{
			high=mid-1;
		}
		else if(arr[mid]==key)
		{
			return mid;
		}
	}
 return -1;
}
//链式对列的空间释放
Linkque free_space(Linkque que)
{
	if(que==NULL)
		return NULL;
	int n=que->front->len;
	for(int i=0;i<n;i++)
	{
		Linkque_de(que);
	}
	free(que->front);
	que->front=NULL;
	free(que);
	que=NULL;
	return que;
}

head2.h


#ifndef __HEAD_H__
#define __HEAD_H__
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct Node
{
	int data;
	struct Node *next;
}*node;

int p;
void Init(node hash[],int Hash_len);
int max_prime(int m);
int insert_hash(int key,node hash,int Hash_len);
void Output(node hash,int Hash_len);
void search(int key,node hash[]);


#endif

main2.c

#include "head9.h"
int main(int argc, const char *argv[])
{
	int arr[]={1,22,199,20,30,356,223,1244};
	int len=sizeof(arr)/sizeof(int);
	//哈希表的长度
	int Hash_len=len*4/3;
	node hash[Hash_len];//指针数组
	Init(hash,Hash_len);//初始化哈希表
	for(int i=0;i<len;i++)
	{
		insert_hash(arr[i],hash,Hash_len);
	}
	Output(hash,Hash_len);
	int key;
	printf("请输入你要查找的值:");
	scanf("%d",&key);
	search(key,hash);
	return 0;
}

test2.c

#include "head9.h"
void Init(node hash[],int Hash_len)
{
	for(int i=0;i<Hash_len;i++)
	{
		hash[i]=NULL;
	}
}
//找到最大的素数
int max_prime(int Hash_len)
{
	for(int i=Hash_len;i>=2;i--)
	{
		int count=0;
		for(int j=1;j<i;j++)
		{
			if(i%j==0)
				count++;
		}
		if(count==2)
			return i;
	}
}
//把数组元素存储到哈希表中
int insert_hash(int key,node hash,int Hash_len)
{
	p=max_prime(Hash_len);
	int sub=key%p;
	//在hash[sub]中头插
	node s=(node)malloc(sizeof(struct Node));
	//s的数据域
	s->data=key;
	s->next=hash[sub];
	hash[sub]=s;
}
//哈希表遍历
void Output(node hash,int Hash_len)
{
	for(int i=0;i<hash;i++)
	{
		printf("%d",i);
		node p=hash[i];
		while(p!=NULL)
		{
			printf("%d\t",p->data);
			p=p->next;
		}
		printf("\n");
	}
}
//哈希查找
void search(int key,node hash[])
{
	int sub=key%p;
	node q=hash[sub];
	while(q!=NULL)
	{
		if(q->data==key)
		{
			printf("存在你要查找的值");
			return;
		}
		q->next;
	}
	printf("值不存在");
}

小白的大神梦
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据结构--链式队列、查找
qq_40084570的博客
06-18 1411
队列的链式表示称为链队列，它实际上是一个同时带有队头指针和队尾指针的单链表。头指针指向队头结点，尾指针指向队尾结点，即单链表的最后一个结点。 队列的链式存储类型可描述为 typedef struct {//链式队列结点 ElemType data; struct LinkNode *next; }LinkNode; typedef struct { LinkNode *front, *rear;//队列的队头和队尾指针 }LinkQueue; 当Q.front和Q.rear
哈希表的画法_复习知识点参考：
weixin_31109487的博客
12-31 1954
第二章：线性表(重点)一．顺序表(也就是数组)p22插入删除时，注意移动元素的顺序(从尾开始or从插入位置开始)二．链表p27插入删除时，注意指针的赋值顺序。三．静态链表：并非链表，而是用顺序表模拟链表，(了解即可，表插入排序)p32四．单循环链表+双向链表p35：注意存储结构的表示、查找是否完成的标志，1.主要复习(顺序+链式)：初始化、查找、插入、删除。2.熟记两个(顺序+链式)存储结构表...
循环链表(双链表法&哈希表法)
qq_29494693的博客
03-11 218
题目 给定一个链表，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。 为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。注意，pos 仅仅是用于标识环的情况，并不会作为参数传递到函数中。 说明：不允许修改给定的链表。 进阶： 你是否可以使用 O(1) 空间解决此题？ 代码 双指针法 思路： fast每次走2步，slow每次走1步; 设f为fast走的步数，s为slow走的步数，a为走
顺序队列，循环队列，链式队列，哈希表，折半查找
qianyaner_的博客
03-20 32
顺序队列：空间申请，入队，出队，遍历 循环队列：空间申请，入队，出队，遍历，元素个数 链式队列：空间申请，入队，出队，遍历 哈希表 折半查找
队列和哈希表的算法实现
m0_67100121的博客
03-20 48
哈希表 队列
嵌入书学习day18(栈,队列,哈希查找)
m0_37565374的博客
03-20 99
栈,队列,哈希查找的学习
【C语言】数据结构：数组，链表，栈，队列，树
airyv的博客
12-19 2667
3 线性结构 3.1 【数组】连续存储 1、什么叫做数组 元素类型相同，大小相等（数组传参，只要传进去首地址和长度就行） 2、数组的优缺点（相对于链表）： 优点： 存取速度快 缺点： 事先必须知道数组的长度 插入删除元素很慢 空间通常是有限制的 需要大块连续的内存块 插入删除元素的效率很低 定义一个数组至少需要3个参数：首地址，长度，有效个数。 用指针自己定义一个数组： # include <stdio.h> # include <malloc.h>
哈希表 相关笔试题
热门推荐
小旋锋 的博客
09-11 1万+
牛客网专项练习题 哈希表的平均查找长度与处理冲突的方法无关()A. 对 B. 错 正确答案: B [摘抄] 哈希表在查找过程中进行比较的关键字个数取决于哈希函数，处理冲突的方法和哈希表的装填因子，哈希表的装填因子标志哈希表的装满程度，与哈希表的长度有直接联系。 有B+Tree/Hash_Map/STL Map三种数据结构。对于内存中数据，查找性能较好的数据结构是（），对于磁盘中数据，
【链表】练习题
m0_63077733的博客
12-25 710
学习数据结构期间做的题目
07.递归的折半查找.wmv（目前数据结构最好的视频,共42集，需要哪一集的知识自己下，一集3积分）
03-13
17循环链表 18双项链表 19链式栈 20链式队列 21STL_list类 22基数排序 23属 24二叉树 25二叉树找数 26红黑树 27红黑树_0 28红黑树_1 29红黑树_2 30红黑树_3 31红黑树_4 32红黑树_5 33红黑树_6 34堆 35堆排序 36...
20.链式队列.wmv（目前数据结构最好的视频,共42集，需要哪一集的知识自己下，一集3积分）
03-13
17循环链表 18双项链表 19链式栈 20链式队列 21STL_list类 22基数排序 23属 24二叉树 25二叉树找数 26红黑树 27红黑树_0 28红黑树_1 29红黑树_2 30红黑树_3 31红黑树_4 32红黑树_5 33红黑树_6 34堆 35堆排序 36...
17.循环链表.wmv（目前数据结构最好的视频,共42集，需要哪一集的知识自己下，一集3积分）
03-13
17循环链表 18双项链表 19链式栈 20链式队列 21STL_list类 22基数排序 23属 24二叉树 25二叉树找数 26红黑树 27红黑树_0 28红黑树_1 29红黑树_2 30红黑树_3 31红黑树_4 32红黑树_5 33红黑树_6 34堆 35堆排序 36...
01.交换算法.wmv （共42集，需要哪个算法下哪个）
03-12
17循环链表 18双项链表 19链式栈 20链式队列 21STL_list类 22基数排序 23属 24二叉树 25二叉树找数 26红黑树 27红黑树_0 28红黑树_1 29红黑树_2 30红黑树_3 31红黑树_4 32红黑树_5 33红黑树_6 34堆 35堆排序 36...
【C语言】Top K问题【建小堆】
2301_80840905的博客
08-04 476
在我们生活中，经常会遇到TopK问题。建小堆解决
C++ STL copy, move 用法
08-04 226
前向（从前向后的顺序）拷贝/移动操作，将一个容器元素拷贝/移动到另一容器中。
【C++】输入输出
2401_83948390的博客
08-02 531
在C++中，输入输出操作主要通过标准库中的iostream头文件提供的一系列对象和函数来完成。
OD C卷 - 中庸行者
weixin_45228198的博客
08-04 187
DFS
c++——map、set底层之AVL树（动图演示旋转）
最新发布
2301_80687320的博客
08-05 772
我们之前学了过二叉搜索树，二这里的AVL也是一种搜索树，当我们二叉搜索树发生偏移时，搜索时间就会边长，就不树logN了，变成N；而AVL就修复了这一点。一、{}// 该节点的左孩子// 该节点的右孩子// 该节点的双亲T _data;int _bf;// 该节点的平衡因子。
哈希表查找与冲突解决策略
"哈希表查找的介绍及冲突解决策略" 哈希表，又被称为散列表，是一种数据结构，它提供了快速的查找、插入和删除操作。哈希表的查找效率高，通常能达到常数级别的平均时间复杂度，这是因为哈希表通过一种特殊的函数...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值