嵌入式学习DAY21 --- 数据结构（双向链表、栈、队列）_队列、栈、双向链表

2401_84247617

于 2024-05-04 08:54:26 发布

阅读量720

点赞数 15

分类专栏：程序员文章标签：数据结构学习链表

本文链接：https://blog.csdn.net/2401_84247617/article/details/138434560

版权

程序员专栏收录该内容

218 篇文章 0 订阅

订阅专栏

HEAD,
DOUBLE_LINK_ERR,
DOUBLE_LINK_OK

};

DoubleLink *createDoubleLink();
int insertItemDoubleLink(DoubleLink *pLink, int iOffset, data_t tData);
int deleteItemDoubleLink(DoubleLink *pLink, int iOffset, data_t *pData);
void showDoubleLink(DoubleLink *pLink);
void destroyDoubleLink(DoubleLink **ppLink);

#endif


***第二步：doublelink.c***

#include<stdio.h>
#include “doubleLink.h”
#include <stdlib.h>
#include <string.h>

DoubleLink *createDoubleLink()
{
DoubleLink *pLink = (DoubleLink *)malloc(sizeof(DoubleLink));
if(NULL == pLink)
{
return NULL;
}
memset(pLink, 0, sizeof(DoubleLink));
return pLink;
}

int insertItemDoubleLink(DoubleLink *pLink, int iOffset, data_t tData)
{
if(NULL == pLink || iOffset < -1)
{
return DOUBLE_LINK_ERR;
}

DoubleLinkNode \*pNode = (DoubleLinkNode \*)malloc(sizeof(DoubleLinkNode));
if(NULL == pNode)
{
	return DOUBLE_LINK_ERR;
}
memset(pNode, 0, sizeof(DoubleLinkNode));
pNode->data = tData;

//如果是空链表
if(0 == pLink->count)
{
	pLink->pHead = pNode;
	pLink->count++;
	return DOUBLE_LINK_OK;
}

DoubleLinkNode \*pTmp = pLink->pHead;

//如果iOffset的值很大，就直接插入到末尾
if(iOffset >= pLink->count)
{
	iOffset = TAIL;
}
int i;
switch(iOffset)
{
	case HEAD:
		pNode->pNext = pLink->pHead;
		pLink->pHead->pPri = pNode;
		pLink->pHead = pNode;
		break;
	case TAIL:
		while(pTmp->pNext != NULL)
		{
			pTmp = pTmp->pNext;
		}
		pTmp->pNext = pNode;
		pNode->pPri = pTmp;
		break;
	default:
		//中间插入
	    for(i = 0; i < iOffset-1; i++)
		{
			pTmp = pTmp->pNext;
		}
		pNode->pNext = pTmp->pNext;
		pTmp->pNext->pPri = pNode;
		pNode->pPri = pTmp;
		pTmp->pNext = pNode;
		break;
}
pLink->count++;
return DOUBLE_LINK_OK;

}
int deleteItemDoubleLink(DoubleLink *pLink, int iOffset, data_t *pData)
{
if(NULL == pLink || NULL == pLink->pHead || NULL == pData || iOffset < -1)
{
return DOUBLE_LINK_ERR;
}

DoubleLinkNode \*pDel = pLink->pHead;
DoubleLinkNode \*pTmp = pLink->pHead;
int i;

//如果iOffset很大，就尾删
if(iOffset >= pLink->count-1)
{
	iOffset = TAIL;
}

switch(iOffset)
{
	case HEAD:
		pLink->pHead = pDel->pNext;
		pLink->pHead->pPri = NULL;
		break;
	case TAIL:
		pDel = pTmp->pNext;
		//如果只剩下一个节点
		if(NULL == pDel)
		{
			pDel = pTmp;
			break;
		}
		while(pDel->pNext != NULL)
		{

			pTmp = pTmp->pNext;
			pDel = pTmp->pNext;
		}
		pTmp->pNext = NULL;
		break;
	default:
		for(i = 0; i < iOffset-1; i++)
		{
			pTmp = pTmp->pNext;
		}
		pDel = pTmp->pNext;
		pTmp->pNext = pDel->pNext;
		pDel->pNext->pPri = pTmp;
        
}
\*pData = pDel->data;
free(pDel);
pDel = NULL;
pLink->count--;
return DOUBLE_LINK_OK;

}
void showDoubleLink(DoubleLink *pLink)
{
if(NULL == pLink || NULL == pLink->pHead)
{
return;
}
DoubleLinkNode *pTmp = pLink->pHead;
while(pTmp != NULL)
{
printf(“%d “, pTmp->data);
pTmp = pTmp->pNext;
}
printf(”\n”);
}

