【无标题】

已于 2022-05-11 00:08:02 修改
阅读量720 收藏 4
点赞数 1
文章标签： c语言
于 2022-04-19 23:38:55 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_21191273/article/details/124286761
版权

2022.04.19 21:40 - 22:40

(设计题)LRU 缓存

https://leetcode-cn.com/problems/lru-cache/

  1. HASH_ITER的使用，从最后开始遍历数组
HASH_ITER(hh, g_usr, cur_usr, next_usr)

  1. UT_HASH本身就是一个优秀的双链表实现，可用于快速查找，快速插入

  2. HASH_COUNT的使用， 用于统计当前HASH中有多少数据

  3. 代码实现

typedef struct {
    int key;
    int value;
    UT_hash_handle hh;
} LRUCache;

LRUCache *g_usr = NULL;
int g_size;

LRUCache* lRUCacheCreate(int capacity) {
    g_size = capacity;
    return g_usr;
}

int lRUCacheGet(LRUCache* obj, int key) {
    LRUCache *cur_usr = NULL;
    HASH_FIND_INT(g_usr, &key, cur_usr);
    if(cur_usr != NULL) {
        HASH_DEL(g_usr, cur_usr);
        HASH_ADD_INT(g_usr, key, cur_usr);
        return cur_usr->value;
    }
    return -1;
}

void lRUCachePut(LRUCache* obj, int key, int value) {
    LRUCache *cur_usr = NULL;
    LRUCache *next_usr = NULL;

    HASH_FIND_INT(g_usr, &key, cur_usr);
    if(cur_usr != NULL) {
        HASH_DEL(g_usr, cur_usr);
        cur_usr->value = value;
        cur_usr->key = key;
        HASH_ADD_INT(g_usr, key, cur_usr);
    } else {
        int cnt = HASH_COUNT(g_usr);
        if(cnt == g_size) {
            HASH_ITER(hh, g_usr, cur_usr, next_usr) {
                HASH_DEL(g_usr, cur_usr);
                free(cur_usr);
                break;
            }
        }
        LRUCache *new_usr = (LRUCache*)malloc(sizeof(LRUCache));
        new_usr->key = key;
        new_usr->value = value;
        HASH_ADD_INT(g_usr, key, new_usr);
    }
    return;
}

void lRUCacheFree(LRUCache* obj) {
    LRUCache *cur_usr = NULL;
    LRUCache *next_usr = NULL;
    HASH_ITER(hh, g_usr, cur_usr, next_usr) {
        HASH_DEL(g_usr, cur_usr);
        free(cur_usr);
    }
}

2022.04.19 22:40 - 23:03

(基础题)链表排序

https://leetcode-cn.com/problems/insertion-sort-list/submissions/

https://leetcode-cn.com/problems/sort-list/

  1. 插入排序的思想：
    插入排序的基本思想是，维护一个有序序列，初始时有序序列只有一个元素，每次将一个新的元素插入到有序序列中，将有序序列的长度增加 11，直到全部元素都加入到有序序列中。
  2. 入参判断
  3. 链表的插入和恢复
            struct ListNode* prev = dummyHead;
            while(prev->next->val <= curr->val) {
                prev = prev->next;
            }
            lastSorted->next = curr->next;
            curr->next = prev->next;
            prev->next = curr;

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */


struct ListNode* insertionSortList(struct ListNode* head)
{
    if(head == NULL) {
        return head;
    }
    struct ListNode* dummyHead = (struct ListNode*)malloc(sizeof(struct ListNode));
    dummyHead->val = 0;
    dummyHead->next = head;
    struct ListNode* lastSorted = head;
    struct ListNode* curr = head->next;
    while(curr != NULL) {
        if(lastSorted->val <= curr->val) {
            lastSorted = lastSorted -> next;
        } else {
            struct ListNode* prev = dummyHead;
            while(prev->next->val <= curr->val) {
                prev = prev->next;
            }
            lastSorted->next = curr->next;
            curr->next = prev->next;
            prev->next = curr;
        }
        curr = lastSorted->next;
    }
    return dummyHead->next;
}

