刷题算法归档

于 2020-05-17 16:52:56 发布
阅读量447 收藏
点赞数
分类专栏： 刷题
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/SWJTU_LiSanShi/article/details/106176428
版权
这篇博客详细介绍了多种常用的算法和数据结构，包括Dijkstra最短路径算法、邻接表、快速排序qsort、广度优先搜索BFS、并查集、二分查找、平衡二叉树、单调栈、全排列、链表操作、滑动窗口和哈希表的应用。通过代码模板和实际场景，帮助读者理解并掌握这些基础知识。
摘要由CSDN通过智能技术生成

目录

Djkstra（迪杰斯特拉）

【使用场景】
加权非负有向图求某点到其他点的最短距离。
核心思想：
① 找出 当前可达点 与 源节点 距离最短点；
② 以上一步求得的距离最短点，重新计算 当前可达点 与 源节点 的距离；

【代码模板】

/*************************************************
Function:		CreateMap
Description:	创建邻接矩阵
Input: 			dis:     	距离关系
				disSize:    距离关系个数
       			n:       	节点个数		
Output:			邻接矩阵
Others:			无
*************************************************/
int **CreateMap(int **dis, int disSize, int n)
{
    int **map;

    map = (int **)malloc(sizeof(int *) * (n + 1));
    for (int i = 0; i < (n + 1); i++) {
        map[i] = (int *)malloc(sizeof(int) * (n + 1));
        memset(map[i], 0x1f, sizeof(int) * (n + 1));        // 初始化 非联通点 为极大值
    }

    for (int i = 0; i < disSize; i++) {
        map[dis[i][0]][dis[i][1]] = map[dis[i][2]];         // 初始化联通点距离
    }
    return map;
}

/*************************************************
Function:		Dijkstra
Description:	Dijkstra算法
Input: 			srcNode: 源节点
       			n:       节点个数		
       			map:     邻接矩阵
Output:			距离矩阵
Others:			无
*************************************************/
int *Dijkstra(int **map, int n, int srcNode)
{
    int node;
    int minDis;
    int *dis;
    int *visit;
    bool flag = false;

    dis = (int *)malloc(sizeof(int) * (n + 1));
    visit = (int *)malloc(sizeof(int) * (n + 1));
    memset(dis, 0x1f, sizeof(int) * (n + 1));
    memset(visit, 0, sizeof(int) * (n + 1));

    node = srcNode;
    dis[node] = 0;
    for (int i = 0; i <= n; i++) {
        minDis = 65535;
        // 寻找距离最小的点
        for (int j = 0; j <= n; j++) {
            if (visit[j] == 0 && dis[j] < minDis) {
                minDis = dis[j];
                node = j;
            }
        }
        // 标识已找到最小距离
        visit[node] = 1;
        // 基于当前最小点，刷新所有可达点距离
        for (int j = 0; j <= n; j++) {
            if (visit[j] == 0 && dis[j] > dis[node] + map[node][j]) {
                dis[j] = dis[node] + map[node][j];
            }
        }
    }
    return dis;
}

【练习题】
Leetcode-743：网络延迟时间链接: link.

———————————————————————————————————————————————————————

邻接表

【使用场景】
DFS、BFS图遍历时，稀疏邻接矩阵，使用邻接矩阵，空间复杂度过高，创建邻接关系图。

【代码模板】

/*************************************************
Function:		CreateMap
Description:	创建邻接表（有向）
Input: 			sideNum: 边数
                sideArr: 邻接关系
Output:			邻接矩阵
Others:			无
*************************************************/
#define MAX_NODE_NUM 1001

typedef struct NodeStru {
    int pos;
    int stepLen;
    struct NodeStru *next;    
} NodeStru;

typedef struct LinkTab {
    int nodeNum;
    NodeStru *firstNode; 
} LinkTab;

int g_nodeNum;
LinkTab g_linkTab[MAX_NODE_NUM];