void destroyDoubleLink(DoubleLink **ppLink)
{
if(NULL == ppLink || NULL == *ppLink)
{
return;
}

DoubleLinkNode \*pDel = (\*ppLink)->pHead;
while(pDel != NULL)
{
	(\*ppLink)->pHead = pDel->pNext;
	free(pDel);
	pDel = (\*ppLink)->pHead;
}
free(\*ppLink);
\*ppLink = NULL;

}


第三步：main.c

#include<stdio.h>
#include “doubleLink.h”

int main()
{
DoubleLink *pLink = createDoubleLink();
insertItemDoubleLink(pLink, HEAD, 100);
insertItemDoubleLink(pLink, HEAD, 200);
insertItemDoubleLink(pLink, HEAD, 300);
insertItemDoubleLink(pLink, TAIL, 888);
insertItemDoubleLink(pLink, 2, 999);

showDoubleLink(pLink);
data_t data;
deleteItemDoubleLink(pLink, HEAD, &data);
showDoubleLink(pLink);
deleteItemDoubleLink(pLink, TAIL, &data);
showDoubleLink(pLink);
deleteItemDoubleLink(pLink, 1, &data);
showDoubleLink(pLink);

destroyDoubleLink(&pLink);
return 0;

}


二、栈和队列  
 1、栈和队列都是属于线性表  
 2、什么是线性表？—元素和元素之间的逻辑关系是一对一，那么就是线性表  
 3、线性表有两种存储结构：顺序存储 链式存储  
 4、顺序表----顺序存储的线性表  
 5、链表----链式存储的线性表  
 所以：栈有顺序栈也有链式栈、队列有顺序队列也有链式队列


本质上栈和队列都是线性表，只不过我们之前讲的顺序表和单链表对于哪里插入和哪里删除没有限制，头部、中间、尾部随便，无所谓，你需要哪种操作，都有，但是栈和队列就对顺序表和单链表的插入和删除操作进行了限制


栈只允许在头部插入和删除  
 队列只能在尾部插入，头部删除


顺序栈：  
 回忆顺序表：

Struct List
{
Data_t data[SIZE];
Int count;
};


