数据结构--初识栈和队列

已于 2023-07-03 15:19:04 修改
阅读量303 收藏 5
点赞数 4
分类专栏： 数据结构 文章标签： 数据结构
于 2023-07-03 15:18:43 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74288306/article/details/131504247
版权

1.栈

1.1栈的概念及结构

栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则。
压栈：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。
出栈：栈的删除操作叫做出栈。出数据也在栈顶。
在这里插入图片描述

1.2栈的实现

栈的实现一般可以使用数组或者链表实现，相对而言数组的结构实现更有一些。因为在数组为上插入数据的代价比较小。
在这里插入图片描述
接下来我们一起用数组实现栈

定义结构体

typedef int STDataType;
typedef struct Stack
{
	STDataType* a;
	int top;
	int capacity;//栈的容量
}ST;

定义一个STDataType类型的指针，int类型的top变量记录位置，int类型的capacity变量记录栈的容量

Stack.h文件

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>

typedef int STDataType;
typedef struct Stack
{
	STDataType* a;
	int top;
	int capacity;//栈的容量
}ST;

//栈的初始化
void STackInit(ST* ps);
//栈的销毁
void STackDestroy(ST* ps);
//入栈
void STackPush(ST* ps, STDataType x);
//出栈
void STackPop(ST* ps);
//判断是否栈空
bool STackEmpty(ST* ps);
//栈的大小
int STackSize(ST* ps);
//获取栈顶元素
STDataType STackTop(ST* ps);

Stack.c文件

#include"Stack.h"
//栈的初始化
void STackInit(ST* ps)
{
	assert(ps);
	STDataType* tmp = (STDataType*)malloc(sizeof(STDataType) * 3);
	if (tmp == NULL)
	{
		perror("STackInit(ST* ps)::malloc");
		return;
	}
	ps->a = tmp;
	ps->capacity = 3;
	ps->top = 0;//指向栈顶元素下一个位置
	//ps->a = -1;//指向栈顶元素的位置
}
//栈的销毁
void STackDestroy(ST* ps)
{
	assert(ps);
	free(ps->a);
	ps->capacity = ps->top = 0;
}
//入栈
void STackPush(ST* ps, STDataType x)
{
	assert(ps);
	if (ps->top == ps->capacity)
	{
		STDataType* tmp = (STDataType*)realloc(ps->a, 
			sizeof(STDataType)*ps->capacity * 2);
		if (tmp == NULL)
		{
			perror("STackPush::realloc");
			return;
		}
		ps->a = tmp;
		ps->capacity *= 2;
	}
	ps->a[ps->top++] = x;
}
//出栈
void STackPop(ST* ps)
{
	assert(ps);
	assert(!STackEmpty(ps));
	ps->top--;
}
//判断是否栈空
bool STackEmpty(ST* ps)
{
	assert(ps);
	return ps->top == 0;
}
//栈的大小
int STackSize(ST* ps)
{
	assert(ps);
	return ps->top;
}
//获取栈顶元素
STDataType STackTop(ST* ps)
{
	assert(ps);
	assert(!STackEmpty(ps));
	return ps->a[ps->top-1];
}

test.c文件

#include"Stack.h"
int main()
{
	ST st;
	STackInit(&st);
	STackPush(&st, 1);
	STackPush(&st, 2);
	STackPush(&st, 3);
	STackPush(&st, 4);
	STackPush(&st, 5);
	printf("当前栈的大小为:>%d\n", STackSize(&st));
	while (!STackEmpty(&st))
	{
		printf("%d ", STackTop(&st));
		STackPop(&st);
	}
	return 0;
}

代码运行的结果为：
在这里插入图片描述

2.队列

2.1队列的概念及实现

队列：只允许在一端进行插入数据操作，在另一端进行删除操作的特殊线性表，队列具有先进先出（First in First Out）入队列：进行插入操作的一端为队尾，出队列：进行删除操作的一端称为队头。
在这里插入图片描述

2.2队列的实现

队列也可以使用数组和链表的结构实现，使用链表的结构更优一些，因为如果使用数组的结构，出队列在数组头上出数据，效率比较低。注意： 使用链表解结构实现，出队列操作，一定会修改头指针，如果出队列之后，队列为空，需要修改尾指针。

