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

最新推荐文章于 2024-07-10 14:52:21 发布
最新推荐文章于 2024-07-10 14:52:21 发布
阅读量31 收藏
点赞数
文章标签： c语言 数据结构 Powered by 金山文档
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qianyaner_/article/details/129675063
版权

顺序队列，循环队列,链式队列

head.h

#ifndef __QUEUE_H__
#define __QUEUE_H__

#include<stdio.h>
#include<stdlib.h>
#include<string.h>

#define MAXSIZE 4

typedef int datatype;

typedef struct{
    datatype data[MAXSIZE];
    //队头
    int front;
    //队尾
    int rear;
}*Queue,queuelist;

Queue Creat_space();
void menu1();
int Enqueue(Queue q,datatype e);
int Dequeue(Queue q);
void Output_queue(Queue q);

void menu2();
int Enqueue_loop(Queue q,datatype e);
int Dequeue_loop(Queue q);
void Output_loop(Queue q);
int len(Queue q);

typedef struct Node{
    union{
        int len;
        datatype data;
    };
    struct Node* next;
}*queuenode;

typedef struct{
    queuenode front;
    queuenode rear;
}*Linkqueue,link_queue;

void menu3();
Linkqueue creat_head();
queuenode creat_node();
int Enqueue_Link(Linkqueue qhead,datatype e);
void Output_queue_Link(Linkqueue qhead);
int Dequeue_Link(Linkqueue qhead);
Linkqueue free_Linlqueue(Linkqueue qhead);
#endif

main.c

#include"queue.h"

int main(int argc,const char *argv[])
{
    int num=0;
    
//顺序队列定义
    //申请空间
    Linkqueue qhead=creat_head();

    while(1){
        puts("------------------------------");
        puts("\t队列的操作：");
        puts("\t1、顺序队列");
        puts("\t2、循环队列");
        puts("\t3、链式队列");
        puts("\t0、退出程序");
        printf("请输入操作：");
        scanf("%d",&num);
        switch(num){
        case 0:return 0;
        case 1:
               menu1();
               break;
        case 2:
               menu2();
               break;
        case 3:
               menu3(qhead);
               qhead=free_Linlqueue(qhead);
               break;
        default:
               printf("输入操作错误，请重新输入\n");
        }
    }

    return 0;
}

txt.c

#include"queue.h"

/*
 *function :  申请空间
 *@param [in]:  无参数
 *@param [out]:
 *@return :  成功返回申请的空间的地址，失败返回NULL
 */
Queue Creat_space(){
    Queue q=(Queue)malloc(sizeof(queuelist));
    if(q==NULL)
        return NULL;
    q->front=q->rear=0;
    return q;
}

/*
 *function :  顺序队列菜单
 *@param [in]:  顺序队列
 *@param [out]:
 *@return :  
 */
void menu1(){
    int num=0;
    datatype e;
    int flag=0;

    Queue q=Creat_space();
    
    while(1){
        puts("********************************");
        puts("\t顺序队列的操作：");
        puts("\t1、顺序队列入队");
        puts("\t2、顺序队列出队");
        puts("\t3、顺序队列的遍历");
        puts("\t0、返回上一级菜单");
        printf("请输入操作：");
        scanf("%d",&num);
        switch(num){
        case 0:
            free(q);
            q=NULL;
            printf("已经返回上一级菜单\n");
            return;
        case 1:
            printf("请输入入队的元素：");
            scanf("%d",&e);
            flag=Enqueue(q,e);
            if(flag==-1)
                printf("队满，顺序队列入队失败\n");
            break;
        case 2:
            flag=Dequeue(q);
            if(flag==-1)
                printf("队空，顺序队列出队失败\n");
            break;
        case 3:
            Output_queue(q);
            break;
        default:
            printf("输入操作错误，请重新输入\n");
            break;
        }
    }
}

/*
 *function :  顺序队列入队
 *@param [in]: 顺序队列，入队的元素
 *@param [out]:
 *@return :  成功返回0，失败返回-1
 */
int Enqueue(Queue q,datatype e){
    //判满
    if(q->rear==MAXSIZE||q==NULL)
        return -1;
    q->data[q->rear++]=e;
    return 0;
}

/*
 *function :  顺序队列出队
 *@param [in]:  顺序队列
 *@param [out]:
 *@return :  成功返回0，失败返回-1
 */
