队列和哈希表的算法实现

最新推荐文章于 2024-08-03 17:07:25 发布
最新推荐文章于 2024-08-03 17:07:25 发布
阅读量48 收藏
点赞数
文章标签： 算法 散列表 c++ Powered by 金山文档
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_67100121/article/details/129675486
版权

1 队列

1.1 功能函数
#define _CRT_SECURE_NO_WARNINGS 1
#include "queue.h"
Linklist que1 = NULL;

/*
* Purpose：申请空间
* 
* Entry：  无
* 
* return：返回申请空间的首地址
*/
queue new_que()
{
    //申请空间
    queue q = malloc(sizeof(Queue));
    //置空队列
    q->front = q->tail = 0;
    return q;
}

/*
* Purpose：队列菜单选择打印
*
* Entry：  无
*
* return： 无
*/
void queue_menu()
{
    printf("\n***************************\n");
    printf("******** 1 顺序队列 *******\n");
    printf("******** 2 循环队列 *******\n");
    printf("******** 3 链式队列 *******\n");
    printf("******** 4 折半查找 *******\n");
    printf("******** 0 退出程序 *******\n");
    printf("***************************\n");
}

/*
* Purpose：顺序队列菜单选择打印
*
* Entry：  无
*
* return： 无
*/
void order_menu(queue q)
{
    int num = 1;
    while (num)
    {
        printf("\n*******************************\n");
        printf("******** 1 顺序队列入队 *******\n");
        printf("******** 2 顺序队列删除 *******\n");
        printf("******** 3 顺序队列遍历 *******\n");
        printf("******** 0 上级菜单     *******\n");
        printf("*******************************\n");

        printf("请选择：");
        scanf("%d", &num);
        switch (num)
        {
        case 1:
        {
            Eletype ele = 0;
            printf("请输入数据元素：");
            scanf("%d", &ele);
            in_queue(q, ele);
        }break;
        case 2:
        {
            dele_queue(q);
        }break;
        case 3:
        {
            output_queue(q);
        }break;
        case 0:break;
        default:printf("输入有误，请重新选择");
        }
    }
}

/*
* Purpose：循环队列菜单选择打印
*
* Entry：  无
*
* return： 无
*/
void loop_menu(queue q)
{
    int num = 1;
    while (num)
    {
        printf("\n*******************************\n");
        printf("******** 1 循环队列入队 *******\n");
        printf("******** 2 循环队列删除 *******\n");
        printf("******** 3 循环队列遍历 *******\n");
        printf("******** 4 循环队列个数 *******\n");
        printf("******** 0 上级菜单     *******\n");
        printf("*******************************\n");

        printf("请选择：");
        scanf("%d", &num);
        switch (num)
        {
        case 1:
        {
            Eletype ele = 0;
            printf("请输入数据元素：");
            scanf("%d", &ele);
            in_loop_queue(q, ele);
        }break;
        case 2:
        {
            dele_loop_queue(q);
        }break;
        case 3:
        {
            output_loop_queue(q);
        }break;
        case 4:
        {
            printf("个数：%d", (MAXSIZE - q->front + q->tail) % MAXSIZE);
            break;
        }
        case 0:break;
        default:printf("输入有误，请重新选择");
        }
    }
}



/*
 * Purpose：入队
 *
 * Entry：  q：队列地址
 *         ele：用户输入的数据元素
 *
 * return： 成功0；失败-1
 */
int in_queue(queue q, Eletype ele)
{
    if (q == NULL || (q->tail == MAXSIZE))
    {
        printf("队列不存在或者队列已满\n");
        return -1;
    }
    q->data[q->tail++] = ele;
    return 0;
}

/*
* Purpose：出队
*
* Entry：  q：队列地址
*
* return： 成功0；失败-1
*/
int dele_queue(queue q)
{
    if (q == NULL || (q->front == q->tail))
    {
        printf("队列不存在或者队列为空\n");
        return -1;
    }
    //先将删除的位置赋值默认值
    q->data[q->front] = 0;
    ++q->front;
    return 0;
}

/*
* Purpose：遍历
*
* Entry：  q：队列地址
*
* return： 成功0；失败-1
*/
int output_queue(queue q)
{
    if (q == NULL || (q->front == q->tail))
    {
        printf("队列不存在或者队列为空\n");
        return -1;
    }
    for (int i = q->front; i < q->tail; i++)
    {
        printf("%d\t", q->data[i]);
    }
    return 0;
}

