【剑指offer专项突破版】哈希表篇——“C“

文章目录

  • 前言
  • 一、插入、删除和随机访问都是 O(1) 的容器
    • 题目分析
    • 思路分析
    • 代码
  • 二、最近最少使用缓存
    • 题目分析
    • 思路分析
    • 代码
  • 三、有效的变位词
    • 题目
    • 分析
    • 代码
  • 四、变位词组
    • 题目分析
    • 思路分析
    • 代码
  • 五、外星语言是否排序
    • 题目分析
    • 思路分析
    • 代码
  • 六、最小时间差
    • 题目分析
    • 思路分析
    • 代码①——快排思路
    • 代码②——哈希思路
  • 总结

前言

剑指offer专项突破版(力扣官网)——> 点击进入
本文所属专栏——>点击进入

本文涉及到了哈希表的基础知识,博主总结了一下,放到这里,有兴趣的小伙伴,可以看一下。

哈希表基础知识——哈希表——C语言

话不多说,直接进入正题。

一、插入、删除和随机访问都是 O(1) 的容器

题目分析

【剑指offer专项突破版】哈希表篇——“C“_第1张图片
总结:自定义结构体,完成上述要求。

思路分析

 为了实现getRandom的等概率返回值,我们采用的数据结构必然是数组这种连续存储的数据结构。
 为了实现访问数据的的O(1),我们还需采用哈希表的结构进行存储数据信息。键值元素val,哈希表中存储的值是元素val的下标
  为了实现删除数据的O(1),我们需要将数组中的数据跟最后一个位置的数据进行交换,问题就转换为删除数组尾部的元素,就省去了删除之后移动数据的操作,同时不要忘记,还要更新哈希表中的信息哦!

代码

#define MIN_NUMS 5000 //这是所开辟数组通过测试的最小元素个数
typedef struct Hash
{   
    int key;
    int val;
    UT_hash_handle hh;
}HNode;
//查找函数
int find(HNode** obj, int key)
{
    HNode* ret = NULL;
    HASH_FIND_INT(*obj,&key,ret);
    if(ret != NULL)
    {
        return ret->val;
    }
    return -1;
}
//插入函数
void insert(HNode** obj, int key, int val)
{
    HNode* ret = NULL;
    HASH_FIND_INT(*obj,&key,ret);
    if(ret == NULL )
    {
        ret = (HNode*)malloc(sizeof(HNode));
        ret->key = key;
        ret->val = val;
        HASH_ADD_INT(*obj,key,ret);
    }
    //找到我们就更新下标,因为数组删除时元素的下标会发生变化
    else
    {
        ret->val = val;
    }

}
void remove_one(HNode** obj, int key)
{
    HNode* ret = NULL;
    HASH_FIND_INT(*obj,&key,ret);
    if(ret != NULL)
    {
        HASH_DEL(*obj,ret);//从哈希表中移除,并没有释放其空间,需手动释放
        free(ret);
    }
}
void remove_all(HNode* obj)
{
    HNode* cur,*next;
    HASH_ITER(hh,obj,cur,next)
    {
        HASH_DEL(obj,cur);
        free(cur);
    }
}
typedef struct 
{
    int* arr;
    int size;
    HNode* hash;
} RandomizedSet;

/** Initialize your data structure here. */

RandomizedSet* randomizedSetCreate() 
{
    //为了返回随机数,需要我们设置一下随机数起点
    srand((unsigned int)time(NULL));
    RandomizedSet* map = (RandomizedSet*)malloc(sizeof(RandomizedSet));
    map->arr = (int*)malloc(sizeof(int)*MIN_NUMS);
    map->size = 0;
    map->hash = NULL;
    return map;
}

/** Inserts a value to the set. Returns true if the set did not already contain the specified element. */
bool randomizedSetInsert(RandomizedSet* obj, int val) 
{
    //如果找不到我们就插入
    int ret = find(&(obj->hash),val);
    if(ret == -1)
    {
        (obj->arr)[(obj->size)++] = val;
        insert(&(obj->hash),val,obj->size-1);

        return true;
    }
    return false;
}

