Day19 3.20 数据结构

已于 2023-03-27 20:58:52 修改
阅读量51 收藏
点赞数
文章标签： 数据结构 c语言 链表 Powered by 金山文档
于 2023-03-20 20:25:35 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kcncoooo/article/details/129672857
版权

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;
}
kcncoooo
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据分析Day08
JanLEE
08-05 300
数据分析DAY08 pandas基础 pandas介绍 Python Data Analysis Library pandas是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。Pandas 纳入 了大量库和一些标准的数据模型，提供了高效地操作大型结构化数据集所需的工具。 pandas核心数据结构 数据结构是计算机存储、组织数据的方式。 通常情况下，精心选择的数据结构可以带来更高的运行或者存储效率。数据结构往往同高效的检索算法和索引技术有关。 Series Series可以理解为一个一维的数
数值型数据描述统计
weixin_40809507的博客
12-05 1515
目录 文章目录目录七、数值型数据描述统计1. 算数平均值(arithmetic mean)2. 加权平均值(weighted average)3. 最值4. 中位数5. 频数与众数6 .四分位数7. 标准差8. 协方差、相关系数、相关系数矩阵1. 协方差2.相关系数3. 相关系数矩阵9. Pandas 特殊值处理9. Pandas数据排序10. Pandas数据合并11. pandas分组聚合八、pandas可视化1. 折线图2. 柱状图3. 散点图4. 饼状图5. 直方图6. 箱线图九、数据清洗1. 去重
3.20 数组相关练习
qq_61886726的博客
03-20 77
（5）23031班有4个小组，每组有5名学生，C语言基础考试成绩，第一组5位同学的成绩为90、92、93、91、88，第二组5位同学的成绩为86、89、87、85、99，第三组5位同学的成绩为100，95，85，75，90，第四组5位同学的成绩为90，85，85，95，80，定义二维数组分别输入4个小组的成绩，利用循环再输出4个小组的学生成绩，求出每个小组的最低成绩，最高成绩并输出每个小组的最高成绩，最低成绩。（3）有如下两个数组：int arr[] = {1,2,3,4,5,6,7,8,9,0};
blog 2019.3.19 && 3.20 Day19&&Day20 集合框架 List、Set
qq_39263750的博客
03-19 130
多态 小插曲：数组是如何实现乾坤袋功能的？ 装父类类型的数组 添加的时候添加子类类型的数组 集合框架 基本概念 集合出现是为了解决数组在开发过程中所遇到的问题 特点： 1、长度不是固定的，可以随时扩容 2、可以存放不同类型的数据 3、提供了很多种集合，不同的算法。采用合适的集合框架可以提高开发效率。 左半边 集合框架 右边 Map框架（不输入collection集合框架） 虚线：接...
day19-20180515笔记
weixin_33845881的博客
05-16 75
笔记：NOSQL非关系型数据库之python3操作redis 一、NOSQL 1、Nosql简介 对于NoSQL并没有一个明确的范围和定义，但是他们都普遍存在下面一些共同特征：1. 不需要预定义模式：不需要事先定义数据模式，预定义表结构。数据中的每条记录都可能有不同的属性和格式。当插入数据时，并不需要预先定义它们的模式。2. 无共享架构：相对于将所有数据存储的存储区域网络中的全共享架构...
python数据分析-pandas学习
da.的博客
11-24 1894
文章目录一、pandas环境的搭建1.pandas 简介2.pandas安装和调用二、pandas学习1.pandas简介2.pandas学习资源3.pandas核心数据结构4.Seriesa.Series定义b.Series的创建c.Series中数据的访问d.Series的常用属性5.DataFramea.DataFrame定义b.DataFrame创建c.DataFrame常用属性d.核心数据结构操作显示索引，列索引选择复合索引列操作列访问列添加列删除行操作行访问行添加行删除数据对齐DataFrame
pandas核心数据结构---API
大大枫free
07-01 1973
pandas基础 pandas介绍 Python Data Analysis Library pandas是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。Pandas 纳入 了大量库和一些标准的数据模型，提供了高效地操作大型结构化数据集所需的工具。 pandas核心数据结构 数据结构是计算机存储、组织数据的方式。 通常情况下，精心选择的数据结构可以带来更高的运行或者存储效率。数据结构往往同高效的检索算法和索引技术有关。 Series Series可以理解为一个一维的数组，只是index名
Java高级总结
m0_51480841的博客
08-07 427
java高级知识点总结
Pandas 数据预处理
weixin_45639174的博客
07-17 1467
Pandas数据处理 一 概述 1.1 业务建模流程 将业务抽象为分类or回归问题 定义标签，得到y 选取合适的样本，并匹配出全部的信息作为特征的来源 特征工程 + 模型训练 + 模型评价与调优（相互之间可能会有交互） 输出模型报告 上线与监控 1.2什么是特征 在机器学习的背景下，特征是用来解释现象发生的单个特性或一组特性。 当这些特性转换为某种可度量的形式时，它们被称为特征。 举个例子，假...
12.20 day1 数据结构
12-20
12.20 day1 数据结构
数据结构 Day 3 主函数
06-12
main.c
数据结构 Day 3 预处理
06-12
head.h
数据结构 Day 3 功能函数
06-12
function.c
【数据结构】Day51
08-03
【数据结构】Day51和Day52的内容主要聚焦在数据结构中的树，特别是二叉树和表达式树。在这一部分的学习中，我们将深入理解这两种重要的数据结构及其应用。 4.2 叉树（Binary Trees） 二叉树是一种特殊类型的树，...
数据结构之并查集
我要学编程的博客
08-21 1233
并查集相关概念、模拟实现并查集、并查集的应用：省份的数量、等式方程的可满足行
【Redis】Redis 底层的数据结构（结合源码）
秋玄的博客
08-22 888
Redis 底层数据结构详解
算法的学习笔记—二叉搜索树的后序遍历序列(牛客JZ33)
业精于勤，荒于嬉
08-22 829
通过递归地判断数组的子序列是否满足二叉搜索树的性质，我们可以有效地判断一个数组是否是某二叉搜索树的后序遍历序列。这个方法在逻辑上比较直观，并且能够处理复杂的情况，尽管其时间复杂度为O(n^2)，但在实际应用中仍然是一个实用的算法。希望通过这篇文章，大家能够更加深入地理解二叉搜索树及其后序遍历的相关概念，并掌握如何通过编程来解决这类问题。😁热门专栏推荐想学习vue的可以看看这个java基础合集数据库合集redis合集nginx合集linux合集手写机制微服务组件spring_尘觉springMVC。
数据结构-时间、空间复杂度-详解
最新发布
2401_86587256的博客
08-23 1181
数据结构-时间、空间复杂度-详解
数据结构提炼与压缩技术研究
数据结构的提炼与压缩 数据结构的提炼与压缩是指对数据结构进行简化和压缩，以减少存储空间和提高处理效率。数据结构的“化繁为简”是指通过减少存储规模、化简存储结构、降低时空复杂度和提供多样化的处理方式来...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值