2022.04.24 22：40~23：29

(基础题) 堆排序 最大平均通过率

https://leetcode-cn.com/problems/maximum-average-pass-ratio/

  1. 大根堆概念
  2. 大根堆创建
  3. 大根堆维护 (增长率作为排序的输入条件)
  4. 大根堆模板要记住 
double calc(int* a)
{
    return (double)(a[0] + 1) / (a[1] + 1) - (double)a[0] / a[1];
}

void swap(int **a, int** b) {
    int *tmp = *a;
    *a = *b;
    *b = tmp;
}

void maxHeapify(int **classes, int n, int i)
{
    int largest = i;
    int l = 2 * i + 1;
    int r = 2 * i + 2;
    if(l < n && calc(classes[l]) > calc(classes[largest])) {
        largest = l;
    }
    if(r < n && calc(classes[r]) > calc(classes[largest])) {
        largest = r;
    }
    if( i != largest) {
        swap(&classes[i], &classes[largest]);
        maxHeapify(classes, n, largest);
    }
}




double maxAverageRatio(int** classes, int classesSize, int* classesColSize, int extraStudents)
{
    int i;
    int n = classesSize;
    double aveSum = 0.0;
    for(i = n / 2 - 1; i >= 0; i--) {
        maxHeapify(classes, n, i);
    }
    classes[0][0]++;
    classes[0][1]++;
    for( i = 1; i < extraStudents; i++) {
        maxHeapify(classes, classesSize, 0);
        classes[0][0]++;
        classes[0][1]++;
    }
    for(i = 0; i < classesSize; i++) {
        aveSum += (double)classes[i][0] / (double)classes[i][1];
    }
    return aveSum / classesSize;
}

#2022.04.30 23:00-23:50

（单调栈）小行星碰撞

https://leetcode-cn.com/problems/XagZNi/

  1. 单调栈特殊处理
  2. 正负号判断
bool IsNeedCash(int a, int b)
{
    if(((a & ACTIVE) == 0) && ((b & ACTIVE) == ACTIVE)) {
        return true;
    }
    return false;
}

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
#define ACTIVE 0x8000

bool IsNeedCash(int a, int b)
{
    if(((a & ACTIVE) == 0) && ((b & ACTIVE) == ACTIVE)) {
        return true;
    }
    return false;
}
int* asteroidCollision(int* asteroids, int asteroidsSize, int* returnSize)
{
    int* stack = (int*)malloc(sizeof(int) * asteroidsSize);
    memset(stack, 0, sizeof(int) * asteroidsSize);
    int top = -1;
    for(int i = 0; i < asteroidsSize; i++) {
        top += 1;
        stack[top] = i;
        while(top > 0 && IsNeedCash(asteroids[stack[top - 1]], asteroids[stack[top]])) {
            if(abs(asteroids[stack[top - 1]]) == abs(asteroids[stack[top]])) {
                top -= 2;
            } else {
                int tmp = abs(asteroids[stack[top - 1]]) > abs(asteroids[stack[top]]) ?  stack[top - 1] : stack[top];
                top -= 1;
                stack[top] = tmp; 
            }
        }

    }
    int* res = (int*)malloc(sizeof(int) * (top + 1));
    for(int i = 0; i <= top; i++) {
        res[i] = asteroids[stack[i]];
    }
    *returnSize = top + 1;
    free(stack);
    return res;
}

动态规划 有点像DFS

通过这两个好好研究下DFS

  1. 礼物的最大价值
    https://leetcode-cn.com/problems/li-wu-de-zui-da-jie-zhi-lcof/

int Max(int a, int b)
{
    return a > b ? a : b;
}


#define MAXLEN 201

int dp[MAXLEN][MAXLEN];