/*
* Purpose：入队
*
* Entry：  q：队列地址
*         ele：用户输入的数据元素
*
* return： 成功0；失败-1
*/
int in_loop_queue(queue q, Eletype ele)
{
    if ((q->front == (q->tail + 1) % MAXSIZE) || q == NULL)
    {
        printf("队列不存在或者队列已满\n");
        return -1;
    }
    q->data[q->tail] = ele;
    q->tail = (q->tail + 1) % MAXSIZE;
    return 0;
}

/*
* Purpose：出队
*
* Entry：  q：队列地址
*
* return： 成功0；失败-1
*/
int dele_loop_queue(queue q)
{
    if (q == NULL || (q->front == q->tail))
    {
        printf("队列不存在或者队列为空\n");
        return -1;
    }
    //先将删除的位置赋值默认值
    printf("%d", q->data[q->front]);
    q->data[q->front] = 0;
    q->front = (q->front + 1) % MAXSIZE;
    return 0;
}

/*
* Purpose：遍历
*
* Entry：  q：队列地址
*
* return： 成功0；失败-1
*/
int output_loop_queue(queue q)
{
    if (q == NULL || (q->front == q->tail))
    {
        printf("队列不存在或者队列为空\n");
        return -1;
    }
    for (int i = q->front; q->tail != i;)
    {
        printf("%d\t", q->data[i]);
        i = (i + 1) % MAXSIZE;
    }
    return 0;
}

/*
* Purpose：链式队列菜单选择打印
*
* Entry：  无
*
* return： 无
*/
void link_menu(Linklist L)
{
    Linklist q = L;
    int num = 1;
    while (num)
    {
        printf("\n*******************************\n");
        printf("******** 1 链式队列入队 *******\n");
        printf("******** 2 链式队列删除 *******\n");
        printf("******** 3 链式队列遍历 *******\n");
        //printf("******** 4 链式队列个数 *******\n");
        printf("******** 0 上级菜单     *******\n");
        printf("*******************************\n");

        printf("请选择：");
        scanf("%d", &num);
        switch (num)
        {
        case 1:
        {
            Eletype ele = 0;
            printf("请输入数据元素：");
            scanf("%d", &ele);
            in_link_queue(q, ele);
        }break;
        case 2:
        {
            dele_link_queue(q);
        }break;
        case 3:
        {
            output_link_queue(q);
        }break;
        /*case 4:
        {
            printf("个数：%d", (MAXSIZE - q->front + q->tail) % MAXSIZE);
            break;
        }*/
        case 0:break;
        default:printf("输入有误，请重新选择");
        }
    }
}

/*
* Purpose：初始化头结点
*
* Entry：  无
*
* return： 成功0；失败-1
*/
Linklist Init_link()
{
    Linklist L = malloc(sizeof(LNode));
    L->len = 0;
    L->next = NULL;
    que1 = L;
    return L;
}

/*
* Purpose：新建结点
*
* Entry：  无
*
* return： 成功0；失败-1
*/
Linklist new_node()
{
    Linklist p = malloc(sizeof(LNode));
    p->data = 0;
    p->next = NULL;
    
    return p;
}

/*
* Purpose：链式入队
*
* Entry：  L：头结点地址
*         ele：用户输入的数据元素
*
* return： 成功0；失败-1
*/
int in_link_queue(Linklist L, Eletype ele)
{
    if (L == NULL)
    {
        return -1;
    }
    Linklist p = new_node();
    p->data = ele;
    que1->next = p;
    que1 = p;
    ++L->len;
    return 0;
}

/*
* Purpose：遍历
*
* Entry：  q：队列地址
*
* return： 成功0；失败-1
*/
int output_link_queue(Linklist L)
{
    if (L == NULL || L->next == NULL)
    {
        return -1;
    }
    Linklist s = L->next;
    while (s)
    {
        printf("%d\t", s->data);
        s = s->next;
    }
    return 0;
}

/*
* Purpose：出队
*
* Entry：  L：头结点地址
*
* return： 成功0；失败-1
*/
int dele_link_queue(Linklist L)
{
    if (L == NULL || L->next == NULL)
    {
        printf("不存在或为空");
        return -1;
    }
    Linklist s = L->next;
    L->next = s->next;
    if (s->next == NULL)
        que1 = L;
    free(s);
    s = NULL;
    --L->len;
    return 0;
}