/** Removes a value from the set. Returns true if the set contained the specified element. */
bool randomizedSetRemove(RandomizedSet* obj, int val) 
{
    //如果有我们就移除
    int ret = find(&(obj->hash),val);
    if(ret != -1)
    {
        //直接将末尾的元素赋值到当前元素的下标处
        int last = (obj->arr)[(obj->size)-1];
        (obj->arr)[ret] = last;
        //同时size减一执行删除操作
        (obj->size)--;

        //更新末尾元素的新的下标,当然前提是首不等于尾
        insert(&(obj->hash),last,ret);
        //在哈希表中删除此元素
        remove_one(&(obj->hash),val);
        return true;
    }
    return false;
}
/** Get a random element from the set. */
int randomizedSetGetRandom(RandomizedSet* obj) 
{
    //获取随机数下标
    int randomIndex = rand()%(obj->size);
    return obj->arr[randomIndex];
}
void randomizedSetFree(RandomizedSet* obj) 
{
    remove_all(obj->hash);
    free(obj->arr);
    free(obj);
}

二、最近最少使用缓存

题目分析

【剑指offer专项突破版】哈希表篇——“C“_第2张图片

思路分析

 因为是缓存,且当缓存满时,要释放最久未被使用的值,我们可以,采用双向循环链表的数据结构,当使用一个值时我们就更新头结点,到下一个结点,这样下一个结点就是最久未被使用的结点。如果需要删除,我们只需要头删即可。

 当我们需要在时间复杂度O(1),实现访问数据的操作,我们就需要哈希表这种数据结构,在开辟结点,存储信息的同时,也要通过关键字key,将节点的地址,存储在哈希表中,方便访问。

代码

//双向循环链表
typedef struct DRListNode
{
    int key;
    int val;
    struct DRListNode* prev;
    struct DRListNode* next;
}Node;
//哈希表
typedef struct Hash
{
    int key;
    Node* val;
    UT_hash_handle hh;
}HNode;
//哈希表的查找函数
Node* find(HNode** obj, int key)
{
    HNode* ret = NULL;
    HASH_FIND_INT(*obj,&key,ret);

    if(ret!=NULL)
    {
        return ret->val;
    }

    return NULL;
}
//哈希表的插入函数
void insert(HNode**obj, int key,Node* val)
{
    HNode* ret = NULL;
    HASH_FIND_INT(*obj,&key,ret);
    if(ret == NULL)
    {
        ret = (HNode*)malloc(sizeof(HNode));
        ret->key = key;
        ret->val = val;
        HASH_ADD_INT(*obj,key,ret);
    }
    else
    {
        ret->val = val;
    }
}
//删除指定结点
void remove_one(HNode** obj, int key)
{
    HNode* ret = NULL;
    HASH_FIND_INT(*obj,&key,ret);
    if(ret != NULL)
    {
        HASH_DEL(*obj,ret);
        free(ret);
    }
}
//全部删除
void remove_all(HNode** obj)
{
    HNode* cur,*next;
    HASH_ITER(hh,*obj,cur,next)
    {
        HASH_DEL(*obj,cur);
        free(cur);
    }
}
//开辟结点
Node* BuyNode(int key,int val)
{
    Node* tmp = (Node*)malloc(sizeof(Node));
    tmp->key = key;
    tmp->val = val;
    tmp->prev = NULL;
    tmp->next = NULL;

    return tmp; 
}
//双向循环链表的尾插
Node* PushBack(Node** head, int key, int val)
{
    Node *tmp = BuyNode(key,val);
    if(*head == NULL)
    {
        tmp->prev = tmp;
        tmp->next = tmp;
        *head = tmp;
    }
    else
    {
        Node* first = *head;
        Node* tail = first->prev;
        tmp->prev = tail;
        tmp->next = first;

        first->prev = tmp;
        tail->next = tmp;
    }
    return tmp;
}
//链表的头删
void PopFront(Node** curr)
{

    Node* first = *curr;
    //说明只有一个结点且为头结点
    if(first->next == first)
    {
        *curr = NULL;
        free(first);
    }
    else
    {
        Node* cur = *curr;
        Node* prev = cur->prev;
        Node* next = cur->next;
        //删除cur
        prev->next = next;
        next->prev = prev;
        *curr = next;
        free(cur);
    }
}
//链表的释放
void free_all(Node* head)
{
    if(head != NULL)
    {
        Node* first = head->next;
        while(first!= head)
        {
            Node* next = first->next;
            free(first);
            first = next;
        }
    }
    free(head);
}
typedef struct 
{
    //链表的头结点
    Node* head;
    //链表的目前的大小
    int size;
    //链表的最大容量
    int capacity;
    //哈希表
    HNode* hash;

}LRUCache;