int maxValue(int** grid, int gridSize, int* gridColSize)
{
  int  m = gridSize;
  int  n = gridColSize[0];
  memset(dp, 0, sizeof(int) * MAXLEN * MAXLEN);

  dp[0][0] = grid[0][0];

  for(int i = 1; i < m; i++) {
      dp[i][0] = dp[i - 1][0] + grid[i][0];
  }

  for(int j = 1; j < n; j++) {
      dp[0][j] = dp[0][j - 1] + grid[0][j];
  }

  for(int i = 1; i <m; i++) {
      for(int j = 1; j < n; j++) {
          dp[i][j] =  Max(dp[i - 1][j], dp[i][j - 1]) + grid[i][j];
      }
  }
    return dp[m - 1][n - 1];
}
  1. 第K条最小指令
    https://leetcode-cn.com/problems/kth-smallest-instructions/
char * kthSmallestPath(int* destination, int destinationSize, int k)
{
    int m = destination[0];
    int n = destination[1];

    int help[m + 1][n + 1];

    for(int i = 0; i <=m; i++) {
        help[i][0] = 1;
    }

    for(int i = 0; i <= n; i++) {
        help[0][i] = 1;
    }

    for(int i = 1; i <= m; i++) {
        for(int j = 1; j <= n; j++) {
            help[i][j] = help[i][j - 1] + help[i - 1][j];
        }
    }

    char* res = (char*)malloc(sizeof(char) * (m + n + 1));

    int col = m;
    int row = n;

    for(int i = 0; i < m + n; i++) {
        if(row > 0 && k <= help[col][row - 1]) {
            res[i] = 'H';
            row--;
        } else {
            if(row > 0) {
                k -= help[col][row - 1];
            } 
            res[i] = 'V';
            col--;
        }
    }
    res[m + n] = '\0';
    return res;
}

双指针特殊题型

https://leetcode-cn.com/problems/find-the-winner-of-an-array-game/
找出数组游戏的赢家

int getWinner(int* arr, int arrSize, int k)
{
    int max = arr[0] > arr[1] ? arr[0] : arr[1];
    int count = 1;
    for(int i = 2; i < arrSize; i++) {
        if(count >= k) {
            break;
        }
        if(arr[i] <= max) {
            count += 1;
        } else{
            max = arr[i];
            count = 1; 
        }
    }
    return max;
}

BFS

单词拆分
https://leetcode-cn.com/problems/word-break/

  1. 保存可以延申的下标作为入队条件
bool CmpString(char* s1, char* s2, int len)
{
    for(int i = 0; i < len; i++) {
        if(s1[i] != s2[i]) {
            return false;
        }
    }
    return true;
}

bool wordBreak(char * s, char ** wordDict, int wordDictSize)
{
    int lens = strlen(s);

    int* visited = (int*)malloc(sizeof(int) * (lens + 1));
    memset(visited, 0, sizeof(int) * (lens + 1));

    int* queryArr = (int*)malloc(sizeof(int) * (lens + 1));
    memset(queryArr, 0, sizeof(int) * (lens + 1));

    int head = 0;
    int tail = 0;
    visited[0] = 1;
    queryArr[tail] = 0;
    tail += 1;
    while(head < tail) {
        int tmp_index = queryArr[head];
        for(int i = 0; i < wordDictSize; i++) {
            int tmpLens = strlen(wordDict[i]);
            if(tmpLens + tmp_index > lens) {
                continue;
            }
            if(visited[tmp_index + tmpLens] == 1) {
                continue;
            }
            if(CmpString(&s[tmp_index], wordDict[i], tmpLens) == true) {
                if(tmpLens + tmp_index == lens) {
                    return true;
                }
                queryArr[tail] = tmp_index + tmpLens;
                tail += 1;
                visited[tmp_index + tmpLens] = 1;
            }
        }
        head += 1;
    }
    return false;
}

贪心

翻转矩阵后的得分
https://leetcode-cn.com/problems/score-after-flipping-matrix/
1.先将行的第一个全部反转为1
2.再反转列， 数值增大反转 否则不反转
3.不必真的反转，只统计贡献值就可以