int Dequeue(Queue q){
    //判空
    if(q->front==q->rear)
        return -1;
    printf("出队的元素为：%d\n",q->data[q->front++]);
    return 0;
}

/*
 *function :  顺序队列的遍历
 *@param [in]:  顺序队列
 *@param [out]:
 *@return : 无返回值
 */
void Output_queue(Queue q){
    //判空
    if(q->front==q->rear)
        return;
    for(int i=q->front;i<q->rear;i++){
        printf("%d\t",q->data[i]);
    }
    printf("\n");
}

/*
 *function :  循环队列菜单
 *@param [in]:  循环队列
 *@param [out]:
 *@return :  
 */
void menu2(){
    int num=0;
    datatype e;
    int flag=0;

    Queue q=Creat_space();
    
    while(1){
        puts("********************************");
        puts("\t循环队列的操作：");
        puts("\t1、循环队列入队");
        puts("\t2、循环队列出队");
        puts("\t3、循环队列的遍历");
        puts("\t4、循环队列的元素个数");
        puts("\t0、返回上一级菜单");
        printf("请输入操作：");
        scanf("%d",&num);
        switch(num){
        case 0:
            free(q);
            q=NULL;
            printf("已经返回上一级菜单\n");
            return;
        case 1:
            printf("请输入入队的元素：");
            scanf("%d",&e);
            flag=Enqueue_loop(q,e);
            if(flag==-1)
                printf("队满，循环队列入队失败\n");
            break;
        case 2:
            flag=Dequeue_loop(q);
            if(flag==-1)
                printf("队空，循环队列出队失败\n");
            break;
        case 3:
            Output_loop(q);
            break;
        case 4:
               printf("队列元素个数：%d\n",len(q));
               break;
        default:
            printf("输入操作错误，请重新输入\n");
            break;
        }
    }
}

/*
 *function :  循环队列入队
 *@param [in]:  循环队列，入队的元素
 *@param [out]:
 *@return :  成功返回0，失败返回-1
 */
int Enqueue_loop(Queue q,datatype e){
    //判满
    if(q->front==(q->rear+1)%MAXSIZE||q==NULL)
        return -1;
    q->data[q->rear]=e;
    q->rear=(q->rear+1)%MAXSIZE;
    return 0;
}

/*
 *function :  循环队列出队
 *@param [in]:  循环队列
 *@param [out]:
 *@return :  成功返回0，失败返回-1
 */
int Dequeue_loop(Queue q){
    //判空
    if(q->front==q->rear)
        return -1;
    printf("出队的元素为：%d\n",q->data[q->front]);
    q->front=(q->front+1)%MAXSIZE;
    return 0;
}

/*
 *function :  循环队列的遍历
 *@param [in]:  循环队列
 *@param [out]:
 *@return : 无返回值
 */
void Output_loop(Queue q){
    //判空
    if(q->front==q->rear)
        return;
    for(int i=q->front;i!=q->rear;i=(i+1)%MAXSIZE){
        printf("%d\t",q->data[i]);
    }
    printf("\n");
}

/*
 *function :  循环队列的元素个数
 *@param [in]:  循环队列
 *@param [out]:
 *@return :  
 */
int len(Queue q){
    return(MAXSIZE-q->front+q->rear)%MAXSIZE;
}

/*
 *function :  链式队列菜单
 *@param [in]:  链式队列
 *@param [out]:
 *@return :  
 */
void menu3(Linkqueue qhead){
    int num=0;
    datatype e;
    int flag=0;
    while(1){
        puts("********************************");
        puts("\t链式队列的操作：");
        puts("\t1、链式队列入队");
        puts("\t2、链式队列出队");
        puts("\t3、链式队列的遍历");
        puts("\t0、返回上一级菜单");
        printf("请输入操作：");
        scanf("%d",&num);
        switch(num){
        case 0:
            printf("已经返回上一级菜单\n");
            return;
        case 1:
            printf("请输入入队的元素：");
            scanf("%d",&e);
            flag=Enqueue_Link(qhead,e);
            if(flag==-1)
                printf("链式入队失败\n");
            break;
        case 2:
            flag=Dequeue_Link(qhead);
            if(flag==-1)
                printf("链式出队失败\n");
            break;
        case 3:
            Output_queue_Link(qhead);
            break;
        default:
            printf("输入操作错误，请重新输入\n");
            break;
        }
    }
}