Queue.h文件

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
#include<assert.h>

typedef int QDataType;
typedef struct QueueNode
{
	struct QueueNode* next;
	QDataType data;
}QNode;
typedef struct Queue
{
	QNode* head;
	QNode* tail;
	int size;
}Queue;
//队列初始化
void QueueInit(Queue* pq);
//队列销毁
void QueueDestroy(Queue* pq);
//入队列
void QueuePush(Queue* pq, QDataType x);
//出队列
void QueuePop(Queue* pq);
//队列大小
int QueueSize(Queue* pq);
//队列判空
bool QueueEmpty(Queue* pq);
//获取队头元素
QDataType QueueFront(Queue* pq);
//获取队尾元素
QDataType QueueBase(Queue* pq);

Queue.c文件

#define _CRT_SECURE_NO_WARNINGS 1
#include"Queue.h"
//队列初始化
void QueueInit(Queue* pq)
{
	assert(pq);
	pq->head = pq->tail = NULL;
	pq->size = 0;
}
//队列销毁
void QueueDestroy(Queue* pq)
{
	assert(pq);
	QNode* cur = pq->head;
	while (cur)
	{
		QNode* next = cur->next;
		free(cur);
		cur = next;
	}
	pq->head = pq->tail = NULL;
	pq->size = 0;
}
//入队列
void QueuePush(Queue* pq, QDataType x)
{
	assert(pq);
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		perror("QueuePush::malloc");
		return;
	}
	newnode->next = NULL;
	newnode->data = x;
	if (pq->head == NULL)
	{
		assert(pq->tail == NULL);
		pq->head = pq->tail = newnode;
	}
	else
	{
		pq->tail->next = newnode;
		pq->tail = newnode;
	}
	pq->size++;
}
//出队列
void QueuePop(Queue* pq)
{
	assert(pq);
	//QNode* del = pq->head;
	//pq->head = del->next;
	//free(del);
	//if (pq->head == NULL)
	//	pq->tail = NULL;
	if (pq->head->next == NULL)
	{
		free(pq->head);
		pq->head = pq->tail = NULL;
	}
	else
	{
		QNode* next = pq->head->next;
		free(pq->head);
		pq->head = next;
	}
	pq->size--;
}
//队列大小
int QueueSize(Queue* pq)
{
	assert(pq);
	return pq->size;
}
//队列判空
bool QueueEmpty(Queue* pq)
{
	assert(pq);
	return pq->size == 0;
}
//获取队头元素
QDataType QueueFront(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));
	return pq->head->data;
}
//获取队尾元素
QDataType QueueBase(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));
	return pq->tail->data;
}

test.c文件

#define _CRT_SECURE_NO_WARNINGS 1
#include"Queue.h"
int main()
{
	Queue q;
	QueueInit(&q);
	QueuePush(&q, 1);
	QueuePop(&q);
	QueuePush(&q, 2);
	QueuePop(&q);
	QueuePush(&q, 3);
	QueuePush(&q, 4);
	QueuePush(&q, 5);
	printf("队列元素个数为:>%d\n", QueueSize(&q));
	while (!QueueEmpty(&q))
	{
		printf("%d ", QueueFront(&q));
		QueuePop(&q);
	}
	return 0;
}

代码测试的结果为：
在这里插入图片描述

3.栈和队列的面试题

3.1括号匹配问题

在这里插入图片描述
代码实现：

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>