LRUCache* lRUCacheCreate(int capacity) 
{
    LRUCache* set = (LRUCache*)malloc(sizeof(LRUCache));
    set->head = NULL;
    set->size = 0;
    set->capacity = capacity;
    set->hash = NULL;

    return set;
}

int lRUCacheGet(LRUCache* obj, int key) 
{
    Node* ret = find(&(obj->hash),key);

    if(ret != NULL)
    {
        //先进行尾插
        Node* new = PushBack(&(obj->head),ret->key,ret->val);
        //再把以前的结点进行释放
        if(obj->head == ret)
        {
            PopFront(&(obj->head));
        }
        else
        {
            PopFront(&ret);
        }
        //更新哈希表的结点地址
        insert(&(obj->hash),key,new);

        return new->val;
    }
    return -1;
}

void lRUCachePut(LRUCache* obj, int key, int value) 
{
    Node* ret = find(&(obj->hash),key);
    // printf("%p\n",ret);
    if(ret != NULL)
    {
        ret->val = value;
        Node* new = PushBack(&(obj->head),ret->key,ret->val);
        //再把以前的结点进行释放
        if(obj->head == ret)
        {
            PopFront(&(obj->head));
        }
        else
        {
            PopFront(&ret);
        }
        //更新哈希表的结点地址
        insert(&(obj->hash),key,new);
    }
    else
    {
        //先进行判断
        //如果当前的size小于capacity就直接尾插
        if(obj->size < obj->capacity)
        {
            Node* new = PushBack(&(obj->head),key,value);
            //更新哈希表
            insert(&(obj->hash),key,new);
            //size还要加1
            (obj->size)++;
        }
        else
        {
            //说明size == capacity
            //先清理此节点在哈希表中的信息
            remove_one(&(obj->hash),(obj->head)->key);
            //先进行头删
            PopFront(&(obj->head));
            //再进行尾插
            Node* new = PushBack(&(obj->head),key,value);
            //再更新此节点在哈希表中的信息
            insert(&(obj->hash),key,new);
            //size无需加加
        }
    }
}

void lRUCacheFree(LRUCache* obj) 
{
    remove_all(&(obj->hash));
    free_all(obj->head);
    free(obj);
}

博主,稍微啰嗦几句,如果不是自讨苦吃,或者锻炼自己的造轮子的能力,是不建议写这种题的,除非没事闲的(很明显是我了)。

三、有效的变位词

题目

【剑指offer专项突破版】哈希表篇——“C“_第3张图片

分析

 此题我们在字符篇(点我进入)系统地论述过,此处不过多叙述,唯一需要强调的一个词是有效的

代码

bool is_diff(char* str1, char* str2)
{
    while((*str1 != '\0')&&(*str2 != '\0'))
    {
        if(*str1 != *str2)
        {
            return true;
        }

        str1++;
        str2++;
    }
    return false;
}
void fun(char *s,int* arr)
{
    for(;*s != '\0'; s++)
    {
        arr[*s-'a']++;
    }
}
bool check(int* arr1, int* arr2)
{
    for(int i = 0; i < 26; i++)
    {
        if(arr1[i]!=arr2[i])
        {
            return false;
        }
    }
    return true;
}
bool isAnagram(char * s, char * t)
{
    if(is_diff(s,t))
    {
        int* str1 = (int*)malloc(sizeof(int)*26);
        int* str2 = (int*)malloc(sizeof(int)*26);
        memset(str1,0,sizeof(int)*26);
        memset(str2,0,sizeof(int)*26);
        fun(s,str1);
        fun(t,str2);
        return check(str1,str2);
    }
    return false;
}

四、变位词组

题目分析

【剑指offer专项突破版】哈希表篇——“C“_第4张图片