/*
 *function :  链式队列的创建
 *@param [in]:  
 *@param [out]:
 *@return :  成功返回申请的空间的地址，失败返回NULL
 */
Linkqueue creat_head(){
    Linkqueue qhead=(Linkqueue)malloc(sizeof(link_queue));
    if(qhead==NULL)
        return NULL;
    qhead->front=(queuenode)malloc(sizeof(struct Node));
    if(qhead->front==NULL)
        return NULL;
    qhead->rear=qhead->front;
    qhead->front->len=0;
    qhead->front->next=NULL;
    return qhead;
}

/*
 *function :  链式队列普通结点的创建
 *@param [in]:  
 *@param [out]:
 *@return :  成功返回申请的空间的地址，失败返回NULL
 */
queuenode creat_node(){
    queuenode p=(queuenode)malloc(sizeof(struct Node));
    if(p==NULL)
        return NULL;
    p->next=NULL;
    return NULL;
}

/*
 *function :  链式队列入队
 *@param [in]:  链式队列，入队的元素
 *@param [out]:
 *@return :  成功返回0，失败返回-1
 */
int Enqueue_Link(Linkqueue qhead,datatype e){
    if(qhead==NULL)
        return -1;
    //创建新结点
    queuenode s=(queuenode)malloc(sizeof(struct Node));
    if(s==NULL)
        return -1;
    //s的数据域赋值
    s->data=e;
    //s的指针域
    s->next=qhead->rear->next;
    qhead->rear->next=s;
    qhead->front->len++;
    qhead->rear=s;
    return 0;
}

/*
 *function :  链式队列的遍历
 *@param [in]:  链式队列
 *@param [out]:
 *@return :  无返回值
 */
void Output_queue_Link(Linkqueue qhead){
    if(qhead==NULL)
        return;
    queuenode s=qhead->front;
    for(int i=0;i<qhead->front->len;i++){
        s=s->next;
        printf("%d\t",s->data);
    }
    printf("\n");
}

/*
 *function :  链式队列出队
 *@param [in]:  链式队列
 *@param [out]:
 *@return :  成功返回0，失败返回-1
 */
int Dequeue_Link(Linkqueue qhead){
    if(qhead==NULL||qhead->front->len==0)
        return -1;
    if(qhead->front->next==qhead->rear)
        qhead->rear=qhead->front;
    queuenode s=qhead->front->next;
    printf("出队的元素是：%d\n",s->data);
    qhead->front->next=s->next;
    free(s);
    s=NULL;
    qhead->front->len--;
    return 0;
}

/*
 *function :  链式队列空间释放
 *@param [in]:  链式队列
 *@param [out]:
 *@return :  返回NULL
 */
Linkqueue free_Linlqueue(Linkqueue qhead){
    if(qhead==NULL)
        return NULL;
    int n=qhead->front->len;
    for(int i=0;i<n;i++){
        Dequeue_Link(qhead);
    }
    free(qhead->front);
    qhead->front=NULL;
    free(qhead);
    qhead=NULL;
    return NULL;
}

哈希表


#include<stdio.h>
#include<stdlib.h>
#include<string.h>

typedef int datatype;

//定义一个结点结构体
typedef struct Node{
    datatype data;
    struct Node *next;
}*node;

/*
 *function :  初始化哈希表
 *@param [in]:  哈希表,哈希表长
 *@param [out]:
 *@return :  无返回值
 */
void Init_hash(node hash[],int hash_len){
    for(int i=0;i<hash_len;i++){
        hash[i]=NULL;
    }
}

/*
 *function :  找最大质数
 *@param [in]:  哈希表长
 *@param [out]:
 *@return :  返回最大质数,失败返回-1
 */
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;
    }
    return -1;
}

/*
 *function :  将元素放入哈希表
 *@param [in]:  哈希表，元素
 *@param [out]:
 *@return :  无返回值
 */
void insert_hash(node hash[],int e,int hash_len){
    //计算不大于哈希表长的最大质数
    int m=max_prime(hash_len);
    //计算元素对应的下标
    int index=e%m;
    //创建一个新结点
    node s=(node)malloc(sizeof(struct Node));
    //给s结点数据域赋值
    s->data=e;
    //s的指针域
    s->next=hash[index];
    hash[index]=s;
}

