先自我介绍一下,小编浙江大学毕业,去过华为、字节跳动等大厂,目前阿里P7
深知大多数程序员,想要提升技能,往往是自己摸索成长,但自己不成体系的自学效果低效又漫长,而且极易碰到天花板技术停滞不前!
因此收集整理了一份《2024年最新Golang全套学习资料》,初衷也很简单,就是希望能够帮助到想自学提升又不知道该从何学起的朋友。
既有适合小白学习的零基础资料,也有适合3年以上经验的小伙伴深入学习提升的进阶课程,涵盖了95%以上Go语言开发知识点,真正体系化!
由于文件比较多,这里只是将部分目录截图出来,全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频,并且后续会持续更新
如果你需要这些资料,可以添加V获取:vip1024b (备注go)
正文
- This routine pulls lstLib into the vxWorks image.
- RETURNS: N/A
*/
void lstLibInit (void)
{
return;
}
/*********************************************************************
*
- lstInit - initialize a list descriptor
- This routine initializes a specified list to an empty list.
- RETURNS: N/A
*/
void lstInit
(
FAST LIST pList / ptr to list descriptor to be initialized /
)
{
pList->HEAD = NULL;
pList->TAIL = NULL;
pList->count = 0;
}
/************************************************************************
*
- lstAdd - add a node to the end of a list
- This routine adds a specified node to the end of a specified list.
- RETURNS: N/A
*/
void lstAdd
(
LIST pList, / pointer to list descriptor /
NODE pNode / pointer to node to be added /
)
{
lstInsert (pList, pList->TAIL, pNode);
}
/************************************************************************
*
- lstConcat - concatenate two lists
- This routine concatenates the second list to the end of the first list.
- The second list is left empty. Either list (or both) can be
- empty at the beginning of the operation.
- RETURNS: N/A
*/
void lstConcat
(
FAST LIST pDstList, / destination list */
FAST LIST pAddList / list to be added to dstList /
)
{
if (pAddList->count == 0) / nothing to do if AddList is empty */
return;
if (pDstList->count == 0)
*pDstList = pAddList;
else
{
/ both lists non-empty; update DstList pointers */
pDstList->TAIL->next = pAddList->HEAD;
pAddList->HEAD->previous = pDstList->TAIL;
pDstList->TAIL = pAddList->TAIL;
pDstList->count += pAddList->count;
}
/* make AddList empty */
lstInit (pAddList);
}
/**************************************************************************
*
- lstCount - report the number of nodes in a list
- This routine returns the number of nodes in a specified list.
- RETURNS:
- The number of nodes in the list.
*/
int lstCount
(
LIST pList / pointer to list descriptor /
)
{
return (pList->count);
}
/*************************************************************************
*
- lstDelete - delete a specified node from a list
- This routine deletes a specified node from a specified list.
- RETURNS: N/A
*/
void lstDelete
(
FAST LIST pList, / pointer to list descriptor */
FAST NODE pNode / pointer to node to be deleted */
)
{
if (pNode->previous == NULL)
pList->HEAD = pNode->next;
else
pNode->previous->next = pNode->next;
if (pNode->next == NULL)
pList->TAIL = pNode->previous;
else
pNode->next->previous = pNode->previous;
/* update node count */
pList->count–;
}
/************************************************************************
*
- lstExtract - extract a sublist from a list
- This routine extracts the sublist that starts with and ends
- with from a source list. It places the extracted list in
- .
- RETURNS: N/A
*/
void lstExtract
(
FAST LIST pSrcList, / pointer to source list */
FAST NODE pStartNode, / first node in sublist to be extracted */
FAST NODE pEndNode, / last node in sublist to be extracted */
FAST LIST pDstList / ptr to list where to put extracted list */
)
{
FAST int i;
FAST NODE *pNode;
/* fix pointers in original list */
if (pStartNode->previous == NULL)
pSrcList->HEAD = pEndNode->next;
else
pStartNode->previous->next = pEndNode->next;
if (pEndNode->next == NULL)
pSrcList->TAIL = pStartNode->previous;
else
pEndNode->next->previous = pStartNode->previous;
/* fix pointers in extracted list */
pDstList->HEAD = pStartNode;
pDstList->TAIL = pEndNode;
pStartNode->previous = NULL;
pEndNode->next = NULL;
/* count number of nodes in extracted list and update counts in lists */
i = 0;
for (pNode = pStartNode; pNode != NULL; pNode = pNode->next)
i++;
pSrcList->count -= i;
pDstList->count = i;
}
/************************************************************************
*
- lstFirst - find first node in list
- This routine finds the first node in a linked list.
- RETURNS
- A pointer to the first node in a list, or
- NULL if the list is empty.
*/
NODE lstFirst
(
LIST pList / pointer to list descriptor /
)
{
return (pList->HEAD);
}
/**********************************************************************
*
- lstGet - delete and return the first node from a list
- This routine gets the first node from a specified list, deletes the node
- from the list, and returns a pointer to the node gotten.
- RETURNS
- A pointer to the node gotten, or
- NULL if the list is empty.
*/
NODE *lstGet
(
FAST LIST pList / ptr to list from which to get node */
)
{
FAST NODE *pNode = pList->HEAD;
if (pNode != NULL) /* is list empty? /
{
pList->HEAD = pNode->next; / make next node be 1st */
if (pNode->next == NULL) /* is there any next node? /
pList->TAIL = NULL; / no - list is empty /
else
pNode->next->previous = NULL; / yes - make it 1st node */
pList->count–; /* update node count */
}
return (pNode);
}
/************************************************************************
*
- lstInsert - insert a node in a list after a specified node
- This routine inserts a specified node in a specified list.
- The new node is placed following the list node .
- If is NULL, the node is inserted at the head of the list.
- RETURNS: N/A
*/
void lstInsert
(
FAST LIST pList, / pointer to list descriptor */
FAST NODE pPrev, / pointer to node after which to insert */
FAST NODE pNode / pointer to node to be inserted */
)
{
FAST NODE *pNext;
if (pPrev == NULL)
{ /* new node is to be first in list /
pNext = pList->HEAD;
pList->HEAD = pNode;
}
else
{ / make prev node point fwd to new */
pNext = pPrev->next;
pPrev->next = pNode;
}
if (pNext == NULL)
pList->TAIL = pNode; /* new node is to be last in list /
else
pNext->previous = pNode; / make next node point back to new */
/* set pointers in new node, and update node count */
pNode->next = pNext;
pNode->previous = pPrev;
pList->count++;
}
/************************************************************************
*
- lstLast - find the last node in a list
- This routine finds the last node in a list.
- RETURNS
- A pointer to the last node in the list, or
- NULL if the list is empty.
*/
NODE lstLast
(
LIST pList / pointer to list descriptor /
)
{
return (pList->TAIL);
}
/**********************************************************************
*
- lstNext - find the next node in a list
- This routine locates the node immediately following a specified node.
- RETURNS:
- A pointer to the next node in the list, or
- NULL if there is no next node.
*/
NODE lstNext
(
NODE pNode / ptr to node whose successor is to be found /
)
{
return (pNode->next);
}
/**********************************************************************
*
- lstNth - find the Nth node in a list
- This routine returns a pointer to the node specified by a number
- where the first node in the list is numbered 1.
- Note that the search is optimized by searching forward from the beginning
- if the node is closer to the head, and searching back from the end
- if it is closer to the tail.
- RETURNS:
- A pointer to the Nth node, or
- NULL if there is no Nth node.
*/
NODE *lstNth
(
FAST LIST pList, / pointer to list descriptor /
FAST int nodenum / number of node to be found */
)
{
FAST NODE *pNode;
/* verify node number is in list */
if ((nodenum < 1) || (nodenum > pList->count))
return (NULL);
/* if nodenum is less than half way, look forward from beginning;
otherwise look back from end */
if (nodenum < (pList->count >> 1))
{
pNode = pList->HEAD;
while (–nodenum > 0)
pNode = pNode->next;
}
else
{
nodenum -= pList->count;
pNode = pList->TAIL;
while (nodenum++ < 0)
pNode = pNode->previous;
}
return (pNode);
}
/************************************************************************
*
- lstPrevious - find the previous node in a list
- This routine locates the node immediately preceding the node pointed to
- by .
- RETURNS:
- A pointer to the previous node in the list, or
- NULL if there is no previous node.
*/
NODE lstPrevious
(
NODE pNode / ptr to node whose predecessor is to be found /
)
{
return (pNode->previous);
}
/**********************************************************************
*
- lstNStep - find a list node steps away from a specified node
- This routine locates the node steps away in either direction from
- a specified node. If is positive, it steps toward the tail. If
- is negative, it steps toward the head. If the number of steps is
- out of range, NULL is returned.
- RETURNS:
- A pointer to the node steps away, or
- NULL if the node is out of range.
*/
NODE *lstNStep
(
FAST NODE pNode, / the known node /
int nStep / number of steps away to find */
)
{
int i;
for (i = 0; i < abs (nStep); i++)
{
if (nStep < 0)
pNode = pNode->previous;
else if (nStep > 0)
pNode = pNode->next;
if (pNode == NULL)
break;
}
return (pNode);
}
/************************************************************************
*
- lstFind - find a node in a list
- This routine returns the node number of a specified node (the
- first node is 1).
- RETURNS:
- The node number, or
- ERROR if the node is not found.
*/
int lstFind
(
LIST pList, / list in which to search */
FAST NODE pNode / pointer to node to search for */
)
{
FAST NODE *pNextNode;
FAST int index = 1;
pNextNode = lstFirst (pList);
while ((pNextNode != NULL) && (pNextNode != pNode))
网上学习资料一大堆,但如果学到的知识不成体系,遇到问题时只是浅尝辄止,不再深入研究,那么很难做到真正的技术提升。
需要这份系统化的资料的朋友,可以添加V获取:vip1024b (备注Go)
一个人可以走的很快,但一群人才能走的更远!不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人,都欢迎加入我们的的圈子(技术交流、学习资源、职场吐槽、大厂内推、面试辅导),让我们一起学习成长!
rch */
FAST NODE pNode / pointer to node to search for */
)
{
FAST NODE *pNextNode;
FAST int index = 1;
pNextNode = lstFirst (pList);
while ((pNextNode != NULL) && (pNextNode != pNode))
网上学习资料一大堆,但如果学到的知识不成体系,遇到问题时只是浅尝辄止,不再深入研究,那么很难做到真正的技术提升。
需要这份系统化的资料的朋友,可以添加V获取:vip1024b (备注Go)
[外链图片转存中…(img-0c9nQrvR-1713439397586)]
一个人可以走的很快,但一群人才能走的更远!不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人,都欢迎加入我们的的圈子(技术交流、学习资源、职场吐槽、大厂内推、面试辅导),让我们一起学习成长!