/*============折半查找=============*/

int binary_seek(int arr[], int low, int high, int key)
{
    int mid = (low + high) / 2;
    if (low > high)
    {
        return -1;
    }
    if (key < arr[mid])
    {
        high = mid - 1;
        binary_seek(arr, low, high, key);
    }
    else if (key > arr[mid])
    {
        low = mid + 1;
        binary_seek(arr, low, high, key);
    }
    else
    {
        return  mid;
    }
}
1.2 头文件
#pragma once
#ifndef __QUEUE_H__
#define __QUEUE_H__

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

#define MAXSIZE 3

typedef int Eletype;

typedef struct Queue
{
    //数据域
    Eletype data[MAXSIZE];
    //队头
    int front;
    //队尾
    int tail;
}Queue, *queue;

typedef struct LNode
{
    union Ele
    {
        int len;
        Eletype data;
    };
    struct LNode* next;
}LNode, *Linklist;


typedef struct que
{
    struct que* next;
}que;



queue new_que();
void queue_menu();
void order_menu(queue q);
void loop_menu(queue q);
int in_queue(queue q, Eletype ele);
int dele_queue(queue q);
int output_queue(queue q);
int in_loop_queue(queue q, Eletype ele);
int dele_loop_queue(queue q);
int output_loop_queue(queue q);
void link_menu(Linklist L);
Linklist Init_link();
Linklist new_node();
int in_link_queue(Linklist L, Eletype ele);
int output_link_queue(Linklist L);

int binary_seek(int arr[], int low, int high, int key);

#endif
1.3 主函数
#define _CRT_SECURE_NO_WARNINGS 1
#include "queue.h"


int main(void)
{
    queue q = new_que();
    Linklist L = Init_link();

    int num = 1;
    while (num)
    {
        queue_menu();
        printf("请选择：");
        scanf("%d", &num);
        switch (num)
        {
        case 1: 
        {
            order_menu(q);
        }break;
        case 2:
        {
            q->front = q->tail = 0;//防止上一个步骤干扰此项
            loop_menu(q);
        }break;
        case 3:
        {
            link_menu(L);
        }break;
        case 4:
        {
            int arr[] = { 12, 23, 34, 45, 56, 67 };
            int len = sizeof(arr) / sizeof(arr[0]);
            int key = 0;
            printf("请输入要查找的数：");
            scanf("%d", &key);
            int ret = binary_seek(arr, 0, len - 1, key);
            printf("\n%d", ret);
        }
        case 0:break;
        default:printf("输入有误，请重新选择");
        }
    }
    return 0;
}

2 哈希表

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

int p = 0;

//结点结构体
typedef struct Node
{
    //数据域
    int data;
    //指针域
    struct Node* next;
}Node, *node;

/*
* Purpose：初始化指针数组
*
* Entry：  hash表， 长度
*
* return： 无
*/
void Init_hash(node hash[], int len)
{
    for (int i = 0; i < len; i++)
    {
        hash[i] = NULL;
    }
}

/*
* Purpose：找最大质数
*
* Entry：  哈希表长
*
* return： 成功返回质数
*/
int prime_seek(int m)
{
    
    for (int i = m; i >= 2; i--)
    {
        int cnt = 0;
        for (int j = 1; j <= i; j++)
        {
            if (i % j == 0)
            {
                ++cnt;
            }
        }
        if (cnt == 2)
        {
            return i;
        }
    }
    return -1;
}

/*
* Purpose：将数组元素映射到哈希表中
*
* Entry：  hash表，数组元素，哈希表长度
*
* return： 无
*/
void insert_hash(node hash[], int ele, int len)
{
    //找到该元素所对应的哈希下标

    p = prime_seek(len);
    int sub = ele % p;
    //新建节点，头插
    node n = malloc(sizeof(Node));
    n->data = ele;
    n->next = hash[sub];
    hash[sub] = n;
}

/*
* Purpose：打印输出
*
* Entry：  哈希表、哈希表长
*
* return： 无
*/
void output_hash(node hash[], int len)
{
    for (int i = 0; i < len; i++)
    {
        node p = hash[i];
        printf("%d:", i);
        while (p)
        {
            printf("%d\t", p->data);
            p = p->next;
        }
        printf("\n");
    }
}