/*
 *function :  哈希表遍历
 *@param [in]:  哈希表
 *@param [out]:
 *@return :  无返回值
 */
void Output_hash(node hash[],int hash_len){
    for(int i=0;i<hash_len;i++){
        printf("%d:",i);
        node p=hash[i];
        while(p!=NULL){
            printf("%d\t",p->data);
            p=p->next;
        }
        printf("\n");
    }
}

/*
 *function :  哈希表查询
 *@param [in]:  哈希表，查找元素
 *@param [out]:
 *@return :  无返回值
 */
void search_hash(node hash[],datatype e,int hash_len){
    int index=e%(max_prime(hash_len));
    node p=hash[index];
    while(p){
        if(p->data==e){
            printf("存在该元素\n");
            return ;
        }
        p=p->next;
    }
    printf("不存在该元素\n");
}

int main(int argc,const char *argv[])
{
    int arr[]={11,46,27,55,89,1111,998};
    //计算数组长度
    int len=sizeof(arr)/sizeof(arr[0]);
    //计算哈希长度
    int hash_len=len*4/3;
    //创建一个哈希表，是一个指针数组
    node hash[hash_len];
    //初始化哈希表
    Init_hash(hash,hash_len);
    //将元素放进哈希表
    for(int i=0;i<len;i++){
        insert_hash(hash,arr[i],hash_len);
    }
    //哈希表遍历
    Output_hash(hash,hash_len);
    //哈希查找
    datatype e;
    printf("请输入要查找的数据：");
    scanf("%d",&e);
    search_hash(hash,e,hash_len);
    
    return 0;
}

折半查找

head.h

#ifndef __HEAD_H__
#define __HEAD_H__

#include<stdio.h>
#include<stdlib.h>
#include<string.h>

int half_find(int *p,int num);
#endif

main.c

#include"head.h"
int main(int argc,const char *argv[])
{
    int arr[7]={90,80,70,60,50,40,30};
    int num=0;
    printf("请输入要查找的值：");
    scanf("%d",&num);
    int index=half_find(arr,num);
    if(index==-1)
        printf("没有该元素\n");
    else
        printf("该元素出现的下标为：%d\n",index);
    return 0;
}

txt.c

#include"head.h"

/*
 *function :  折半查找
 *@param [in]:  数组，查找的元素
 *@param [out]:
 *@return :  成功返回下标，失败返回-1
 */