思路分析

 如何判断是多组呢?思路其实很简单,将变位词固定顺序——快排 ,也就是对变位词排序,判断在哈希表中有没有,如果有,则说明是同一组变位词,如果没有,则不是同一组变位词,需要将排序过后的变位词,当做键值记录。

代码

typedef struct Hash
{
     const char* key;//字符串
     int row;//所在行号
     int size;//当前行的个数
     int capacity;//最大容量
     char** str;
     UT_hash_handle hh;

}HNode;
int my_cmp(const void* e1, const void* e2)
{
    return *(char*)(e1) - *(char*)(e2);
}
char *** groupAnagrams(char ** strs, int strsSize, int* returnSize, int** returnColumnSizes)
{
    HNode* head = NULL;
    int group = 0; 
    for(int i = 0; i < strsSize; i++)
    {
        //先将字符串复制一份,进行排序
        int size =  strlen(strs[i]) + 1;
        char* copy_str = (char*)malloc(sizeof(char)*size);
        strcpy(copy_str,strs[i]);
        //对复制的字符串进行排序
        qsort(copy_str,size-1,sizeof(char),my_cmp);
        //先看在字符串中有没有这个字符串
        HNode* ret = NULL;
        HASH_FIND_STR(head,copy_str,ret);
        //printf("%s\n",copy_str);
        if(ret == NULL)
        {
            //说明哈希表中没有
            ret = (HNode*)malloc(sizeof(HNode));
            ret->row = group++;
            ret->size = 0;
            ret->capacity = 10;
            //赋值key
            ret->key = copy_str;
            //开辟空间
            ret->str = (char**)malloc(sizeof(char*)*(ret->capacity));
            (ret->str)[ret->size++] = strs[i];
            //添加到哈希表中
            HASH_ADD_KEYPTR(hh,head,ret->key,strlen(ret->key),ret);
        }
        else
        {
            //说明哈希表中有
            //判断是否需要扩容
            if(ret->size == ret->capacity)
            {
                ret->str = (char**)realloc(ret->str,sizeof(char*)*(ret->capacity)*2);
                (ret->capacity)*=2;
            }
            (ret->str)[ret->size++] = strs[i]; 
            
        }
    }
    //剩余的工作是将数组移到一堆
    //先判断需要开多少行
    int n = HASH_COUNT(head);
    *returnSize = n;
    char*** str = (char***)malloc(sizeof(char**)*n);
    *returnColumnSizes = (int*)malloc(sizeof(int)*n);
    //通过遍历哈希表放到一堆
    HNode* cur,*next;
    HASH_ITER(hh,head,cur,next)
    {
        //获取行号
        int row = cur->row;
        //获取行元素个数
        int size = cur->size;
        //获取行所在地址
        char** str_row = cur->str;

        str[row] = str_row;
        (*returnColumnSizes)[row] = size;
    }
    return str;
}

五、外星语言是否排序

题目分析

【剑指offer专项突破版】哈希表篇——“C“_第5张图片
只要看明白了,其实很简单,意思就是我们是按abcdef……yz,26个字母排序的。但外星语言可能是按bcdef……26个字母排序的,但字母都是相同的。

思路分析

  • 关键:记录字典序的每个字符的顺序,然后遍历数组,比较相邻字符串每个字符是不是按照这种顺序排的。

代码

bool isAlienSorted(char ** words, int wordsSize, char * order)
{
    //记录字典序,顺序
    int* arr = (int*)malloc(sizeof(int)*26);
    memset(arr,0,sizeof(int)*26);
    for(int i = 0; i < 26; i++)
    {
        arr[order[i]-'a'] = i;
    }
    //判断是否按照顺序进行排序
    for(int i = 0; i < wordsSize-1; i++)
    {
        char* cur = words[i];
        char* next = words[i+1];
        while(*cur!='\0'&& *next !='\0')
        {
            if(arr[*cur-'a'] > arr[*next-'a'])
            {
                return false;
            }
            else if(arr[*cur-'a'] < arr[*next-'a'])
            {
                break;
            }
            else
            {
                cur++;
                next++;
            }
        }
        if((*cur!='\0')&&(*next=='\0'))
        {
            return false;
        }
    }
    return true;
}

六、最小时间差

题目分析

【剑指offer专项突破版】哈希表篇——“C“_第6张图片

思路分析