int matrixScore(int** grid, int gridSize, int* gridColSize)
{
    int row = gridSize;
    int col = gridColSize[0];

    int ret = row * (1 << (col - 1));

    for(int i = 1; i < col; i++) {
        int nOnes = 0;
        for(int j = 0; j < row; j++) {
            if(grid[j][0] == 1) {
                nOnes += grid[j][i];
            } else {
                nOnes += (1 - grid[j][i]);
            }
        }
    int k = nOnes > row - nOnes ? nOnes : row - nOnes;
    ret += k * (1 << (col - i - 1));
    }
    return ret;
}

回溯

2.全部子集

int** ans;
int* ansColSize;
int ansSize;

int* t;
int tSize;


void dfs(int cur, int* nums, int numsSize)
{
    if(cur == numsSize) {
        // 存结果
        int* tmp = (int*)malloc(sizeof(int) * numsSize);
        memcpy(tmp, t, sizeof(int) * numsSize);
        ans[ansSize] = tmp;
        ansColSize[ansSize] = tSize;
        ansSize +=1;
        return;
    }
    t[tSize++] = nums[cur];
    dfs(cur + 1, nums, numsSize);
    tSize -= 1;
    dfs(cur + 1, nums, numsSize);
}


int** subsets(int* nums, int numsSize, int* returnSize, int** returnColumnSizes) 
{
    ans = (int**)malloc(sizeof(int*) * (1 << numsSize));
    ansColSize = (int*)malloc(sizeof(int) * (1 << numsSize));

    t = (int*)malloc(sizeof(int) * numsSize);
    ansSize = 0;
    tSize = 0;
    dfs(0, nums, numsSize);
    * returnSize = 1 << numsSize;
    *returnColumnSizes = ansColSize;
    return ans;
}

1.全排列

/**
 * Return an array of arrays of size *returnSize.
 * The sizes of the arrays are returned as *returnColumnSizes array.
 * Note: Both returned array and *columnSizes array must be malloced, assume caller calls free().
 */

int** ans;
int* ansCol;
int ansSize;

int* path;


int g_used[1000] = {0};


void dfs(int cur, int* nums, int numsSize)
{
    if(cur == numsSize) {
        int* tmpx = (int*)malloc(sizeof(int) * numsSize);
        memcpy(tmpx, path, sizeof(int) * numsSize);
        ans[ansSize] = tmpx;
        ansCol[ansSize] = numsSize;
        ansSize += 1;
        return;
    }
    for(int i = 0; i < numsSize; i++) {
        if(g_used[i] == 1) {
            continue;
        }
        path[cur] = nums[i];
        g_used[i] = 1;
        dfs(cur + 1, nums, numsSize);
        g_used[i] = 0;
    }
}