void CreateLinkTab(int sideNum, int **sideArr)
{
    NodeStru *tmpNode;

    /* 初始化所有节点边表 */
    for (int i = 0; i < g_nodeNum; i++) {
        g_linkTab[i].nodeNum = 0;
        g_linkTab[i].firstNode = NULL;
    }

    /* 加入边表 */
    for (int i = 0; i < sideNum; i++) {
        tmpNode = (NodeStru *)malloc(sizeof(NodeStru));
        tmpNode->pos = sideArr[i][1];
        tmpNode->stepLen = sideArr[i][2];
        tmpNode->next = g_linkTab[sideArr[i][0]].firstNode;
        g_linkTab[sideArr[i][0]].firstNode = tmpNode;
        g_linkTab[sideArr[i][0]].nodeNum++;
    }
}

———————————————————————————————————————————————————————

qsort

【使用场景】
快速排序，char / int / struct / 二级指针数组。

【代码模板】

/*************************************************
Function:		qsort
Description:	快速排序，char / int / struct / 二级指针数组
Input: 			无序数组
Output:			有序数组
Others:			无
*************************************************/
int CompareOneCh(const void *a, const void *b)
{
    char *ap = (char *)a;
    char *bp = (char *)b;
    return *ap - *bp;
}
qsort(oneCh, 4, sizeof(char), CompareOneCh);

int CompareOneInt(const void *a, const void *b)
{
    int *ap = (int *)a;
    int *bp = (int *)b;
    return *ap - *bp;
}
qsort(oneInt, 5, sizeof(int), CompareOneInt);

int CompareTwoCh(const void *a, const void *b)
{
    return strcmp((char *)a, (char *)b);
}
qsort(twoCh, 5, sizeof(twoCh[0]), CompareTwoCh);

int CompareTwoChPst(const void *a, const void *b)
{
    char *ap = *(char **)a;
    char *bp = *(char **)b;

    return strcmp(ap, bp);
}
qsort(twoChPst, 5, sizeof(twoChPst[0]), CompareTwoChPst);
    
int CompareTwoInt(const void *a, const void *b)
{
    return ((int *)a)[1] - ((int *)b)[1];
}
qsort(twoInt, 5, sizeof(twoInt[0]), CompareTwoInt);

int CompareTwoIntPst(const void *a, const void *b)
{
    int *ap = *(int **)a;
    int *bp = *(int **)b;

    return ap[1] - bp[1];
}
qsort(twoIntPst, 5, sizeof(twoIntPst[0]), CompareTwoIntPst);

typedef struct {
    int val1;
    int val2;
    char str[5];
} Test;

int CompareStru(const void *a, const void *b)
{
    Test *ap = (Test *)a;
    Test *bp = (Test *)b;

    if (ap->val1 != bp->val1) {
        return ap->val1 - bp->val1;
    } else if (ap->val2 != bp->val2) {
        return ap->val2 - bp->val2;
    } else {
        return strcmp(ap->str, bp->str);
    }
}
qsort(stru, 5, sizeof(stru[0]), CompareStru);

———————————————————————————————————————————————————————

广度优先（BFS）

【使用场景】
图遍历。

【代码模板】

/*************************************************
Function:		TraverseBfs
Description:	BFS
Input: 			
Output:			
Others:			无
*************************************************/
int TraverseBfs(char **wordList, int wordListSize, char *beginWord, char *endWord)
{
    int sum = 0;
    int seq = 0;
    int lay = 1;

    EnQueue(seq);

    while (!IsEmpty()) {
        sum = g_size;
        lay++;
        for (int i = 0; i < sum; i++) {
            seq = DeQueue();
            for (int j = 0; j < wordListSize; j++) {
                if (g_visit[j] == 0 && IsValid()) {
                    EnQueue(j);
                    g_visit[j] = 1;
                    if (IsDst()) {
                        return lay;
                    }
                }
            }
        }
    }

    return 0;
}