typedef char STDataType;
typedef struct Stack
{
	STDataType* a;
	int top;
	int capacity;//栈的容量
}ST;
//栈的初始化
void STackInit(ST* ps);
//栈的销毁
void STackDestroy(ST* ps);
//入栈
void STackPush(ST* ps, STDataType x);
//出栈
void STackPop(ST* ps);
//判断是否栈空
bool STackEmpty(ST* ps);
//栈的大小
int STackSize(ST* ps);
//获取栈顶元素
STDataType STackTop(ST* ps);
//栈的初始化
void STackInit(ST* ps)
{
	//assert(ps);
	STDataType* tmp = (STDataType*)malloc(sizeof(STDataType) * 3);
	if (tmp == NULL)
	{
		perror("STackInit(ST* ps)::malloc");
		return;
	}
	ps->a = tmp;
	ps->capacity = 3;
	ps->top = 0;//指向栈顶元素下一个位置
	//ps->a = -1;//指向栈顶元素的位置
}
//栈的销毁
void STackDestroy(ST* ps)
{
	assert(ps);
	free(ps->a);
	ps->capacity = ps->top = 0;
}
//入栈
void STackPush(ST* ps, STDataType x)
{
	assert(ps);
	if (ps->top == ps->capacity)
	{
		STDataType* tmp = (STDataType*)realloc(ps->a, 
			sizeof(STDataType)*ps->capacity * 2);
		if (tmp == NULL)
		{
			perror("STackPush::realloc");
			return;
		}
		ps->a = tmp;
		ps->capacity *= 2;
	}
	ps->a[ps->top++] = x;
}
//判断是否栈空
bool STackEmpty(ST* ps)
{
	assert(ps);
	return ps->top == 0;
}
//出栈
void STackPop(ST* ps)
{
	assert(ps);
	assert(!STackEmpty(ps));
	ps->top--;
}

//栈的大小
int STackSize(ST* ps)
{
	assert(ps);
	return ps->top;
}
//获取栈顶元素
STDataType STackTop(ST* ps)
{
	assert(ps);
	assert(!STackEmpty(ps));
	return ps->a[ps->top-1];
}
 
 bool isValid(char * s)
 {
     ST st;
    STackInit(&st);
    //StackInit(&st);
     while(*s)
     {
         if(*s=='('||*s=='['||*s=='{')
         {
            STackPush(&st,*s);
         }
         else{
             //右括号比左括号多的情况
             if(STackEmpty(&st))
             {
                 STackDestroy(&st);
                 return false;
             }  
             char top=STackTop(&st);
             if((top=='('&&*s!=')')||
             (top=='['&&*s!=']')||
             (top=='{'&&*s!='}'))
             {
                STackDestroy(&st);
                 return false;
             }
             STackPop(&st);
         }
         s++;
     }
     //左括号比右括号多的情况
     bool ret =STackEmpty(&st);
     STackDestroy(&st);
     return ret;
 }

3.2用队列实现栈

在这里插入图片描述
图形理解：
在这里插入图片描述
代码实现：

typedef int QDataType;
typedef struct QueueNode
{
	struct QueueNode* next;
	QDataType data;
}QNode;
typedef struct Queue
{
	QNode* head;
	QNode* tail;
	int size;
}Queue;
//队列初始化
void QueueInit(Queue* pq);
//队列销毁
void QueueDestroy(Queue* pq);
//入队列
void QueuePush(Queue* pq, QDataType x);
//出队列
void QueuePop(Queue* pq);
//队列大小
int QueueSize(Queue* pq);
//队列判空
bool QueueEmpty(Queue* pq);
//获取队头元素
QDataType QueueFront(Queue* pq);
//获取队尾元素
QDataType QueueBase(Queue* pq);

//队列初始化
void QueueInit(Queue* pq)
{
	assert(pq);
	pq->head = pq->tail = NULL;
	pq->size = 0;
}
//队列销毁
void QueueDestroy(Queue* pq)
{
	assert(pq);
	QNode* cur = pq->head;
	while (cur)
	{
		QNode* next = cur->next;
		free(cur);
		cur = next;
	}
	pq->head = pq->tail = NULL;
	pq->size = 0;
}
//入队列
void QueuePush(Queue* pq, QDataType x)
{
	assert(pq);
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		perror("QueuePush::malloc");
		return;
	}
	newnode->next = NULL;
	newnode->data = x;
	if (pq->head == NULL)
	{
		assert(pq->tail == NULL);
		pq->head = pq->tail = newnode;
	}
	else
	{
		pq->tail->next = newnode;
		pq->tail = newnode;
	}
	pq->size++;
}
//出队列
void QueuePop(Queue* pq)
{
	assert(pq);
	//QNode* del = pq->head;
	//pq->head = del->next;
	//free(del);
	//if (pq->head == NULL)
	//	pq->tail = NULL;
	if (pq->head->next == NULL)
	{
		free(pq->head);
		pq->head = pq->tail = NULL;
	}
	else
	{
		QNode* next = pq->head->next;
		free(pq->head);
		pq->head = next;
	}
	pq->size--;
}
//队列大小
int QueueSize(Queue* pq)
{
	assert(pq);
	return pq->size;
}
//队列判空
bool QueueEmpty(Queue* pq)
{
	assert(pq);
	return pq->size == 0;
}
//获取队头元素
QDataType QueueFront(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));
	return pq->head->data;
}
//获取队尾元素
QDataType QueueBase(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));
	return pq->tail->data;
}
typedef struct {
    Queue q1;
    Queue q2;
} MyStack;