int half_find(int *p,int num){
    int mid,low=0,high=6;
    while(low<=high){
        mid=(low+high)/2;
        if(*(p+mid)>num)
            low=mid+1;
        else if(*(p+mid)<num)
            high=mid-1;
        else
            return mid;
    }
    return -1;
}
qianyaner_
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据结构基础知识概念 数据结构的逻辑结构： 线性表 顺序表 链表 栈和队列 栈的链式存储： 队列的链式存储：
ZJQ的博客
09-17 323
目录 数据结构是什么? 数据结构的存储结构： 线性表 树存储结构 图存储结构 一、基本概念 2、算法的基本概念 二、线性表 三、栈和队列 四、树、二叉树 五、图 六、查找 七、排序 数据结构是什么? 我认为，数据结构是一门学科，它教会我们“如何存储具有复杂关系的数据更有助于后期对数据的再利用”。 数据结构的存储结构： 线性表，还可细分为顺序表、链表、栈和队列； 树结构，包括普通树，二叉树，线索二叉树等； 图存储结构； 线性表 线性表结构...
循环队列 链式队列 哈希表 折半查找
weixin_49024667的博客
03-20 46
【代码】循环队列 链式队列 哈希表 折半查找。
队列和哈希表的算法实现
m0_67100121的博客
03-20 45
哈希表 队列
嵌入书学习day18(栈,队列,哈希查找)
m0_37565374的博客
03-20 98
栈,队列,哈希查找的学习
【C语言】数据结构：数组，链表，栈，队列，树
airyv的博客
12-19 2643
3 线性结构 3.1 【数组】连续存储 1、什么叫做数组 元素类型相同，大小相等（数组传参，只要传进去首地址和长度就行） 2、数组的优缺点（相对于链表）： 优点： 存取速度快 缺点： 事先必须知道数组的长度 插入删除元素很慢 空间通常是有限制的 需要大块连续的内存块 插入删除元素的效率很低 定义一个数组至少需要3个参数：首地址，长度，有效个数。 用指针自己定义一个数组： # include <stdio.h> # include <malloc.h>
哈希表的画法_复习知识点参考：
weixin_31109487的博客
12-31 1947
第二章：线性表(重点)一．顺序表(也就是数组)p22插入删除时，注意移动元素的顺序(从尾开始or从插入位置开始)二．链表p27插入删除时，注意指针的赋值顺序。三．静态链表：并非链表，而是用顺序表模拟链表，(了解即可，表插入排序)p32四．单循环链表+双向链表p35：注意存储结构的表示、查找是否完成的标志，1.主要复习(顺序+链式)：初始化、查找、插入、删除。2.熟记两个(顺序+链式)存储结构表...
哈希表 相关笔试题
小旋锋 的博客
09-11 1万+
牛客网专项练习题 哈希表的平均查找长度与处理冲突的方法无关()A. 对 B. 错 正确答案: B [摘抄] 哈希表在查找过程中进行比较的关键字个数取决于哈希函数，处理冲突的方法和哈希表的装填因子，哈希表的装填因子标志哈希表的装满程度，与哈希表的长度有直接联系。 有B+Tree/Hash_Map/STL Map三种数据结构。对于内存中数据，查找性能较好的数据结构是（），对于磁盘中数据，
数据结构面试、数据结构考研复试——常见问题以及回答
热门推荐
weixin_44177594的博客
05-05 1万+
逻辑结构与物理结构的区别 算法的特点 常见的数据结构 单链表结构和顺序存储结构的区别 线性链表 数组和链表的区别 判断疫个链表是否有环，如何找到这个环 单链表和双链表的区别 头指针和头结点的区别 简述KMP算法 栈和队列的区别 栈和队列的相同之处和不同之处 两个栈实现队列，两个队列实现栈 树和二叉树的相关概念 二叉平衡树 二叉搜索树 红黑树 图的相关概念 邻接矩阵与邻接表的区别 深度优先遍历与广度...
python顺序查找x是否存在_python学习-09（查找、排序和浅谈数据结构）
weixin_39760206的博客
12-03 389
查找的方法：排序的方法：简单的数据结构：一、算计基础1.1、什么是算法：算法(Algorithm)是指解题方案的准确而完整的描述，是一系列解决问题的清晰指令，算法代表着用系统的方法描述解决问题的策略机制。也就是说，能够对一定规范的输入，在有限时间内获得所要求的输出。如果一个算法有缺陷，或不适合于某个问题，执行这个算法将不会解决这个问题。不同的算法可能用不同的时间、空间或效率来完成同样的任务。一个算...
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...
13.顺序队列.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...
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...
大话C语言：第28篇 内存分配与释放
whccf的博客
07-05 315
C语言内存分配与释放
Linux C轻量级白盒测试方法 (shell + c + signal)
AntigravityC的博客
07-08 293
linux C轻量级白盒测试方法（shell + c +signal）
Windows图形界面(GUI)-SDK-C/C++ - 按钮(button)
最新发布
0xCC说逆向
07-10 386
【代码】Windows图形界面(GUI)-SDK-C/C++ - 按钮(button)
c小红的图上划分（牛客127）
m0_74310050的博客
07-06 341
用并查集，如果新增边的点没有共同祖先，连通块就减1，只要判断连通块<=r即可满足条件，不用管l的值，因为减少一个连通块，也就是多增一条边，这条边一定会小于原来的值的，答案要的是最大值，所有不用管。有一个无向图，有 n 个点 m 条边，q 个询问，每次给出 L,R，求将图划分为至少 L 个连通块，最多 R个连通块的最大划分价值，若不可划分输出 "NO ANSWER"。图的划分定义为将图划分为一个或多个连通块，对于每个连通块，其点集为其边集中每一条边的两端点的集合，且点集内任意两点均可通过边集里的边互相到达。
【C语言】C语言可以做什么？
EleganceJiaBao的博客
07-06 994
C语言作为一种高效、灵活且具有底层控制能力的编程语言，在软件开发的多个领域中得到了广泛应用。以下是C语言在主要应用领域中的总结：

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值