———————————————————————————————————————————————————————

并查集

【使用场景】
归并。
核心思想：
① 初始化每个点的父节点为其本身；
② 找出 当前点 的 根 ；
③ 刷新 当前点 的所有父节点为 根；
④ 合并：如果两个根不相等，其中一个根指向另一个根；
【代码模板】

#define MAX_NODE_NUM 10001

int g_pre[MAX_NODE_NUM];

void Init()
{
    for (int i = 0; i < MAX_NODE_NUM; i++) {
        g_pre[i] = i;
    }
}

int UnionSearch(int root)
{
    int son, tmp;
    
    son = root;
    while (g_pre[root] != root) {
        root = g_pre[root];
    }

    while (son != root) {
        tmp = g_pre[son];
        g_pre[son] = root;
        son = tmp;
    }

    return root;
}

bool Join(int a, int b)
{
    int rootA, rootB;

    rootA = UnionSearch(a);
    rootB = UnionSearch(b);

    if (rootA != rootB) {
        g_pre[rootA] = rootB;
        return false;
    }

    return true;
}

———————————————————————————————————————————————————————

二分查找

【使用场景】

【代码模板】

/*************************************************
Function:		BinarySearch
Description:	二分查找
Input: 			
Output:			
Others:			无
*************************************************/
int BinarySearch(int *array, int size, int key)
{
    int low = 0;
    int mid = 0;
    int high = size - 1;
    
    while (low <= high) {
        mid = low + (high - low) / 2;
        if (array[mid] > key) {
            high = mid - 1;
        } else if (array[mid] < key) {
            low = mid + 1;
        } else {
            // same fst
            while (array[mid] == array[mid - 1]) {
                mid--;
            }
            return mid;
        }
    }
    return -1;
}

———————————————————————————————————————————————————————

平衡二叉树

【使用场景】

【代码模板】

/*************************************************
Function:		AddNode
Description:	平衡二叉树添加节点
Input: 			
Output:			
Others:			无
*************************************************/
NodeStru *AddNode(NodeStru *root, int val)
{
    if (root == NULL) {
        root = (NodeStru *)malloc(sizeof(NodeStru));
        memset(root, 0, sizeof(NodeStru));
        root->val = val;
        return root;
    }
    if (root->val >= val ) {
        root->smartCnt++;
        root->left = AddNode(root->left, val);
    } else {
        g_maxValue += root->smartCnt + 1;
        root->right = AddNode(root->right, val);
    }
}

———————————————————————————————————————————————————————

单调栈

【使用场景】
核心思想：
① 初始化栈为0；
② 当前点 不满足单调特性，入栈 ；
③ 当前点 不满足特性，出栈，知道满足位置，压入栈；
【代码模板】

/*************************************************
Function:		MonoStack
Description:	单调栈
Input: 			
Output:			
Others:			无
*************************************************/
void MonoStack(int* T, int TSize, int *seqList)
{
    for (int i = 0; i < TSize; i++) {
        while (T[i] > T[g_stack[g_top]] && !IsEmpty()) {
            seqList[g_stack[g_top]] = i - g_stack[g_top];
            Pop();
        }
        Push(i);
    }
}

———————————————————————————————————————————————————————

全排列

【使用场景】
排列

【代码模板】

void SwapElem(char *s, int posA, int posB)
{
    char ch = s[posA];
    s[posA] = s[posB];
    s[posB] = ch;
}

bool IsValidElem(char *s, char ch)
{
    if (s[ch - 'a'] == 0) {
        return true;
    }
    return false;
}