![在这里插入图片描述](https://img-blog.csdnimg.cn/20210322190729536.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1NwcmluZ1dKTg==,size_16,color_FFFFFF,t_70)

Struct seqStack
{
Data_t data[SIZE];
Int iTop; //栈顶元素的下标，初始值：-1，表示没有元素
};


顺序队列：  
 ![在这里插入图片描述](https://img-blog.csdnimg.cn/20210322191219814.png)

Struct seqQueue
{
Data_t data[SIZE];
Int iFront; //队头的下标
Int iRear; //队尾的下标
Int count; //当前队列的元素个数
};


***顺序栈代码实现***


*一.stack.h*

#ifndef _STACK_H_
#define _STACK_H_

#define SIZE 5

typedef int data_t;

typedef struct Stack
{
data_t data[SIZE];
int iTop;
}Stack;

enum STACK_OP
{
STACK_ERR = -1,
STACK_OK,
STACK_FULL,
STACK_EMPTY
};

Stack *createStack();
int pushStack(Stack *pStack, data_t tData);
int popStack(Stack *pStack, data_t *pData);
void destroyStack(Stack **ppStack);
int isEmpty(Stack *pStack);
int isFull(Stack *pStack);

#endif


*二：stack.c*

#include<stdio.h>
#include “stack.h”
#include <stdlib.h>
#include <string.h>

Stack *createStack()
{
Stack *pStack = (Stack *)malloc(sizeof(Stack));
if(NULL == pStack)
{
return NULL;
}

memset(pStack, 0, sizeof(Stack));
pStack->iTop = -1;
return pStack;

}

//入栈
int pushStack(Stack *pStack, data_t tData)
{
if(NULL == pStack)
{
return STACK_ERR;
}
pStack->iTop++;
pStack->data[pStack->iTop] = tData;
return STACK_OK;
}

//出栈
int popStack(Stack *pStack, data_t *pData)
{
if(NULL == pStack || NULL == pData)
{
return STACK_ERR;
}
*pData = pStack->data[pStack->iTop];
pStack->iTop–;
return STACK_OK;
}

void destroyStack(Stack **ppStack)
{
if(NULL == *ppStack || NULL == ppStack)
{
return;
}
free(*ppStack);
*ppStack = NULL;
}

int isEmpty(Stack *pStack)
{
if(NULL == pStack)
{
return STACK_ERR;
}
if(-1 == pStack->iTop)
{
return STACK_EMPTY;
}
return STACK_OK;
}

int isFull(Stack *pStack)
{
if(NULL == pStack)
{
return STACK_ERR;
}
if(SIZE == pStack->iTop+1)
{
return STACK_FULL;
}
return STACK_OK;
}


*三：main.c*

#include<stdio.h>
#include “stack.h”

int main()
{
Stack *pStack = createStack();

data_t data;
//如果栈不满，就入栈
while(STACK_FULL != isFull(pStack))
{
	scanf("%d", &data);

还有兄弟不知道网络安全面试可以提前刷题吗？费时一周整理的160+网络安全面试题，金九银十，做网络安全面试里的显眼包！

王岚嵚工程师面试题（附答案），只能帮兄弟们到这儿了！如果你能答对70%，找一个安全工作，问题不大。

对于有1-3年工作经验，想要跳槽的朋友来说，也是很好的温习资料！

【完整版领取方式在文末！！】

93道网络安全面试题

内容实在太多，不一一截图了

黑客学习资源推荐

最后给大家分享一份全套的网络安全学习资料，给那些想学习网络安全的小伙伴们一点帮助！

对于从来没有接触过网络安全的同学，我们帮你准备了详细的学习成长路线图。可以说是最科学最系统的学习路线，大家跟着这个大的方向学习准没问题。

😝朋友们如果有需要的话，可以联系领取~

1️⃣零基础入门

① 学习路线

对于从来没有接触过网络安全的同学，我们帮你准备了详细的学习成长路线图。可以说是最科学最系统的学习路线，大家跟着这个大的方向学习准没问题。

② 路线对应学习视频

同时每个成长路线对应的板块都有配套的视频提供：

2️⃣视频配套工具&国内外网安书籍、文档

① 工具

② 视频

③ 书籍

资源较为敏感，未展示全面，需要的最下面获取

在这里插入图片描述

② 简历模板

在这里插入图片描述

因篇幅有限，资料较为敏感仅展示部分资料，添加上方即可获取👆

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化资料的朋友，可以点击这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

2401_84247617

关注

15
点赞
踩
25

收藏

觉得还不错? 一键收藏
0
评论
嵌入式学习DAY21 --- 数据结构（双向链表、栈、队列）_队列、栈、双向链表

while(pTmp!第三步：main.cint main()Int count;Int iTop;//栈顶元素的下标，初始值：-1，表示没有元素Int iFront;//队头的下标Int iRear;//队尾的下标Int count;//当前队列的元素个数。
复制链接

扫一扫