/*
* Purpose：查找元素
*
* Entry：  哈希表、元素
*
* return： 成功则返回该元素值，否则返回-1
*/
int ele_seek(node hash[], int ele)
{
    //找出该元素多对应的哈希表下标
    int sub = ele % p;
    node t = hash[sub];
    //根据下标中的链表地址找该元素
    while (t)
    {
        if (t->data == ele)
        {
            return t->data;
        }
        t = t->next;
    }
    return -1;
}


int main(void)
{
    int arr[] = { 23, 22, 34, 23, 26, 56, 55, 34 };
    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);
    //查找数据元素
    int ele = 0;
    printf("请输入要查找的元素：");
    scanf("%d", &ele);
    printf("\n%d\n", ele_seek(hash, ele));

    return 0;
}
月到天心~
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C语言实现部分数据结构和算法，包括链表，栈，队列，哈希表，树，排序算法，图算法等等.zip
12-27
算法的设计和选择会直接影响到程序的效率，因此，在设计和选择算法时，需要考虑到时间复杂度、空间复杂度等因素。 在实际应用中，数据结构和算法常常是密不可分的。通过对数据结构的理解和运用，以及对算法的学习和...
哈希表操作算法
12-29
5. **依赖关系**：图数据结构算法依赖于哈希表与队列，而队列算法又依赖于链表。这意味着整个框架是一个层层嵌套的设计，每种数据结构相互配合以达到最优的性能表现。 #### 四、哈希表与图数据结构的应用 1. **图...
栈&队列&哈希表&堆-python
Rnan_prince的博客
11-09 1867
一、栈 栈（stack）又名堆栈，它是一种运算受限的线性表。限定仅在表尾进行插入和删除操作的线性表。 栈的主要操作： push()，将新的元素压入栈顶，同时栈顶上升。 pop()，将新的元素弹出栈顶，同时栈顶下降。 empty()，栈是否为空。 peek()，返回栈顶元素。 python通常实现栈只需要list就可以，list.append(val), list.pop()、list...
栈和队列、哈希表、链表、二叉树的题较多，图的较少
NZC2237的博客
12-20 347
不过，虽然图的题目出现频率相对较低，但对于算法和编程能力的全面评估来说，理解图结构和图算法是至关重要的。在面试准备过程中，还是建议对图的相关算法和常见问题有一定了解和准备，因为在一些特定的技术公司或更高级别的面试中可能会出现图相关的问题。在编程面试或算法题中，栈和队列、哈希表、链表以及二叉树确实是经常涉及的数据结构，因为它们是解决各种实际问题的基础。2. 面试时长考虑： 图的问题可能需要更多的时间来讲解和理解，而在面试时时间通常是有限的，所以会更倾向于涉及那些更为基础且容易实现的数据结构和算法。
算法篇07---链表、哈希表
S1406793的博客
01-19 1279
一、链表 二、哈希表 python的字典、集合都是它实现的。
使用哈希表+优先队列解决字符频率问题
weixin_56068397的博客
03-15 508
在求解算法题时，往往我们遇见的不是纯算法的题目，而是参杂着数据结构的题型；例如一般我们遇到需要统计字符出现的次数时，往往使用哈希表来记录数量，但是我们要找到最大的出现频率的元素，往往很难直接通过哈希表的来获取相应的value值，此时往往可以通过构造优先队列的方式来取值。 接下来将列举几道有关使用哈希表+优先队列求解出现频率的类型题，望大家参考： 题目1概述：前K个高频元素 给你一个整数数组 nums 和一个整数 k ，请你返回其中出现频率前 k 高的元素。你可以按 任意顺序 返回答案。 示例： 输入: nu
Java算法系列5 — 用队列和哈希表实现LRU缓存方案
早起一杯咖啡
11-26 430
LRU：Least Recently Used 最近最少使用。常用于缓存淘汰策略、页面置换的一种算法。 如何实现LRU? 使用双向链表实现的队列和一个哈希表可以实现，队列的最大容量为缓存的大小，哈希表中页号作为键，缓存在队列中的结点地址作为值。 具体代码实现： import java.util.ArrayDeque; import java.util.HashSet; /** * 用队列和...
查找--理解哈希算法并实现哈希表
Paranoid
06-01 3288
我们喜欢使用数组进行数据的查找，就是因为数组是一种“随机存取”的数据结构，我们根据数组的起始地址和数组元素的下标值就可以直接计算出每一个数组元素的存储位置，所以它的查找时间是O(1)，而与数组的个数无关。 我们在这个思想的基础上，可以联想到，如果有一种数据结构，让我们在进行关键字查找的时候，也可以像数组一样，进行随机存储，使其时间复杂度从O(n)降到O(1)，那就可以大大提高查找的效率。我们的前...
算法思想总结：哈希表
weixin_51142926的博客
05-31 2159
哈希表是我们在解决算法问题时的一个重要容器，值得我们深入去学习。
算法：哈希表的设计
OceanStar的博客
08-12 2922
实际上，散列函数也是哈希算法的一种应用。实现哈希算法的函数叫做哈希函数，可以用f(in) = out表示 举个例子： 哈希函数应该有如下特性：推论：相似字符串，经过f(str1)输出一个0~2^{128}-1中的一个数，经过%10之后，在上还是均匀分布的 发生冲突，继续寻找下一块未被占用的存储地址。常见的实现方法有如下三种：（1）线性探测（Linear Probing）（最好O(1)；最坏情况下的时间复杂度为 O(n)）(2）二次探测（Quadratic probing）和线性探测（Linear Probi
哈希表— —链式实现
m0_65635427的博客
11-11 1253
数据结构— — 哈希表链式实现
数据结构几个最简单的阐述完整版（带你入门：链表，栈，队列，哈希表，树）通俗易懂简单明了
m0_61271042的博客
03-14 1612
数据结构几个最简单的阐述完整版 一.链表（Linked list）： 如下图是一个链表： 1.链表是无须存储在连续的空间内，一般都是分散存储于内存中。（指针是指向下一个数据的内存地址） 2.所有要访问或查找时要一个一个往下连续访问。这就是所谓的顺序访问。 （1）如果要添加一个数据：如添加一个数据D到AB之间 只需要将A的指针指向位置由B变成D，D的指针指向B即可。 （2）如果要删除一个数据：如把B从数据中删除 只需要把A的指针指向改为C即可，删除即可完成所...
基于C和C++实现的嵌入式设备算法库(含PID控制器-哈夫曼编码器-哈希表-环形队列算法实现).zip
12-30
基于C和C++实现的嵌入式设备算法库(含PID控制器_哈夫曼编码器_哈希表_环形队列算法实现).zip 基于C和C++实现的嵌入式设备算法库(含PID控制器_哈夫曼编码器_哈希表_环形队列算法实现).zip 基于C和C++实现的嵌入式设备...
5力扣：最长回文子串
m0_75015083的博客
08-02 279
从后到前遍历是为了让每一次遍历时所需用到的子串提前被计算过。
LeetCode：2740. 找出分区值（Java 排序）
Cosmoshhhyyy的博客
08-02 289
一道简单的mid题，翻译题目其实就是找出排序后两个相邻数之间的最小差值。
算法第十七天：leetcode242.有效的字母异位词
m0_75068978的博客
08-02 511
如下表所示，您可以直接复制下面网址进入力扣学习，在观看下面的内容之前您一定要先做一遍哦，以便让你印象更加深刻！
代码随想录算法训练营第三十三天 | 动态规划理论基础、509. 斐波那契数、70. 爬楼梯、746. 使用最小花费爬楼梯
weixin_43581681的博客
08-01 309
1. 动态规划基础；2. 背包问题；3. 打家劫舍；4. 股票问题；5. 子序列问题。1. 确定 dp[ i ] 数组及下标含义；2. 确定递推公式；3.确定dp数组如何初始化；4. 确定遍历顺序（背包问题中很重要）；5. 举例推导dp数组。
TypeScript 及算法准备
qq_25416827的博客
08-02 865
typescript复制代码function mergeSortedArrays(arr1: number[], arr2: number[]): number[] {typescript复制代码function flattenArray(arr: any[]): any[] {typescript复制代码function flattenArray(arr: any[]): any[] {typescript复制代码function flattenArray(arr: any[]): any[] {
算法：BFS 解决多源最短路问题
最新发布
一名还在努力学习技术的程序员的博客
08-03 804
本篇博客是关于 BFS 解决多源最短路问题 的练习题，每道题都超链接了力扣的网页，每道题都有详细的解答过程
哈希表查找算法与堆数据结构解析
总结来说，哈希表提供快速的查找功能，而堆则是一种具有特定性质的数据结构，常用于实现优先队列和高效的排序算法。两者都是数据结构和算法中不可或缺的部分，尤其在C语言这样的编程环境中，理解和熟练运用这些数据...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值