void TraverseDfs(char **rst, char *s, int curSeq, int len)
{
    char usedElem[MAX_ELEM_NUM];

    memset(usedElem, 0, MAX_ELEM_NUM);

    if (curSeq == len - 1) {
        strcpy(rst[g_rstNum], s);
        printf("%s\n", s);
        g_rstNum++;
        return;
    }
    for (int i = curSeq; i < len; i++) {
        if (!IsValidElem(usedElem, s[i])) {
            continue;
        }
        usedElem[s[i] - 'a'] = 1;
        SwapElem(s, curSeq, i);
        TraverseDfs(rst, s, curSeq + 1, len);
        SwapElem(s, curSeq, i);
    }
}

———————————————————————————————————————————————————————

链表

【使用场景】
数据结构

【代码模板】

typedef struct NODE {
    char data;
    struct NODE *pNext;
} NODE, *LINK_NODE_STRU;

LINK_NODE_STRU CreateLinkList(int len)
{
    LINK_NODE_STRU pHead = NULL;
    LINK_NODE_STRU pNew = NULL;
    LINK_NODE_STRU pTail = NULL;

    pHead = (LINK_NODE_STRU)malloc(sizeof(NODE));

    if (pHead == NULL) {
        // return -1;
    }
    pHead->data = 0;
    pHead->pNext = NULL;
    pTail = pHead;

    for (int i = 0; i < len; i++) {
        pNew = (LINK_NODE_STRU)malloc(sizeof(NODE));
        if (pNew == NULL) {
            // return -1;
        }

        pNew->data = g_data[i];
        pNew->pNext = NULL;
        pTail->pNext = pNew;
        pTail = pNew;
    }

    return pHead;
}

void PrintLinkList(LINK_NODE_STRU pHead)
{
    LINK_NODE_STRU pCur;

    pCur = pHead->pNext;
    printf("\n");
    while (pCur != NULL) {
        printf("%c", pCur->data);
        pCur = pCur->pNext;
    }
}

int InsertLinkList(LINK_NODE_STRU pHead, char data)
{
    // 升序插入
    LINK_NODE_STRU pCur;
    LINK_NODE_STRU pLast;
    LINK_NODE_STRU pNew;

    pNew = (LINK_NODE_STRU)malloc(sizeof(NODE));
    if (pNew == NULL) {
        return -1;
    }

    pNew->data = data;
    pNew->pNext = NULL;
    pCur = pHead->pNext;

    // head
    if (pCur->data >= data) {
        pNew->pNext = pCur;
        pHead->pNext = pNew;
        return 0;
    }
    // mid
    while ((pCur->data < data) && ((pCur->pNext) != NULL)) {
        pLast = pCur;
        pCur = pCur->pNext;
    }
    // rear
    if ((pCur->data) < data) {
        pCur->pNext = pNew;
        pNew->pNext = NULL;
        return 0;
    }

    pLast->pNext = pNew;
    pNew->pNext = pCur;

    return 0;
}

int DeleteElem(LINK_NODE_STRU pHead, int num)
{
    int curNum = 0;
    P_LINKLIST_STRU pCur;
    P_LINKLIST_STRU pLast;

    pLast = pHead;
    pCur = pHead;

    while (pCur->pNext != NULL) {
        if (curNum == num) {
            pLast->pNext = pCur->pNext;
            free(pCur);
            return 0;
        }
        pLast = pCur;
        pCur = pCur->pNext;
        curNum++;
    }
    if ((pCur->pNext == NULL) && (curNum == num)) {
        pLast->pNext = NULL;
        free(pCur);
        return 0;
    }
    return -1;
}

int DeleteLinkList(LINK_NODE_STRU pHead, char data)
{
    LINK_NODE_STRU pCur;
    LINK_NODE_STRU pLast;

    pLast = pHead;
    pCur = pHead->pNext;

    while (pCur->pNext != NULL) {
        if (pCur->data == data) {
            pLast->pNext = pCur->pNext;
            free(pCur);
            pCur = pLast;
        }
        pLast = pCur;
        pCur = pCur->pNext;
    }

    //del rear
    if (pCur -> data == data) {
        pLast->pNext = NULL;
        free(pCur);
	}
    return 0;
}

