1>循环队列
2>链式队列
3>折半查找
4>哈希查找
#ifndef __HEAD1_H__
#define __HEAD1_H__
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAXSIZE 50
typedef int datatype;
typedef struct
{
//数据元素
datatype data[MAXSIZE];
//队头
int front;
//队尾
int rear;
}*queue,queuelist;
queue create();
int enter_queue(queue q,datatype e);
int exit_queue(queue q);
void output1(queue q);
int loop_enterqueue(queue q,datatype e);
int loop_exitqueue(queue q);
void output2(queue q);
void menu1(queue q);
void menu2(queue q);
//定义结点结构体
typedef struct Node
{
union{
int len;
datatype data;
};
struct Node* next;
}*Linkedlist;
//定义结构体QFR存放队列首尾地址
typedef struct QFR
{
Linkedlist front;
Linkedlist rear;
}*Linkedlistqueue;
Linkedlistqueue create_q1();
Linkedlist create_node();
int Linkedlist_enterqueuequeue(Linkedlistqueue q1,datatype e);
int Linkedlist_exitqueue(Linkedlistqueue q1);
void output3(Linkedlistqueue q1);
void menu3(Linkedlistqueue q1);
//定义哈希表结构体
typedef struct Node1
{
int data;
struct Node1 *next;
}*node;
void Init(node hash[],int hash_len);
int max_prime(int m);
int insert_hash(int key,node hash[],int m);
void output_hash(node hash[],int hash_len);
void search(int key,node hash[]);
#endif
#include "head1.h"
/*
* function: 创建队列在堆区
* @param [ in]
* @param [out]
* @return 成功返回地址 失败返回NULL
*/
queue create()
{
queue q=(queue)malloc(sizeof(queuelist));
if(q==NULL)
return NULL;
q->front=q->rear=0;
return q;
}
/*
* function: 入队
* @param [ in] 队列 值
* @param [out]
* @return 成功返回0 失败返回-1
*/
int enter_queue(queue q,datatype e)
{
//判满
//判断队列是否存在
if(q->rear==MAXSIZE||q==NULL){
printf("队满\n");
return -1;
}
//入队
q->data[q->rear++]=e;
return 0;
}
/*
* function: 出队
* @param [ in] 队列
* @param [out]
* @return 成功返回0 失败返回-1
*/
int exit_queue(queue q)
{
//判空
//判断队列是否存在
if(q->front==q->rear||q==NULL){
printf("队空\n");
return -1;
}
//出队
printf("出队的元素是:%d\n",q->data[q->front++]);
return 0;
}
/*
* function: 顺序队列遍历
* @param [ in] 队列
* @param [out]
* @return
*/
void output1(queue q)
{
//队列的遍历
if(q->front==q->rear)
printf("队空\n");
int i;
printf("输出为:\n");
for(i=q->front;i<q->rear;i++){
printf("%d\t",q->data[i]);
}
putchar('\n');
}
/*
* function: 顺序队列菜单
* @param [ in]
* @param [out]
* @return
*/
void menu1(queue q)
{
datatype e;
while(1){
puts("******************");
puts("1.顺序队列入队");
puts("2.顺序队列删除");
puts("3.顺序队列遍历");
puts("0.返回上一级菜单");
int num;
printf("请输入你的选择:");
scanf("%d",&num);
switch(num){
case 1:
printf("请输入要入队的值:");
scanf("%d",&e);
enter_queue(q,e);
break;
case 2:
exit_queue(q);
break;
case 3:
output1(q);
break;
case 0:printf("已返回上一级菜单\n");
return;
}
}
}
/*
* function: 入队
* @param [ in] 队列 值
* @param [out]
* @return 成功返回0 失败返回-1
*/
int loop_enterqueue(queue q,datatype e)
{
//判满
//判断队列是否存在
if(q->front==(q->rear+1)%MAXSIZE||q==NULL){
printf("队满\n");
return -1;
}
//入队
q->data[q->rear]=e;
q->rear=(q->rear+1)%MAXSIZE;
return 0;
}
/*
* function: 出队
* @param [ in] 队列
* @param [out]
* @return 成功返回0 失败返回-1
*/
int loop_exitqueue(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;
}
/*
* function: 循环队列遍历
* @param [ in] 队列
* @param [out]
* @return
*/
void output2(queue q)
{
//队列的遍历
if(q->front==q->rear)
printf("队空\n");
int i;
printf("结果为:\n");
for(i=q->front;i!=q->rear;i=(i+1)%MAXSIZE){
printf("%d\t",q->data[i]);
}
putchar('\n');
}
/*
* function: 循环队列菜单
* @param [ in]
* @param [out]
* @return
*/
void menu2(queue q)
{
datatype e;
while(1){
puts("******************");
puts("1.循环队列入队");
puts("2.循环队列删除");
puts("3.循环队列遍历");
puts("0.返回上一级菜单");
int num;
printf("请输入你的选择:");
scanf("%d",&num);
switch(num){
case 1:
printf("请输入入队的值:");
scanf("%d",&e);
loop_enterqueue(q,e);
break;
case 2:
loop_exitqueue(q);
break;
case 3:
output2(q);
break;
case 0:
printf("已返回上一级菜单\n");
return;
}
}
}
/*
* function: 链式队列的创建
* @param [ in]
* @param [out]
* @return 成功返回首地址 失败返回NULL
*/
Linkedlistqueue create_q1()
{
Linkedlistqueue q1=(Linkedlistqueue)malloc(sizeof(struct QFR));
if(q1==NULL)
return NULL;
Linkedlist L=(Linkedlist)malloc(sizeof(struct Node));
L->len=0;
L->next=NULL;
q1->front=L;
q1->rear=L;
return q1;
}
Linkedlist create_node()
{
Linkedlist p=(Linkedlist)malloc(sizeof(struct Node));
if(p==NULL)
return NULL;
p->data=0;
p->next=NULL;
return p;
}
/*
* function: 链式队列入队
* @param [ in] 队列 值
* @param [out]
* @return 成功返回0 失败返回-1
*/
int Linkedlist_enterqueue(Linkedlistqueue q1,datatype e)
{
if(q1==NULL)
return -1;
Linkedlist p=create_node();
if(p==NULL)
return -1;
p->data=e;
q1->rear->next=p;
q1->rear=p;
q1->front->len++;
}
/*
* function: 输出
* @param [ in] 队列
* @param [out]
* @return
*/
void output3(Linkedlistqueue q1)
{
Linkedlist p=q1->front;
printf("结果为:");
while(p->next!=NULL){
p=p->next;
printf("%d\t",p->data);
}
putchar('\n');
}
/*
* function: 链式队列删除
* @param [ in] 队列
* @param [out]
* @return 成功返回0 失败返回-1;
*/
int Linkedlist_exitqueue(Linkedlistqueue q1)
{
if(q1==NULL||q1->front->len==0)
return -1;
if(q1->front->next==q1->rear)
q1->rear=q1->front;
Linkedlist s=q1->front->next;
printf("输出的元素为:%d\n",s->data);
q1->front->next=s->next;
free(s);
s=NULL;
q1->front->len--;
return 0;
}
/*
* function: 链式队列菜单
* @param [ in]
* @param [out]
* @return
*/
void menu3(Linkedlistqueue q1)
{
datatype e;
while(1){
puts("******************");
puts("1.链式队列入队");
puts("2.链式队列删除");
puts("3.链式队列遍历");
puts("0.返回上一级菜单");
int num;
printf("请输入你的选择:");
scanf("%d",&num);
switch(num){
case 1:
printf("请输入入队的值:");
scanf("%d",&e);
Linkedlist_enterqueue(q1,e);
break;
case 2:
Linkedlist_exitqueue(q1);
break;
case 3:
output3(q1);
break;
case 0:printf("已返回上一级菜单\n");
return;
}
}
}
/*
* function: 降序折半查找
* @param [ in] 数组 最大下标 最小下标
* @param [out]
* @return 成功返回下标 失败返回-1
*/
int binary_search(int arr[],int low,int high,int key)
{
int mid;
while(low<=high){
mid=(low+high)/2;
if(arr[mid]<key)
high=mid-1;
else if(arr[mid]>key)
low=mid+1;
else if(arr[mid]==key)
return mid;
}
return -1;
}
/*
* function: 释放链式队列空间
* @param [ in] 链式队列
* @param [out]
* @return 返回NULL
*/
Linkedlistqueue free_space(Linkedlistqueue q1)
{
if(q1==NULL)
return NULL;
int n=q1->front->len;
int i;
for(i=0;i<n;i++){
Linkedlist_exitqueue(q1);
}
free(q1->front);
q1->front=NULL;
free(q1);
q1=NULL;
return q1;
}
/*
* function: 对哈希表初始化
* @param [ in] 哈希表
* @param [out]
* @return
*/
void Init(node hash[],int hash_len)
{
int i;
for(i=0;i<hash_len;i++){
hash[i]=NULL;
}
}
/*
* function: 计算最大素数
* @param [ in]
* @param [out]
* @return 返回最大素数
*/
int max_prime(int m)
{
int i,j;
for(i=m;i>=2;i--){
int count=0;
//循环素数的所有约数
for(j=1;j<=i;j++){
if(0==i%j)
count++;
}
if(2==count)
return i;
}
}
/*
* function: 把数组元素存到哈希表
* @param [ in] 元素 哈希表
* @param [out]
* @return
*/
int insert_hash(int key,node hash[],int m)
{
//构造哈希函数H(key)%p(p<m)
//计算最大素数的函数
int p;
p=max_prime(m);
int sub=key%p;
//在hash[sub]头插
node s=(node)malloc(sizeof(struct Node1));
s->data=key;
s->next=hash[sub];
hash[sub]=s;
}
/*
* function: 哈希表遍历
* @param [ in] 哈希表 表长
* @param [out]
* @return
*/
void output_hash(node hash[],int hash_len)
{
int i,p;
for(i=0;i<hash_len;i++){
printf("%d:",i);
node p=hash[i];
while(NULL!=p){
printf("\t%d",p->data);
p=p->next;
}
printf("\n");
}
}
/*
* function: 哈希查找
* @param [ in] 查找的元素 哈希表
* @param [out]
* @return
*/
void search(int key,node hash[])
{
int p;
int sub=key%p;
node q=hash[sub];
while(NULL!=q){
if(q->data==key){
printf("存在查找的值\n");
return;
}
q=q->next;
}
printf("不存在查找的值\n");
}
#include "head1.h"
#include "test1.c"
int main(int argc, const char *argv[])
{
while(1){
puts("*********************");
puts("1.顺序队列");
puts("2.循环队列");
puts("3.链式队列");
puts("4.折半查找");
puts("5.哈希查找");
puts("0.退出程序");
int num;
printf("请输入你的选择:");
scanf("%d",&num);
switch(num){
case 1:{
queue q=create();
//清空队列
q->front=q->rear=0;
menu1(q);
free(q);
q=NULL;
break;
}
case 2:{
queue q=create();
//清空队列
q->front=q->rear=0;
menu2(q);
free(q);
q=NULL;
break;
}
case 3:{
Linkedlistqueue q1=create_q1();
menu3(q1);
q1=free_space(q1);
break;
}
case 4:{
int arr[]={9,8,7,6,5,4,3,2,1};
int len=sizeof(arr)/sizeof(int);
int key;
printf("请输入查找的值:");
scanf("%d",&key);
int sub=binary_search(arr,0,len-1,key);
if(sub==-1)
printf("查找的元素不存在\n");
else
printf("在下标%d\n",sub);
break;
}
case 5:{
int arr[]={244,17,169,45,9999,44,46,74,77};
int len=sizeof(arr)/sizeof(arr[0]);//计算数组长度
//哈希表长为数组长度乘以4除以3
int hash_len=len*4/3;
node hash[hash_len];//指针数组
Init(hash,hash_len);//对哈希表初始化为NULL
int i;
for(i=0;i<len;i++){
//把arr[i]存到哈希表中
insert_hash(arr[i],hash,hash_len);
}
//遍历
output_hash(hash,hash_len);
int key;
printf("请输入查找的元素:");
scanf("%d",&key);
search(key,hash);
break;
}
case 0:return 0;
default:{
printf("输入错误,请重新输入\n");
break;
}
}
}
return 0;
}