MyStack* myStackCreate() {
    MyStack* pst=(MyStack*)malloc(sizeof(MyStack));
    if(pst==NULL)
    {
        perror("myStackCreate()::malloc");
        return NULL;
    }
    QueueInit(&pst->q1);
    QueueInit(&pst->q2);
    return pst;
}

void myStackPush(MyStack* obj, int x) {
    if(!QueueEmpty(&obj->q1))
    {
        QueuePush(&obj->q1,x);
    }
    else
    {
        QueuePush(&obj->q2,x);
    }
}

int myStackPop(MyStack* obj) {
    Queue* noneempty=&obj->q1;
    Queue* empty=&obj->q2;
    if(QueueEmpty(&obj->q1))
    {
        noneempty=&obj->q2;
        empty=&obj->q1;
    }
    while(QueueSize(noneempty)>1)
    {
        QueuePush(empty,QueueFront(noneempty));
        QueuePop(noneempty);
    }
    int top=QueueFront(noneempty);
    QueuePop(noneempty);
    return top;
}

int myStackTop(MyStack* obj) {
    if(!QueueEmpty(&obj->q1))
    {
       return QueueBase(&obj->q1);
    }
    else
    {
       return QueueBase(&obj->q2);
    }
}

bool myStackEmpty(MyStack* obj) {
    return QueueEmpty(&obj->q1)&&
    QueueEmpty(&obj->q2);
}

void myStackFree(MyStack* obj) {
    QueueDestroy(&obj->q1);
    QueueDestroy(&obj->q2);
    free(obj);
}

3.3用栈实现队列

在这里插入图片描述
图形理解：
在这里插入图片描述
代码实现：

typedef int STDataType;
typedef struct Stack
{
	STDataType* a;
	int top;
	int capacity;//栈的容量
}ST;

//栈的初始化
void STackInit(ST* ps);
//栈的销毁
void STackDestroy(ST* ps);
//入栈
void STackPush(ST* ps, STDataType x);
//出栈
void STackPop(ST* ps);
//判断是否栈空
bool STackEmpty(ST* ps);
//栈的大小
int STackSize(ST* ps);
//获取栈顶元素
STDataType STackTop(ST* ps);
//栈的初始化
void STackInit(ST* ps)
{
	assert(ps);
	STDataType* tmp = (STDataType*)malloc(sizeof(STDataType) * 3);
	if (tmp == NULL)
	{
		perror("STackInit(ST* ps)::malloc");
		return;
	}
	ps->a = tmp;
	ps->capacity = 3;
	ps->top = 0;//指向栈顶元素下一个位置
	//ps->a = -1;//指向栈顶元素的位置
}
//栈的销毁
void STackDestroy(ST* ps)
{
	assert(ps);
	free(ps->a);
	ps->capacity = ps->top = 0;
}
//入栈
void STackPush(ST* ps, STDataType x)
{
	assert(ps);
	if (ps->top == ps->capacity)
	{
		STDataType* tmp = (STDataType*)realloc(ps->a, 
			sizeof(STDataType)*ps->capacity * 2);
		if (tmp == NULL)
		{
			perror("STackPush::realloc");
			return;
		}
		ps->a = tmp;
		ps->capacity *= 2;
	}
	ps->a[ps->top++] = x;
}
//出栈
void STackPop(ST* ps)
{
	assert(ps);
	assert(!STackEmpty(ps));
	ps->top--;
}
//判断是否栈空
bool STackEmpty(ST* ps)
{
	assert(ps);
	return ps->top == 0;
}
//栈的大小
int STackSize(ST* ps)
{
	assert(ps);
	return ps->top;
}
//获取栈顶元素
STDataType STackTop(ST* ps)
{
	assert(ps);
	assert(!STackEmpty(ps));
	return ps->a[ps->top-1];
}
typedef struct {
    ST pushst;
    ST popst;
} MyQueue;