int** permute(int* nums, int numsSize, int* returnSize, int** returnColumnSizes)
{
    memset(g_used, 0, sizeof(g_used));
    ans = (int**)malloc(sizeof(int*) * (100000));
    ansCol = (int*)malloc(sizeof(int)* (100000));
    path = (int*)malloc(sizeof(int)* (numsSize));
    ansSize = 0;
    dfs(0, nums, numsSize);
    *returnSize = ansSize;
    *returnColumnSizes = ansCol;
    return ans;
}
Falairmicro_zheng
关注
遍历字典方法：HASH_ITER
sanyuancap
04-16 4740
HASH_ITER(hh, m_pElements, pElement, tmp) { CCString* pOneKey = new CCString(pElement->m_szKey); pArray->addObject(pOneKey); CC_SAFE_RELEASE(pOneKey);
【C语言】算法学习·哈希算法全解
m0_64560763的博客
07-26 5170
c语言哈希算法
hash类型数据的遍历
若圆之意
12-04 990
/**  * hash数据类型的遍历  */ public class Test2 { Map hm = new HashMap(); /** * 初始化hm对象 */ public void initMap(){ hm.put("1", "lily"); hm.put("2", "lucy"); hm.put("3", "lilei"); hm.put("4",
C语言哈希表用法
我的blog屋
09-27 1856
转自：https://blog.csdn.net/nameofcsdn/article/details/107297361 哈希表在头文件"uthash.h"中已经有了，只需要简单学习一下用法即可。 1，哈希结构体 #include "uthash.h" typedef struct { int key; int value; UT_hash_handle hh; } Hash; Hash *hash = NULL; 其中UT_hash_handle是头文件"uthash
C语言哈希表uthash的使用方法详解
qq_45022743的博客
03-17 3049
uthash简介   由于C语言本身不存在哈希，但是当需要使用哈希表的时候自己构建哈希会异常复杂。因此，我们可以调用开源的第三方头文件，这只是一个头文件：uthash.h。我们需要做的就是将头文件复制到您的项目中，然后：#include "uthash.h"。由于uthash仅是头文件，因此没有可链接的库代码。   使用uthash添加，查找和删除通常是常数时间的操作，此哈希的目标是简约高效。它大约有1000行C。它会自动内联，因为它是作为宏实现的。   uthash还包括三个额外的头文件，主要提供链表，.
c#实现无标题栏窗口的拖动
09-05
本篇文章将详细讲解如何在C#中实现这种无标题栏窗口的拖动以及其他基本操作。 首先，为了实现无标题栏窗口的拖动，我们需要处理窗体的鼠标事件。窗体的`FormBorderStyle`属性应设置为`None`，这会去除窗体的边框和...
Qt无标题窗口
05-21
在本文中，我们将深入探讨如何使用Qt框架创建一个无标题窗口，这在界面设计和自定义标题栏美化中非常有用。我们将关注`framelesswidget.cpp`、`main.cpp`、`framelesswidget.h`等核心文件，理解它们在实现无标题窗口...
Delphi实现拖动按钮移动无标题栏窗口
05-11
摘要:Delphi源码,界面编程,窗体拖动,无标题栏 无标题栏的窗体的拖动功能实现，Delphi添加一个可拖动窗体的按钮，通过对此按钮的控制可移动窗体，实现按住标题栏移动窗口的功能，无标题栏也就不能显示最大化、最小化...
VC去掉'无标题'字样的方法.zip
11-21
在使用Visual C++进行编程时，我们经常会在创建新的窗口或者对话框时默认看到标题栏显示为“无标题”。这可能会对用户界面的美观性和专业性造成一定的影响。本资料包提供了一种方法来帮助开发者去掉这个“无标题”...
visual c++取掉对话框窗口的 -无标题 字样的方法
08-04
在Visual C++编程环境中，创建窗口应用程序时，默认情况下，窗口标题栏可能会显示“-无标题”字样，这通常是由于没有正确设置窗口类或没有自定义窗口标题所导致的。要解决这个问题，我们需要深入理解Windows API中的...
C语言——uthash使用
qwrasdzcc的博客
07-07 582
uthash
C语言哈希表UT_hash的使用方法详解
m0_65251054的博客
08-30 5821
C语言哈希表UT_hash的使用方法
哈希函数的C语言类型定义,C语言哈希表用法
weixin_33585822的博客
05-20 1458
为了认证C语言专业级上机编程，我特地学习了C语言的哈希表。哈希表在头文件"uthash.h"中已经有了，只需要简单学习一下用法即可。1，哈希结构体#include "uthash.h"typedef struct {int key;int value;UT_hash_handle hh;} Hash;Hash *hash = NULL;其中UT_hash_handle是头文件"uthash.h"中...
c++ 封装哈希表（Hash） 以及实现迭代器（iterator）
sumkee911‘s coding
12-16 3577
程序功能: 1.封装哈希表(Hash) 2.以及实现了迭代器(iterator) 3.允许string类，整形变量，浮点形变量，字符型变量等作为key值 废话不多说，马上上源码 Hash.h /* * Name: Hash * Date: 14-12-2015 * Author: Sumkee * Brief: 哈希模组 * 1.能把strin
HashMap的工作原理
iTer的专栏
11-21 1175
http://www.importnew.com/7099.html HashMap的工作原理是近年来常见的Java面试题。几乎每个Java程序员都知道HashMap，都知道哪里要用HashMap，知道Hashtable和HashMap之间的区别，那么为何这道面试题如此特殊呢？是因为这道题考察的深度很深。这题经常出现在高级或中高级面试中。投资银行更喜欢问这个问题，甚至会要求你实现Ha
面试HashMap看这篇就够了
sowhat
03-23 8733
文章目录预备知识位运算知识ArrayListLinkedListRedBlackTreeHashTableHashMap 预备知识 位运算知识 位运算操作是由处理器支持的底层操作，底层硬件只支持01这样的数字，因此位运算运行速度很快。尽管现代计算机处理器拥有了更长的指令流水线和更优的架构设计，使得加法和乘法运算几乎与位运算一样快，但是位运算消耗更少的资源。常用的位运算如下： 位与 &...
C语言哈希表uthash的使用方法详解（附下载链接）
weixin_45459266的博客
04-08 493
uthash简介   由于C语言本身不存在哈希，但是当需要使用哈希表的时候自己构建哈希会异常复杂。因此，我们可以调用开源的第三方头文件，这只是一个头文件：uthash.h。我们需要做的就是将头文件复制到您的项目中，然后：#include "uthash.h"。由于uthash仅是头文件，因此没有可链接的库代码。   使用uthash添加，查找和删除通常是常数时间的操作，此哈希的目标是简约高效。它大约有1000行C。它会自动内联，因为它是作为宏实现的。   uthash还包括三个额外的头文件，主要提供..
python只能在循环体中使用break_第9课 python while循环、for循环、迭代器和iter()函数...
weixin_39754915的博客
12-02 716
一、while循环语句1. while 循环语句结构while循环中，当条件表达式为真时，就会重复的执行循环体内的语句块，直到条件为假。count = 1while count <= 10:print("这是第%d次循环" % count)count += 1# 计数循环while True:print("dead loop")# 死循环一般情况下，很少使用死循环，除非要求程序一直是执行的，...
布谷鸟哈希函数的参数_布谷鸟算法详细讲解
weixin_35523259的博客
12-24 1665
今天我要讲的内容是布谷鸟算法，英文叫做Cuckoo search (CS algorithm)。首先还是同样，介绍一下这个算法的英文含义， Cuckoo是布谷鸟的意思，啥是布谷鸟呢，是一种叫做布谷的鸟，o(∩_∩)o ，这种鸟她妈很懒，自己生蛋自己不养，一般把它的宝宝扔到别的种类鸟的鸟巢去。但是呢，当孵化后，遇到聪明的鸟妈妈，一看就知道不是亲生的，直接就被鸟妈妈给杀了。于是这群布谷鸟宝宝为了保命，...
设置无标题 android
最新发布
05-02
在Android应用中，设置无标题是一种简洁和美观的设计方式，可以为用户提供更流畅的使用体验。以下是一些实现设置无标题的方法： 1. 在Android的Manifest文件中，找到对应Activity的标签，并添加”android:theme="@android:style/Theme.NoTitleBar"“属性。这样可以通过Android自带的主题去掉标题栏。 2. 使用自定义的主题，可以在样式表中添加以下代码： <style name="AppTheme" parent="Theme.AppCompat.NoActionBar"> <!-- ...其他样式... --> </style> 这种方式可以通过设置主题去除ActionBar和标题栏，同时保留其他布局元素。 3. 去掉代码中的setTitle()方法，这是一种最简单的方法，通过不设置Activity的标题来实现无标题。 以上就是三种常见的实现Android无标题的方式，开发者可以根据实际需求进行选择。值得注意的是，去除标题栏可能会影响用户的导航体验，因此在设计上需要考虑周全。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值