———————————————————————————————————————————————————————

滑动窗口

【使用场景】

【代码模板】

/*************************************************
Function:		SlideWindow
Description:	滑动窗口
Input: 			
Output:			
Others:			无
*************************************************/
int SlideWindow(int s, int *nums, int numsSize)
{
    int len;
    int minLen = INT_MAX;
    int leftSeq = 0;
    int rightSeq = 0;
    long sum = 0;

    while (rightSeq < numsSize) {
        sum += nums[rightSeq];               // 右边界移动 找第一个满足条件
        while (sum >= s && leftSeq <= rightSeq) {
            len = rightSeq - leftSeq + 1;
            if (len < minLen) {
                minLen = len;
            }
            sum -= nums[leftSeq];
            leftSeq++;                      // 左边界移动 找第一个不满足条件
        }
        rightSeq++;
    }

    return minLen;
}

———————————————————————————————————————————————————————

哈希

【使用场景】
查找、排序

【代码模板】

haxi,1=
typedef struct {
    int row;
    int col;
}Pos;

typedef struct HashStru {
    Pos key;
    int val;
    UT_hash_handle hh;
}Hash;

Hash *g_hash = NULL;

void AddElem(Pos key, int val)
{
    Hash *hash;
    HASH_FIND(hh, g_hash, &key, sizeof(Pos), hash);
    if (hash==NULL) {
        hash = (Hash *)malloc(sizeof(Hash));
        hash->key.row = key.row;
        hash->key.col = key.col;
        HASH_ADD(hh, g_hash, key, sizeof(Pos), hash);
    }
    hash->val = val;
}

Hash *FindElem(Pos key)
{
    Hash *hash;
    HASH_FIND(hh, g_hash, &key, sizeof(Pos), hash);
    return hash;
}

void DelHash()
{
    Hash *hash, *tmp;

    HASH_ITER(hh, g_hash, hash, tmp) {
        HASH_DEL(g_hash, hash);
        free(hash);
    }
}


haxi,2=
typedef struct myhash {
    int key;
    int val;
    UT_hash_handle hh; 
}hash;

hash *g_hash = NULL; 

void AddHash(int a)
{
    hash *s;
    // int key = (int)a; //a char

    HASH_FIND_INT(g_hash, &a, s);
    if (s) {
        printf("%d\n", s->val);
    } else {
        s = (hash *)malloc(sizeof(hash));
        s->key = a;
        s->val = 1;
        HASH_ADD_INT(g_hash, key, s);
    }
}

void UpdateHash(int key, int newval)
{
    hash *s;
    // int key = (int)a; //a char

    HASH_FIND_INT(g_hash, &key, s);
    if (s) {
        printf("%d\n", s->val);
        s->val = newval;
    } else {
        s = (hash *)malloc(sizeof(hash));
        s->key = key;
        s->val = newval;
        HASH_ADD_INT(g_hash, key, s);
    }    
}

void DelOneKey(int key)
{
    hash *s;
    // int key = (int)a; //a char

    HASH_FIND_INT(g_hash, &key, s);

    if (s) {
        HASH_DEL(g_hash, s);
        free(s);
    }    
}

void DelHash()
{
    hash *s, *tmp;

    HASH_ITER(hh, g_hash, s, tmp) {
        HASH_DEL(g_hash, s);
        free(s);
    }
}

void IterHash()
{
    hash *s, *tmp;

    HASH_ITER(hh, g_hash, s, tmp) {
        printf("key(%d)  val(%d)   ", s->key, s->val);
    } 
    printf("\n**************\n");
}

int Compare(hash *a, hash *b)
{
    return (a->key - b->key); 
}

void SortHash()
{
    HASH_SORT(g_hash, cmp);
}

———————————————————————————————————————————————————————

常用字符处理函数

【ctype.h】