MyQueue* myQueueCreate() {
    MyQueue* obj=(MyQueue*)malloc(sizeof(MyQueue));
    if(obj==NULL)
    {
        perror("myQueueCreate()::malloc");
        return NULL;
    }
    STackInit(&obj->pushst);
    STackInit(&obj->popst);
    return obj;
}

void myQueuePush(MyQueue* obj, int x) {
    STackPush(&obj->pushst,x);
}

int myQueuePeek(MyQueue* obj) {
    if(STackEmpty(&obj->popst))
    {
        while(!STackEmpty(&obj->pushst))
        {
            STackPush(&obj->popst,STackTop(&obj->pushst));
            STackPop(&obj->pushst);
        }
    }
    return STackTop(&obj->popst);
}

int myQueuePop(MyQueue* obj) {
    int top=myQueuePeek(obj);
    STackPop(&obj->popst);
    return top;
}


bool myQueueEmpty(MyQueue* obj) {
    return STackEmpty(&obj->pushst)&&
    STackEmpty(&obj->popst);
}

void myQueueFree(MyQueue* obj) {
    STackDestroy(&obj->pushst);
    STackDestroy(&obj->popst);
    free(obj);
}

3.4设计循环队列

在这里插入图片描述
代码实现：

typedef struct {
    int* a;
    int front;//首元素下标
    int rear;//末尾元素的下一个位置
    int k;//循环队列的数据个数
} MyCircularQueue;


MyCircularQueue* myCircularQueueCreate(int k) {
    MyCircularQueue* obj=(MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    if(obj==NULL)
    {
        perror("myCircularQueueCreate::malloc");
        return NULL;
    }
    int* tmp=(int*)malloc(sizeof(int)*(k+1));//多开一段空间
    if(tmp==NULL)
    {
        perror("myCircularQueueCreate::malloc");
        return NULL;
    }
    obj->a=tmp;
    obj->front=obj->rear=0;
    obj->k=k;
    return obj;
}
bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
    //rear\front下标相同时，循环队列为空
    return obj->rear==obj->front;
}

bool myCircularQueueIsFull(MyCircularQueue* obj) {
    //rear下一个位置与front的位置相同时，循环队列为满
    return (obj->rear+1)%(obj->k+1)==obj->front;
}
bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
    if(myCircularQueueIsFull(obj))
    {
        return false;
    }
        //obj->a[obj->rear++]=value;
        obj->a[obj->rear++]=value;
        //rear到末尾的情况
        obj->rear %=(obj->k+1);
        return true;
}

bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
    {
        return false;
    }
    obj->front++;
    //front到末尾的情况
    obj->front%=(obj->k+1);
    return true;
}

int myCircularQueueFront(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
    {
        return -1;
    }
    return obj->a[obj->front];
}