补充知识:一天最多有1440分钟
 这道题的关键在于求最小时间差(分钟表示) ,比如"23:59"和"00:00",最小时间差是1,而不是1439。我们可以将此问题看为:圆上两点之间的最短距离,如果两点之差大于圆周长的一半,那就是另一边较短了。
  因此,如果两时间的分钟差大于一天一半的时间,那就是另一边较短了。
图解:
【剑指offer专项突破版】哈希表篇——“C“_第7张图片
那如何求最短时间差呢,这里提供两种思路,

  • 排序之后,两相邻数的时间差可能最小的,遍历一遍。首尾时间差,也可能是最小的,因此我们需要再求一下。
  • 为了省去排序的麻烦 ,时间按分钟分,只有1440种可能,因此我们可以开一个数组,存每个槽位是否有这个时间,如果时间重复,直接返回0,即可。剩下的就是找存在的相邻的时间,和存在的首尾时间差。

代码①——快排思路

int change_minutes(char* str)
{
    int hours = (str[0]-'0')*10 + (str[1]-'0');
    int minutes = (str[3]-'0')*10 + (str[4]-'0');
    return hours*60 + minutes;
}
int minutes_sub(int m1, int m2)
{
    int ret = abs(m1-m2);
    if(ret > 1440/2)
    {
        return 1440-ret;
    }
    else
    {
        return ret;
    }
}
int my_cmp(const void* e1, const void* e2)
{
    return *(int*)e2 - *(int*)e1;
}
int findMinDifference(char ** timePoints, int timePointsSize)
{
    //将时间转换为分钟记录
    int*arr = (int*)malloc(sizeof(int)*timePointsSize);
    for(int i = 0; i < timePointsSize; i++)
    {
        arr[i] = change_minutes(timePoints[i]);
    }
    //将时间进行排序_排降序
    qsort(arr,timePointsSize,sizeof(int),my_cmp);
    //比较相邻的时间差,最大时间差的那个可能也是最小的(想一下为啥子),因此我们要先计算一下。
    int min = minutes_sub(arr[0],arr[timePointsSize-1]);
    for(int i = 0; i < timePointsSize-1;i++)
    {
        int cur = minutes_sub(arr[i],arr[i+1]);
        if(cur < min)
        {
            min = cur; 
        } 
    }
    //及时地清理空间
    free(arr);
    return min;
}

代码②——哈希思路

int change_minutes(char* str)
{
    int hours = (str[0]-'0')*10 + (str[1]-'0');
    int minutes = (str[3]-'0')*10 + (str[4]-'0');
    return hours*60 + minutes;
}
int minutes_sub(int m1, int m2)
{
    int ret = abs(m1-m2);
    if(ret > 1440/2)
    {
        return 1440-ret;
    }
    else
    {
        return ret;
    }
}
int findMinDifference(char ** timePoints, int timePointsSize)
{
    //开一个数组存储所有可能的情况
    int *arr = (int*)malloc(sizeof(int)*1440);
    memset(arr,0,sizeof(int)*1440);
    for(int i = 0; i < timePointsSize; i++)
    {
        int ret = change_minutes(timePoints[i]);
        if(arr[ret] == 0)
        {
            arr[ret] = 1;
        }
        else
        {
            //如果有相同的直接返回0
            return 0;
        }
    }
    //先找到首尾
    int first = 0;
    int last = 1439;
    while((arr[first] == 0)||(arr[last] == 0))
    {
        if(arr[first] == 0)
        {
            first++;
        }
        if(arr[last] == 0)
        {
            last--;
        }
    }
    int min = minutes_sub(first,last);
    for(int i = 0; i < 1440;)
    {
        while(arr[i]==0)
        {
            i++;
        }
        int j = i+1;
        while(j <1440&&arr[j]==0)
        {
            j++;
        }
        if(j != 1440)
        {
            int ret = minutes_sub(i,j);
            if(ret < min)
            {
                min =  ret;
            }
        }
        i = j;
    }
    free(arr);
    return min;
}   

总结

 今天的内容就分享到这里了,文章不错的话,帮忙点个赞呗,小伙伴们,我们下次见吧!

你可能感兴趣的:(剑指offer专项突破版,c语言,哈希算法,剑指offer,面试,数据结构)