int isalnum(int ch) int isalpha(int ch) int isdigit(int ch)
int islower(int ch) int isupper(int ch) int isspace(int ch)
int isxdigit(int ch) int tolower(int ch) int toupper(int ch)
int sscanf(const char *buffer, const char *format, …)
int sprintf(char *buffer, const char *format, …)
SWJTU_LiSanShi
关注
专栏目录
算法模板整理
Y.W.jian的博客
07-21 1773
---------------------转载请注明出处--------------------------- ---------------------转载请注明出处--------------------------- ---------------------转载请注明出处--------------------------- 文章目录二叉树总模板二分搜索树模板单调栈基础模板循环数组模板单调队列二分查找二分查找模板基本二分查找左侧边界二分查找右侧边界二分查找双指针快慢指针左右指针滑动窗滑动窗模板回溯算
Python基础训练100题（带答案），刷题一时爽，一直刷题一直爽
m0_64355682的博客
12-31 7774
Python3 100例 实例001：数字组合 题目 有四个数字：1、2、3、4，能组成多少个互不相同且无重复数字的三位数？各是多少？ 程序分析 遍历全部可能，把有重复的剃掉。 total=0 for i in range(1,5): for j in range(1,5): for k in range(1,5): if ((i!=j)and(j!=k)and(k!=i)): print(i,j,k)
多目标进化算法中的归档方法——聚类（Clustering）
weixin_45799452的博客
03-31 1364
背景： 多目标进化算法一般最终是获得一组非支配解。 归档的必要性： 有些优化问题的非支配解数量非常巨大，然而电脑资源却是有限的，并且决策者只可能在有限的方案中选择自己感兴趣的一种。归档方法是将具有代表性的非支配解保存下来，使得最终获得的非支配解广泛的分布在解空间。 聚类方法的思想： 为了从大小为N的种群中形成N个簇（N为归档的大小），需要用欧氏距离来计算目标空间中点的距离，然后将具有最小距离的两个...
排序算法-整理归档
wangqing008的专栏
09-28 606
TODO tomorrow
java写一个文件归档的算法
NON blog
09-11 883
文件归档就是将多个小文件归档形成一个大的文件，然后在进行解归档的算法进行还原。 直接看源代码： 核心归档文件类：package com.wang.archiver;import java.io.BufferedInputStream; import java.io.BufferedOutputStream; import java.io.File; import java.io.FileInpu
归档大小日志计算
luckchang的专栏
09-18 2905
redo日志切换频率推算出存放归档日志所需的空间 我们可以通过日志切换频率推算出存放归档日志所需的空间，这样对存储规划有很好的指导意义。 可以按照如下步骤完成归档日志空间规划预估任务。 1.查看数据库日志文件的大小 sys@bomsdb> select distinct(bytes/1024/1024) MB from v$log;         MB ----------    
leetcode中国-LeetCodeIsNothing:算法题整理总结归档
06-29
birdguan的刷题斗争之路 仪式先来一波 :folded_hands: :folded_hands: :folded_hands: :folded_hands: :folded_hands: :folded_hands: :folded_hands: :folded_hands: :folded_hands: :folded_hands: :folded_hands:...
leetcode最大蓄水量-leetcode_note_book:leetcode题目分类及刷题总结
06-30
Leetcode题目分类及刷题心得 算法题目列表 总数 归档：20 未归档：30 Array 题目 说明 状态 TowSum 两数之和 完成 MedianOfTwoSortArrays 两有序数组的中位数 完成 NextPermutation 下一排序 完成 DFS 题目 说明 ...
2017-我的秋招之路 机器学习/算法工程师 含大量面经
hdfyhf的博客
11-16 1136
2017-我的秋招之路 机器学习/算法工程师 含大量面经
夯实Java基础系列5：Java文件和Java包结构
Java技术江湖
04-24 5548
本文主要介绍了抽象类和接口的特性和使用方法。 具体代码在我的GitHub中可以找到 https://github.com/h2pl/MyTech 文章首发于我的个人博客： https://h2pl.github.io/2018/04/24/javase5 1 抽象类一般会实现一部分操作，并且留一些抽象方法让子类自己实现，比如Stringbuffer和Stringbuilder的父类...
归档— NSKeyedArchiver
12-23 351
// // main.m // OC语言学习 #import int main(int argc, const char * argv[]) { /* 在OC语言中，归档是一个过程，即用某种格式来保存一个或多个对象，以便以后还原这些对象。 通常，这个过程包括将多个对象写入文件中，以便以后读取该对象。 */ @autoreleas
5253-微信小程序基于springboot汽车维修管理系统微信小程序springboot（源码+数据库+lun文）.zip
09-15
本系统主要针对计算机相关专业的正在做毕业设计的学生和需要项目实战练习的学习者，可作为毕业设计、课程设计、期末大作业。本系统主要针对计算机相关专业的正在做毕业设计的学生和需要项目实战练习的学习者，可作为毕业设计、课程设计、期末大作业。本系统主要针对计算机相关专业的正在做毕业设计的学生和需要项目实战练习的学习者，可作为毕业设计、课程设计、期末大作业。本系统主要针对计算机相关专业的正在做毕业设计的学生和需要项目实战练习的学习者，可作为毕业设计、课程设计、期末大作业。本系统主要针对计算机相关专业的正在做毕业设计的学生和需要项目实战练习的学习者，可作为毕业设计、课程设计、期末大作业。本系统主要针对计算机相关专业的正在做毕业设计的学生和需要项目实战练习的学习者，可作为毕业设计、课程设计、期末大作业。
基于Matlab界面GUI设计的身份证号码识别源码[Matlab界面GUI设计].zip
09-15
基于
1.开源数据库MySQL DBA运维实战 第1章 部署.学习笔记整理分享给需要的同学
最新发布
09-15
1.开源数据库MySQL DBA运维实战 第1章 部署.学习笔记整理分享给需要的同学
java写s7和plc通讯
09-15
java写s7和plc通讯
基于 Flask 的书评系统.zip
09-15
这是一个基于 Flask 框架的书评系统项目。用户可以通过注册登录系统，对书籍进行搜索、发表评论以及查看其他用户的评论。项目利用 Goodreads 的第三方 API，引入更广泛的读者评分。此外，用户还可以通过应用程序的 API 以编程方式查询书籍详情和书评。项目具有注册、登录、注销、书籍导入、搜索、书籍页面展示、评论提交、Goodreads 评级数据展示和 aPI 访问等功能。 1、资源项目源码均已通过严格测试验证，保证能够正常运行； 2、项目问题、技术讨论，可以给博主私信或留言，博主看到后会第一时间与您进行沟通； 3、本项目比较适合计算机领域相关的毕业设计课题、课程作业等使用，尤其对于人工智能、计算机科学与技术等相关专业，更为适合； 4、下载使用后，可先查看ReadME.md文件（如有），本项目仅用作交流学习参考，请切勿用于商业用途。
【前景培训教材】第二十一章 路测问题点分析.pdf
09-15
以下是对提供的参考资料的总结，按照要求结构化多个要点分条输出： 4G/5G无线网络优化与网规案例分析： NSA站点下终端掉4G问题：部分用户反馈NSA终端频繁掉4G，主要因终端主动发起SCGfail导致。分析显示，在信号较好的环境下，终端可能因节能、过热保护等原因主动释放连接。解决方案建议终端侧进行分析处理，尝试关闭节电开关等。 RSSI算法识别天馈遮挡：通过计算RSSI平均值及差值识别天馈遮挡，差值大于3dB则认定有遮挡。不同设备分组规则不同，如64T和32T。此方法可有效帮助现场人员识别因环境变化引起的网络问题。 5G 160M组网小区CA不生效：某5G站点开启100M+60M CA功能后，测试发现UE无法正常使用CA功能。问题原因在于CA频点集标识配置错误，修正后测试正常。 5G网络优化与策略： CCE映射方式优化：针对诺基亚站点覆盖农村区域，通过优化CCE资源映射方式（交织、非交织），提升RRC连接建立成功率和无线接通率。非交织方式相比交织方式有显著提升。 5G AAU两扇区组网：与三扇区组网相比，AAU两扇区组网在RSRP、SINR、下载速率和上传速率上表现不同，需根据具体场景选择适合的组网方式。 5G语音解决方案：包括沿用4G语音解决方案、EPS Fallback方案和VoNR方案。不同方案适用于不同的5G组网策略，如NSA和SA，并影响语音连续性和网络覆盖。 4G网络优化与资源利用： 4G室分设备利旧：面对4G网络投资压减与资源需求矛盾，提出利旧多维度调优策略，包括资源整合、统筹调配既有资源，以满足新增需求和提质增效。 宏站RRU设备1托N射灯：针对5G深度覆盖需求，研究使用宏站AAU结合1托N射灯方案，快速便捷地开通5G站点，提升深度覆盖能力。 基站与流程管理： 爱立信LTE基站邻区添加流程：未提供具体内容，但通常涉及邻区规划、参数配置、测试验证等步骤，以确保基站间顺畅切换和覆盖连续性。 网络规划与策略： 新高铁跨海大桥覆盖方案试点：虽未提供详细内容，但可推测涉及高铁跨海大桥区域的4G/5G网络覆盖规划，需考虑信号穿透、移动性管理、网络容量等因素。 总结： 提供的参考资料涵盖了4G/5G无线网络优化、网规案例分析、网络优化策略、资源利用、基站管理等多个方面。 通过具体案例分析，展示了无线网络优化中的常见问题及解决方案，如NSA终端掉4G、RSSI识别天馈遮挡、CA不生效等。 强调了5G网络优化与策略的重要性，包括CCE映射方式优化、5G语音解决方案、AAU扇区组网选择等。 提出了4G网络优化与资源利用的策略，如室分设备利旧、宏站RRU设备1托N射灯等。 基站与流程管理方面，提到了爱立信LTE基站邻区添加流程，但未给出具体细节。 新高铁跨海大桥覆盖方案试点展示了特殊场景下的网络规划需求。
5332-微信小程序摄影竞赛小程序（源码+数据库）.zip
09-15
本系统主要针对计算机相关专业的正在做毕业设计的学生和需要项目实战练习的学习者，可作为毕业设计、课程设计、期末大作业。本系统主要针对计算机相关专业的正在做毕业设计的学生和需要项目实战练习的学习者，可作为毕业设计、课程设计、期末大作业。本系统主要针对计算机相关专业的正在做毕业设计的学生和需要项目实战练习的学习者，可作为毕业设计、课程设计、期末大作业。本系统主要针对计算机相关专业的正在做毕业设计的学生和需要项目实战练习的学习者，可作为毕业设计、课程设计、期末大作业。
气象监测Web应用.zip
09-15
这是一个基于Python的web应用程序，使用了Flask框架、Bootstrap和JQuery技术。该程序可能用于气象数据的展示、监测和预警等功能。由于项目描述较为简洁，具体功能和细节实现尚不清楚，建议进一步查看项目代码和相关文档以获取更多信息。 1、资源项目源码均已通过严格测试验证，保证能够正常运行； 2、项目问题、技术讨论，可以给博主私信或留言，博主看到后会第一时间与您进行沟通； 3、本项目比较适合计算机领域相关的毕业设计课题、课程作业等使用，尤其对于人工智能、计算机科学与技术等相关专业，更为适合； 4、下载使用后，可先查看README.md文件（如有），本项目仅用作交流学习参考，请切勿用于商业用途。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值