int myCircularQueueRear(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
    {
        return -1;
    }
    else
    {
        //rear前一个的位置为队尾的情况
        //rear在数组开头的时候，特殊处理
        return obj->a[(obj->rear-1+obj->k+1)%(obj->k+1)];
    }
}
void myCircularQueueFree(MyCircularQueue* obj) {
    free(obj->a);
    free(obj);
}
吾与C
关注
  • 4
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
第01课时-初识数据结构.pptx
12-06
第01课时-初识数据结构.pptx
数据结构初阶--栈和队列
weixin_67916525的博客
03-15 152
栈栈的概念及结构栈：一种特殊的线性表，其只允许在固定的一端插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO (Last In First Out) 的原则；同时对于栈来说，一种入栈顺序对应多种出栈顺序。
数据结构(七)---C语言实现栈和队列
cainiaochufa2021的博客
04-12 2351
1. 队列和栈都是线性表类型的数据结构，两个结构都可以从一端存入数据，区别是栈结构只能从存入数据的一端取出数据，而队列结构只能从出入数据的另一端取出数据。 2. 队列和栈都可以用数组和链表来实现。不管是哪种实现方式，都应该尽可能高效的找到几个特殊的位置（栈顶、队列头、队列尾）。
Python数据结构第三章第一节--初识栈和队列
2301_81989907的博客
04-07 244
队列：像排队打饭一样，先进先出（First in First out, 简称：FIFO）栈：像叠盘子一样，后进先出（Last in First out:简称：LIFO)6.栈底：Stack_Base。5.栈顶：Stack_Top。2. 队列：Queue。
LeetCode数据结构题---用栈实现队列
精致的灰的博客
08-04 205
原题链接：用栈实现队列 思路 栈的特性是先进后出，而队列的特性是后进先出，也就是说，如果把一串数据放进栈里面，它会倒着拿出来，但是队列是会正着拿出来。这里题目给了两个栈，如果我们将数据放到一个栈里面，再从这个栈里面拿出来放到另一个栈里面，那取出来不就是成正的了吗? 为了便于区分，我们将第一个栈命名为pushs，因为入队的数据都必须先放在这个栈里面，第二个栈命名为pops，因为如果要出队或者取最先入栈的数据，必须先将第一个栈的数据全部转移到这个栈里面，如果没能全部转移，那么数据就会造成混乱，无法做到先进先出
第6课-数据初识公开课.docx
12-17
第6课-数据初识公开课.docx
任务9-1-初识人工智能.docx
12-18
任务9-1-初识人工智能.docx
《初识数据结构》教学建议.pdf
08-07
#资源达人分享计划#
redux-saga 初识和使用
08-27
主要介绍了redux-saga 初识和使，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
数据结构九：线性表之链式队列的设计
weixin_47040031的博客
04-30 590
现在，我们可以知道，其实从本质上来讲，链式队列就是重新设计头节点的单链表结构，并且只允许头删和尾插（队尾入队头出）；对于循环队列与链队列的比较，可以从两方面来考虑，从时间上，其实它们的基本操作都是常数时间，即都为O(1)的，不过循环队列是事先申请好空间，使用期间不释放，而对于链队列，每次申请和释放结点也会存在一些时间开销，如果入队出队频繁，则两者还是有细微差异。对于空间上来说，循环队列必须有一个固定的长度，所以就有了存储元素个数和空间浪费的问题。
数据结构===队列
yajunjiao的专栏
05-03 241
队列，一种基础数据结构；像现实种的一样，先进先出，入队，出队操作。有顺序队列，链式队列，等等。可以看看封面，是不是很形象。便于理解。
二叉树：数据结构的分形之美
2301_78804510的博客
04-30 1019
树是一种非线性的数据结构，它是由n(n>=0)个有限结点组成一个具有层次关系的集合。把他叫做树是因为它看起来像一棵倒挂的树，也就说它的根朝上，而叶朝下的。
学习笔记-数据结构-线性表（2024-04-24）
XuJiaKai的博客
04-26 228
p 用于追踪新链表的最后一个节点，最初设置为 NULL。q 指向当前正在处理的原链表的节点，最初是链表的头节点。在 while 循环中，遍历原链表。循环的每一次迭代都会处理一个节点，将其从原位置移动到新链表的前端。这通过改变节点的 next 指针实现，使其指向新链表的当前第一个节点 p。当 q 为 NULL 时，意味着已经处理完所有的节点，此时 p 指向新链表的头节点。最后，将链表的头指针 L 更新为 p，完成链表的反转。在移动节点之后，p 更新为 q，q 更新为 r，以继续遍历和反转剩余的链表。
数据库系统工程师之数据结构
selenia8860的博客
04-27 238
在数据库系统工程师的考试中，数据结构是一个重要的考点。数据结构主要关注数据元素之间的相互关系以及它们的组织和存储方式。
C语言/数据结构——每日一题（分割链表）
最新发布
yiqingaa的博客
05-03 168
废话不多说，让我们直接进入正题吧。
bite阶段性测试_数据结构
li_peixiansang的博客
04-30 812
bite阶段性测试_数据结构
【数据结构（邓俊辉）学习笔记】向量05——排序器
weixin_44399845的博客
04-30 1067
介绍下有序向量的排序器，包括起泡排序和归并排序
【数据结构】单链表
s_little_monster的博客
04-24 1942
简单来说就是结构体的应用哦~
[spark]-结构化数据查询之初识篇
03-16
在初识篇中，我们可以学习如何使用Spark SQL来进行结构化数据查询，包括如何创建表格、执行SQL查询、过滤数据、聚合数据等。这些基础知识可以帮助我们更好地理解和使用Spark中的结构化数据查询功能。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值