考研数据结构-栈、队列和数组（超详细）

已于 2023-08-11 12:12:16 修改
阅读量477 收藏 2
点赞数 2
分类专栏： 考研数据结构 文章标签： 数据结构
于 2023-08-11 12:09:36 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_52087266/article/details/132228181
版权

文章目录

3. 栈、队列和数组

请添加图片描述

3.1 栈

3.1.1 栈的基本概念

  1. 栈的定义：栈（Stack）是只允许在一端进行插入或删除操作的线性表

  2. 栈的基本操作：

    InitStack(&S)：初始化栈。构造一个空栈 S，分配内存空间。

    DestroyStack(&S)：销毁栈。销毁并释放栈 S 所占用的内存空间。

    Push(&S,x)：进栈，若栈S未满，则将x加入使之成为新栈顶。

    Pop(&S,&x)：出栈，若栈S非空，则弹出栈顶元素，并用x返回。

    GetTop(S, &x)：读栈顶元素。若栈 S 非空，则用 x 返回栈顶元素

    其他常用操作：

    StackEmpty(S)：判断一个栈 S 是否为空。若S为空，则返回true，否则返回false

  3. 卡特兰数
    请添加图片描述

3.1.2 栈的顺序存储实现

  1. 顺序栈

    #include <stdio.h>
#define true 1
#define false 0
#define MAXSIZE 10
typedef int bool;
typedef int ElemType;
typedef struct {
	ElemType data[MAXSIZE]; // 数据域
	int top; // 栈顶指针
} SqStack;
/*初始化栈*/
bool InitStack(SqStack* S)
{
	S->top= -1; // 让栈顶指针指向 -1，表示当前为空栈
	return true;
}
/*判断栈是否为空*/
bool isEmpty(SqStack S)
{
	if (S.top == -1)
		return true; // 栈空
	return	false; // 非空
}
/*进栈操作*/
bool Push(SqStack* S, ElemType e)
{
	if (S->top == MAXSIZE - 1)
		return false; // 栈已满
	S->top++; // 栈顶指针加一
	S->data[S->top] = e; // 将值赋值给新的栈顶元素
	return true;
}
/*出栈操作*/
bool Pop(SqStack* S, ElemType* x)
{
	if (isEmpty(*S))
		return false; // 栈空，无出栈元素
	*x = S->data[S->top];
	S->top--; // 栈顶指针减一
	return true;
}
/*获取栈顶元素*/
bool GetTop(SqStack S, ElemType* x)
{
	if (isEmpty(S))
		return false; // 栈空
	*x = S.data[S.top];
	return true;
}
int main()
{
	SqStack S; // 定义一个栈
	InitStack(&S); // 初始化一个栈
	Push(&S, 666);
	Push(&S, 777);
	// 判断栈是否为空
	isEmpty(S) ? printf("The Stack is NULL\n") : printf("The Stack not is NULL\n"); 
	ElemType x;
	Pop(&S, &x) ? printf("The pop element is %d\n", x) : printf("Pop failure\n");
	GetTop(S, &x) ? printf("Get top element is %d\n", x) : printf("The Stack is NULL\n");
	return 0;
}

  2. 共享栈

    #include <stdio.h>
#define true 1
#define false 0
#define MAXSIZE 10
typedef int bool;
typedef int ElemType;
typedef struct {
	ElemType data[MAXSIZE];
	int top0; // 0号栈栈顶指针
	int top1; // 1号栈栈顶指针
} ShStack;
/*初始化栈*/
bool InitStack(ShStack* S)
{
	S->top0 = -1; // 0号栈栈顶指针指向 -1
	S->top1 = MAXSIZE; // 1号栈栈顶指针指向 MaxSize
}
/*判断栈是否为空*/
bool isEmpty(ShStack S)
{
	if (S.top0 == -1 && S.top1 == MAXSIZE)
		return true;
	return false;
}
/*入栈 c=0代表操作0号栈，c=1代表操作1号栈*/
bool Push(ShStack* S, ElemType e, int c)
{
	if (c == 0)// 操作0号栈
	{
		if (S->top0 + 1 == S->top1)
			return false; // 栈满
		S->data[++S->top0] = e; // 将top0加一，并填入新元素
		return true;
	}
	else if (c == 1) // 操作1号栈
	{
		if (S->top1 - 1 == S->top0)
			return false; // 栈满
		S->data[--S->top1] = e; // 将top1减一，并填入新元素
		return true;
	}
	return false; // c参数输入不合法
}
/*弹栈 c=0代表操作0号栈，c=1代表操作1号栈*/
bool Pop(ShStack* S, ElemType* x, int c)
{
	if (c == 0)// 操作0号栈
	{
		if (S->top0 == -1)
			return false; // 栈空
		*x = S->data[S->top0--]; // 出栈，栈顶指针减一
		return true;
	}
	else if (c == 1) // 操作1号栈
	{
		if (S->top1 == MAXSIZE)
			return false; // 栈空
		*x = S->data[S->top1++]; // 出栈，栈顶指针加一
		return true;
	}
	return false; // c参数输入不合法
}
int main()
{
	ShStack S;
	InitStack(&S); // 初始化栈
	isEmpty(S); // 判断栈是否为空
	Push(&S, 985, 0); // 0号栈入栈
	Push(&S, 211, 1); // 1号栈入栈
	ElemType x;
	Pop(&S, &x, 0); // 0号栈弹栈
	Pop(&S, &x, 1); // 1号栈弹栈
	return 0;
}
3.1.3 栈的链式存储实现

  1. 不带头结点

    #include <stdio.h>
#include <stdlib.h>
#define true 1
#define false 0
typedef int bool;
typedef int ElemType;

typedef struct LinkNode { // 定义链栈的结构体
	ElemType data; // 数据域
	struct LinkNode* next; // 指针域
}LinkNode,*LiStack;
/*初始化链栈*/
bool InitStack(LiStack* S)
{
	*S = NULL;
	return true;
}
/*判空*/
bool isEmpty(LiStack S)
{
	return S == NULL;
}
/*入栈*/
bool Push(LiStack* S, ElemType e)
{
	if (isEmpty(*S)) // 当前链栈为空
	{
		*S = (LinkNode*)malloc(sizeof(LinkNode));
		if (*S == NULL) // 内存不足，分配失败
			return false;
		(*S)->data = e;
		(*S)->next = NULL;
		return true;
	}
	// 链栈不为空时
	LinkNode* p = (LinkNode*)malloc(sizeof(LinkNode));
	if (p == NULL)
		return false;
	p->data = e;
	p->next = *S; // 让新节点指向原来的第一个节点
	*S = p; // 让头指针指向新节点
	return true;
}
/*弹栈*/
bool Pop(LiStack* S, ElemType* x)
{
	if (isEmpty(*S)) // 链栈为空
		return false;
	if ((*S)->next == NULL) // 链栈中只有一个节点
	{
		*x = (*S)->data; // 把仅有的一个节点的数据赋值给x
		free(*S); // 把仅有的那个节点空间释放掉
		*S = NULL;
		return true;
	}
	// 链栈中不只有一个节点
	LinkNode* p = (*S)->next;
	*x = (*S)->data;
	free(*S); // 释放第一个节点
	*S = p; // 让栈指针指向原来位序为2的节点
	return true;
}
/*获取栈顶元素*/
bool GetTop(LiStack S, ElemType* x)
{
	if (isEmpty(S))
		return false;
	*x = S->data;
}
int main()
{
	LiStack S; 
	InitStack(&S);
	isEmpty(S);
	Push(&S, 666);
	Push(&S, 777);
	ElemType x;
	Pop(&S, &x);
	GetTop(S, &x);
	Pop(&S, &x);
	Pop(&S, &x);
	return 0;
}

  2. 带头结点

    #include <stdio.h>
#include <stdlib.h>
#define true 1
#define false 0
typedef int bool;
typedef int ElemType;

typedef struct LinkNode { // 定义链栈的结构体
	ElemType data; // 数据域
	struct LinkNode* next; // 指针域
}LinkNode, * LiStack;
/*初始化链栈*/
bool InitStack(LiStack* S)
{
	*S = (LinkNode*)malloc(sizeof(LinkNode));
	if (*S == NULL)
		return false;
	(*S)->next = NULL;
}
/*判空*/
bool isEmpty(LiStack S)
{
	return S->next == NULL;
}
/*入栈*/
bool Push(LiStack S, ElemType e)
{
	LinkNode* p = (LinkNode*)malloc(sizeof(LinkNode));
	if (p == NULL)
		return false;
	p->data = e;
	p->next = S->next; // 让新节点指向头节点的下一个节点
	S->next = p; // 让头节点指向 新节点
	return true;
}
/*弹栈*/
bool Pop(LiStack S, ElemType* x)
{
	if (isEmpty(S))
		return false;
	LinkNode* p = S->next; // 让p指向即将被删除的节点
	*x = p->data;
	S->next = p->next; // 断链。让头节点的next指向被删除节点的下一个节点
	free(p); // 释放被删除节点的空间
	return true;
}
bool Pop(LiStack* S, ElemType* x);
/*获取栈顶元素*/
bool GetTop(LiStack S, ElemType* x)
{
	if (isEmpty(S))
		return false;
	*x = S->next->data;
	return true;
}
int main()
{
	LiStack S;
	InitStack(&S);
	Push(S, 666);
	Push(S, 777);
	isEmpty(S);
	ElemType x;
	GetTop(S, &x);
	Pop(S, &x);
	Pop(S, &x);
	Pop(S, &x);
	return 0;
}

3.2 队列

3.2.1 队列的基本概念

  1. 队列的定义：队列（Queue）是只允许在一端进行插入，在另一端删除的线性表

  2. 队列的基本操作：

    InitQueue(&Q)：初始化队列，构造一个空队列Q。

    DestroyQueue(&Q)：销毁队列。销毁并释放队列Q所占用的内存空间。

    EnQueue(&Q,x)：入队，若队列Q未满，将x加入，使之成为新的队尾。

    DeQueue(&Q,&x)：出队，若队列Q非空，删除队头元素，并用x返回。

    GetHead(Q,&x)：读队头元素，若队列Q非空，则将队头元素赋值给x。

    其他常用操作：

    QueueEmpty(Q)：判队列空，若队列Q为空返回true，否则返回false。

3.2.2 队列的顺序实现(循环队列)

  1. 顺序实现的队列我们只讨论循环队列，因为不能循环得队列没意义

  2. 在这里插入图片描述

  3. 循环队列（初始化Q.front=0; Q.rear=0）

    #include <stdio.h>
#include <stdlib.h>
#define true 1
#define false 0
#define MAXSIZE 10
typedef int bool;
typedef int ElemType;
typedef struct {
	ElemType data[MAXSIZE];
	int front, rear; // 队头指针和队尾指针（头出尾进）
} SqQueue;
/*初始化队列*/
void InitQueue(SqQueue* Q)
{
	// 初始时对头指针和队尾指针都指向 0
	(*Q).front = (*Q).rear = 0;
}
/*判断队列是否为空*/
bool isEmpty(SqQueue Q)
{
	return Q.front == Q.rear;
}
/*入队*/
bool EnQueue(SqQueue* Q, ElemType e)
{
	if (((*Q).rear + 1) % MAXSIZE == (*Q).front)
		return false; // 队满
	(*Q).data[(*Q).rear] = e; // 新元素插入队尾
	(*Q).rear = ((*Q).rear + 1) % MAXSIZE; // 队尾指针加 1 取模
	return true;
}
/*出队*/
bool DeQueue(SqQueue* Q, ElemType* x)
{
	if (isEmpty(*Q))
		return false; // 队列为空
	*x = (*Q).data[(*Q).front];
	(*Q).front = ((*Q).front + 1) % MAXSIZE; // 队头指针后移
	return true;
}
/*获取队头元素值*/
bool GetHead(SqQueue Q, ElemType* x)
{
	if (isEmpty(Q))
		return false;
	*x = Q.data[Q.front];
	return true;
}
int main()
{
	SqQueue Q;
	InitQueue(&Q);
	EnQueue(&Q, 666);
	ElemType x;
	GetHead(Q, &x);
	DeQueue(&Q, &x);
	DeQueue(&Q, &x);
	return 0;
}

  4. 判断队列已满/已空

    初始化时rear=front=0

    1. 队空的条件：Q.front == Q.rear
    2. 队满的条件：牺牲一个存储位置：(Q.rear + 1) % MAXSIZE == Q.front

    在结构体添加一个size属性记录当前队列的长度

    1. 队空条件：Q.size == 0
    2. 队满的条件：Q.size == MAXSIZE

    在结构体添加一个tag属性每次删除操作成功时，都令tag=0；每次插入操作成功时，都令tag=1；

    1. 队空条件：Q.front == Q.rear && tag == 0
    2. 队满的条件：Q.front == Q.rear && tag == 1

  5. 还有其他出题方法，比如出题人初始时front仍然指向0不变，但是rear要求实时指向当前队列中的元素，那么我们最好将rear的初始值定为 MAXSIZE - 1。这样的话判队空/满的条件也就都发生变化了，所以学东西一定要灵活，重在理解。

🧡💚💛3.2.3 队列的链式实现

  1. 带头结点

    #include <stdio.h>
#include <stdlib.h>
#define true 1
#define false 0
typedef int bool;
typedef int ElemType;

// ★★★★★ 之前从来没有定义过两个结构体
typedef struct LinkNode { // 链式队列节点
	ElemType data;
	struct LinkNode *next;
}LinkNode;
typedef struct { // 链式队列
	LinkNode *front, *rear; // 队列的队头指针和队尾指针
}QueueNode, *LinkQueue;
/*初始化队列*/
bool InitQueue(LinkQueue* Q)
{
	// ★★★★★ 之前写过的数据结构没这样写过
	*Q = (LinkQueue)malloc(sizeof(QueueNode)); // 先给队列Q申请空间
	if (*Q == NULL)
		return false;
	// 申请头节点
	LinkNode *s = (LinkNode*)malloc(sizeof(LinkNode));
	if (s == NULL)
		return false;
	s->next = NULL;
	(*Q)->front = (*Q)->rear = s; // Q的头指针和尾指针都指向头节点
}
/*判断队列是否为空*/
bool isEmpty(LinkQueue Q)
{
	return Q->front == Q->rear;
}

/*入队*/
bool EnQueue(LinkQueue Q, ElemType e)
{
	LinkNode* s = (LinkNode*)malloc(sizeof(LinkNode));
	if (s == NULL)
		return false;
	s->data = e;
	s->next = NULL;
	Q->rear->next = s; // 当前队尾节点指向新插入的节点
	Q->rear = s; // 保证队列的rear指针一直指向队尾元素
	return true;
}
/*出队*/
bool DeQueue(LinkQueue Q, ElemType* x)
{
	if (isEmpty(Q))
		return false; // 队列为空
	LinkNode* s = Q->front->next; // 让s指向队列链表中的除头节点的第一个节点
	*x = s->data;
	Q->front->next = s->next; // 让头节点指向出队节点的下一个节点
	if (s == Q->rear) // 当前出队的是队中的最后一个节点(★★★★★)
		Q->rear = Q->front; // 修改 rear 的指针
	return true;
}
int main()
{
	LinkQueue Q;
	LinkNode* L;
	InitQueue(&Q);
	free(Q);
	EnQueue(Q, 111);
	EnQueue(Q, 222);
	ElemType x;
	DeQueue(Q, &x);
	DeQueue(Q, &x);
	DeQueue(Q, &x);
	return 0;
}

  2. 不带头结点

    #include <stdio.h>
#include <stdlib.h>
#define true 1
#define false 0
typedef int bool;
typedef int ElemType;

typedef struct LinkNode { // 链式队列的节点
	ElemType data;
	struct LinkNode* next;
} LinkNode;

typedef struct { // 链式队列
	LinkNode *front, *rear;
}QueueNode, *LinkQueue;

/*初始化队列*/
bool InitQueue(LinkQueue* Q)
{
	*Q = (QueueNode*)malloc(sizeof(QueueNode));
	if (*Q == NULL)
		return false;
	(*Q)->front = (*Q)->rear = NULL; // 头指针和尾指针都指向NULL
	return true;
}
/*判空*/
bool isEmpty(LinkQueue Q)
{
	return Q->front == NULL;
}

/*入队*/
bool EnQueue(LinkQueue Q, ElemType e)
{
	LinkNode* s = (LinkNode*)malloc(sizeof(LinkNode));
	if (s == NULL)
		return false;
	s->data = e;
	s->next = NULL;
	if (Q->front == NULL) // 在空队列中插入第一个元素
	{
		Q->front = Q->rear = s; // 修改队头队尾指针
		return true;
	}
	Q->rear->next = s; // 将新节点插入到 rear 节点之后
	Q->rear = s; // 修改 rear指针
	return true;
}
/*出队*/
bool DeQueue(LinkQueue Q, ElemType* x)
{
	if (Q->front == NULL)
		return false;
	LinkNode* s = Q->front;
	*x = s->data;
	if (Q->front == Q->rear) // 此次是最后一个节点出队
		Q->front = Q->rear = NULL; // front 和 rear都指向NULL
	Q->front = s->next; // 修改front 指针
	free(s);
	return true;
}

int main()
{
	LinkQueue Q;
	InitQueue(&Q);
	EnQueue(Q, 111);
	EnQueue(Q, 222);
	ElemType x;
	DeQueue(Q, &x);
	DeQueue(Q, &x);
	DeQueue(Q, &x);
	return 0;
}
3.2.4 双端队列

3.3 栈和队列的应用

3.3.1 栈在括号匹配中的应用

  1. 流程图

    在这里插入图片描述

  2. 处理流程：

    1. 遇到左括号 ([{ ：进栈
    2. 遇到右括号 )]} ：弹栈 & 判断是否匹配
    3. 遇到非括号：数据输入不合法，匹配失败(){}[]

  3. 三种失败情况：

    1. 在处理过程中括号不匹配，失败。如：(){]
    2. 在处理过程中，遇到右括号，需要弹栈，但是栈空，失败。如：())
    3. 括号处理完之后，栈不为空，说明括号元素有多余,失败。如：{()
/*括号是否匹配*/
bool bracketCheck(char str[], int length) 
{
	// 注意：length接收的长度是实际 字符串长度 + 1，因为有'\0'
	SqStack S;
	InitStack(&S); // 初始化一个栈
	for (int i = 0; i < length - 1; i++)
	{
		if (str[i] == '(' || str[i] == '[' || str[i] == '{') { // 扫描到左括号
			Push(&S, str[i]); // 扫描到左括号元素入栈
		} else if(str[i] == ')' || str[i] == ']' || str[i] == '}') { // 扫描到右括号
			if (isEmpty(S)) { // 栈为空
				return false; // 匹配失败
			} else { // 栈不为空
				ElemType topElem;
				Pop(&S, &topElem); // 栈顶元素出栈
				if (str[i] == ')' && topElem != '(')
					return false;
				if (str[i] == ']' && topElem != '[')
					return false;
				if (str[i] == '}' && topElem != '{')
					return false;
			}
		} else{
			return false; // 表示输入数据不合法
		}
	}
	return isEmpty(S); // 若此时栈为空则说明完全匹配，且无剩余，表示匹配成功;
}
int main()
{
	char str[] = "{()";
	bool flag = bracketCheck(str, sizeof(str) / sizeof(char));
	flag ? printf("匹配成功\n") : printf("匹配失败\n");
	return 0;
}
3.3.2 栈在表达式求值中的应用

  1. 中缀转后缀（手算）
    (1)确定中缀表达式各个运算符的运算顺序(采用“左优先原则”)
    (2)选择下一个运算符，按照<左操作数 右操作数 运算符>的方式组合成一个新的操作数
    (3)如果还有运算符没被处理，就继续(2)

    eg: A+B*(C-D)-E/F
    运算次序：3 2 1 5 4
    ABCD-*+EF/-
    123 45

    eg: A+B-CD/E+F
    运算次序： 1 4 2 3 5
    AB+CD    E/-F+
    1 2 34 5

  1. 后缀表达式的运算（手算）
    从左往右扫描，每遇到一个运算符，就让运算符前面最近的两个操作数执行对应运算，合体为一个操作数
  1. 后缀表达式的运算（机算）【这也正是后缀转中缀的算法】
    用栈实现后缀表达式的计算：
    (1)从左往右扫描，直到处理完所有元素
    (2)若扫描到操作数则压栈，并且返回(1)，否则执行(3)
    (3)若扫描到运算符，则弹出两个栈顶元素，执行相应运算，运算结果压回栈顶，回到(1)
    ———若表达式合法，则最后栈中只会留下一个元素，就是最终结果
    注意：先出栈的是“右操作数”

  1. 中缀转前缀（手算）
    (1)确定中缀表达式各个运算符的运算顺序(采用“右优先原则”)
    (2)选择下一个运算符，按照<运算符 左操作数 右操作数>的方式组合成一个新的操作数
    (3)如果还有运算符没被处理，就继续(2)

    A+B*(C-D)–E/F
    5 3 2 4 1
    +A-*B-CD/EF
    5 43 2 1
    +A-*B-CD/EF

  1. 前缀表达式的计算(手算)【这也正是前缀转中缀的算法】
    用栈实现前缀表达式的计算：
    (1)从右往左扫描下一个元素，直到处理完所有元素
    (2)若扫描到操作数则压入栈，并回到(1)；否则执行(3)
    (3)若扫描到运算符，则弹出两个栈顶元素，执行相应运算，运算结果压回栈顶，回到(1)
    注意：先取出的是左操作数
  1. 中缀表达式转后缀表达式(机算)
    初始化一个栈，用于暂时保存还不能确定运算顺序的操作符。
    从左至右处理各个元素，直到末尾。可能遇到三种情况：
    (1)遇到操作数。直接加入后缀表达式。
    (2)遇到界限符。遇到’(‘直接入栈；遇到’)‘则依次弹出栈内运算符并加入后缀表达式，直到
    弹出’(‘为止。注意’(‘不加入后缀表达式。
    (3)遇到运算符。依次弹出栈中优先级高于或等于当前运算符的所有运算符，并加入后缀表达式，
    若碰到’('或栈空则停止。之后再把当前运算符入栈。
    按上述方法处理完所有字符后，将栈中剩余运算符依次弹出，并加入后缀表达式。
  1. 中缀表达式的计算（机算）
    初始化两个栈，操作数栈和运算符栈
    若扫描到操作数，压入操作数栈
    若扫描到运算符或界限符，则按照“中缀转后缀”相同的逻辑压入运算符栈（期间也会弹出
    运算符，每当弹出一个运算符时，就需要再弹出两个操作数栈的栈顶元素并执行相应运算，
    运算结果再压回操作数栈）
3.3.3 栈在递归中的应用

  1. 函数调用的特点：最后被调用的函数最先执行结束（LIFO）

  2. 函数调用时，需要用一个“函数调用栈” 存储：

​ ① 调用返回地址

​ ② 实参

​ ③ 局部变量

  1. 递归调用时，函数调用栈可称为“递归工作栈”每进入一层递归，就将递归调用所需信息压入栈顶每退出一层递归，就从栈顶弹出相应信息。
  2. 缺点：效率低，太多层递归可能会导致栈溢出；可能包含很多重复计算
3.3.4 队列的应用
  1. 树的层序遍历
  2. 图的广度优先遍历
  3. 队列在操作系统中的应用

3.4 数组和特殊矩阵

####3.4.1 对称矩阵

特点：对方阵中的任意一个元素都有ai,j = aj,i
压缩：只存储主对角线+下三角区（或主对角线+上三角区）

3.4.2 三角矩阵

特点：上三角区全为常量(下三角矩阵)；或下三角区全为常量（上三角矩阵）
压缩:按行/列优先规则依次存储非常量区域，并在最后一个元素存储常量c

####3.4.3 三对角矩阵

特点：当|i - j| > 1时，有ai,j = 0(1<=j, j<=n)
压缩:按行/列优先规则依次存储带状区域

####3.4.4 稀疏矩阵

特点：非零元素远小于零元素个数
压缩:只存储非零元素
顺序存储：顺序存储三元组<行、列、值>
链式存储：十字链表法

别云超
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
考研 数据结构 第二章 栈队列和数组
04-17
考研必备 数据结构 第二章 栈队列和数组 请使用IE浏览器观看！ 欢迎下载！
数据结构考研复习（详细指导）（持续更新中）
m0_59860403的博客
04-04 9014
数据结构复习指导
拿命 3 天肝出来的计算机考研数据结构与算法复习笔记（超详细教程，更新中）
唤醒手腕的博客
10-11 1312
数据结构指的是“一组数据的存储结构”，算法指的是“操作数据的一组方法”。数据结构是为算法服务的，算法是要作用再特定的数据结构上的。最常用的数据结构预算法数据结构：数组、链表、栈、队列、散列表、二叉树、堆、跳表、图、Tire 树算法： 递归、排序、二分查找、搜索、哈希算法、贪心算法、分治算法、回溯算法、动态规划、字符串匹配算法算法设计的要求正确性：程序没有语法错误。程序对于一切合法的输入数据包括那些典型、苛刻且带有刁难性的几组输入数据可以得出满足要求的结果（设计算法时需要考虑到所有可能会输入数据）可读性。
计算机考研——数据结构笔记
ccccddeee的博客
03-10 1879
​ 线性表是一种逻辑结构，是具有相同数据类型的n个数据元素的有限序列。其中每个非表头元素仅有一个直接前驱元素，非表尾元素仅有一个直接后继元素。表中元素有限表中元素具有逻辑上的顺序性，表中元素有其先后次序表中元素都是数据元素，每个元素都是单个元素表中每个元素的数据类型相同，这使得每个元素占有的存储空间相等表中元素具有抽象性，仅讨论元素之间的逻辑关系，不考虑元素本身​ 顺序表是使用一组连续的存储单元依次存储数据元素的存储结构。​ 顺序表的空间分配方式分为两种，即静态分配和动态分配。
【2023考研】数据结构常考应用典型例题（含真题）
qq_34438969的博客
09-02 1万+
本文针对《数据结构》，博主花了几天时间列出了考研常考的应用题型，讲解详细，方便复习。各类题型所涉及的知识点包括但不限于队列、二叉排序树、平衡二叉树、哈夫曼树及哈夫曼编码、图的存储、最小生成树、关键路径、排序算法等等。（标题即为考点）。例题出自408真题，以及各高校的自主命题（含王道解析）。（后期会继续补充题目）目录前言一、队列二、树（一）二叉排序树（二）平衡二叉树（三）森林与二叉树的转换（四）哈夫曼树及哈夫曼编码三、图（一）邻接表及邻接矩阵、最小生成树（二）DFS和BFS（图的遍历）
考研数据结构汇总
越过山丘
05-15 3850
必背知识点 数据结构 是相互之间存在一种或多种特定关系的数据元素的集合 数据结构的三要素： 逻辑结构，存储结构，数据的运算（定义（逻辑结构的，运算的功能）和实现（物理结构的，运算的具体操作步骤）） 逻辑结构：数据元素之间的逻辑关系，与数据的存储无关，独立于计算机，线性结构和非线性结构 存储结构：数据结构在计算机中的表示 顺序存储：逻辑上相邻，物理上也相邻 链式存储：逻辑上相邻，物理上可以不相邻 索引表：在存储信息时，还需要建立附加的索引表 哈希表：根据关键字，直接计算出该元素的存储地址。 算法：对特定问题求
王道计算机考研 数据结构 （绪论、线性表）
m0_51448653的博客
09-27 1311
目录第一章、绪论1.1_数据结构的基本概念知识总览数据元素、数据项数据结构、数据对象数据结构的三要素数据类型、抽象数据类型1.2.1_算法的基本概念什么是算法算法的特性1.2.2_算法的时间复杂度1.2.3_算法的空间复杂度函数递归调用带来的内存开销第二章、线性表2.1_线性表的定义和基本操作线性表的基本操作2.2.1_顺序表的定义顺序表的实现-静态分配顺序表的实现-动态分配 第一章、绪论 1.1_数据结构的基本概念 知识总览 数据元素、数据项 数据元素是数据的基本单位，通常作为一个整体考虑 一个数据元
考研数据结构-学习笔记
最新发布
05-17
考研数据结构-学习笔记
数据结构考研讲义 第三章 栈、队列和数组.pdf
08-31
数据结构考研讲义 第三章 栈、队列和数组.pdf
考研专业课-数据结构-思维导图
12-30
打开方式：Freemind、幕布等思维导图软件  “数据结构”是计算机、...资源中包含数据结构绪论，线性表，栈、队列和数组，串，树与二叉树，即王道书前五章内容，均为本人考研过程中自己整理总结。后续内容会逐步更新。
【考研必备】数据结构-思维导图.pdf
05-15
1、在408真题中的数据结构部分的题目可以看出：选择题大多考察相应结构/算法的中间过程，能从计算机的角度出发去思考计算机处理这个问题处理的整个过程是什么样的，而不要从个人主观上出发去看此结构/算法；...
【数据结构】复习攻略——计算机考研最重要的专业课
计算机与软件考研
06-11 1149
“数据结构”是计算机、软件工程等计算机类专业考研时，最经常考的科目之一，也是很多同学头疼的科目。本文介绍的方法是通用的，既适用于408中的数据结构部分，也适用于大部分自主命题科目的数据结构部分。图灵奖获得者，计算机科学家 Niklaus Wirth 曾经说过一句著名的话:Algorithm+Data Structures=Programs翻译过来就是：算法...
【考研易忘知识点】数据结构
weixin_45628782的博客
11-16 1850
数据结构算是几天之内重新过了一遍知识点，个人觉得数据结构的内容比较通俗易懂，学会了没那么容易忘记，与之相比，剩下的三本书可以说是折磨了。后序线索二叉树求不出后序后继 前序线索二叉树求不出前序前驱 所以后序线索二叉树的遍历需要栈的支持。对于n阶B树来说 首先得满足至少有一个节点有5个孩子 才能考虑其他。图的所有生成树的边数是相同的，其中数值之和最小的生成树为最小生成树。回路不是简单路径(回路怎么可能是路径！n个节点的红黑树高度≤2logn+1。左根右 根叶黑 不红红 黑路同。在查找的时候用了折半查找。
数据结构(考研必备)
研究方向：机器学习、深度学习、AIOT
03-29 511
在实际编程中，数据结构是实现高效算法和程序的关键。因此，对于计算机科学和软件工程专业的学生和从事软件开发的工程师来说，学习数据结构是非常重要的。数据结构是计算机科学中的一个基本概念，它是指数据元素之间的关系以及对这些数据元素的操作，是计算机程序设计中不可或缺的一部分。数据结构可以用于描述和组织数据，使得数据的存储、检索和处理变得更加高效和方便。除此之外，掌握数据结构还可以培养我们的抽象思维能力、逻辑思维能力和问题解决能力，这些能力不仅对计算机科学专业有用，也对其他领域的学习和工作有益。
《数据结构》C语言版 (清华严蔚敏考研版） 全书知识梳理
热门推荐
12 26 25 的博客
01-20 18万+
写在前面： 恰逢期末复习，用了几天时间结合老师勾画的重点以及课件教材等，将全书重要内容做了个大整合。一方面便于自己复习记忆，另一方面po出来让更多需要的人也可以做个参考。 同类梳理： 《数据库系统概论》第五版(王珊版）全书知识梳理 《计算机组成原理》第五版(唐朔飞考研版） 全书知识梳理 《数据结构》C语言版 (清华严...
数据结构笔记（考研）
qq_40837276的博客
02-21 1672
目录一、算法概述算法的定义：基本特性：算法的基本要求二、数据的逻辑结构集合结构线性结构数组：栈队列单链表循环链表双链表递归排序算法树形结构图形结构 一、算法概述 算法的定义： 算法是解决特定问题求解决步骤的描述，再计算机中表现为指令的有限序列，并且每条指令表示一个或多个操作。 基本特性： 输入、输出、又穷性、确定性、可行性 输入：算法具有零个或多个输入 输出：算法至少有一个或多个输出 有穷性：指算法再执行有限的步骤之后，自动结束而不会出现无心循环，并且每一个步骤再可接受的时间内完成 确定性：算法的每一个步骤
408考研-数据结构算法
JAVA技术博客
08-29 472
线性表，从名字上你就能感觉到，是具有像线一样的性质的表。一个班级的小朋友，一个跟着一个排着队，有一个打头，有一个收尾，当中的小朋友每一个都知道他前面一个是谁，他后面一个是谁，这样如同有一根线把他们串联起来了。就可以称之为线性表。线性表（List）：零个或多个数据元素的有限序列。
考研复试——数据结构
weixin_46351593的博客
03-02 1508
数据结构是指相互之间存在一种或多种关系的数据元素的集合。树是一种非线性的数据结构，其元素之间有明显的层次关系，由结点和边组成且不存在环；在树的结构中，每个结点都只有一个前件称为父结点，没有前件的结点为树的根结点，简称为树的根；每个结点可以有多个后件成为结点的子结点，没有后件的结点称为叶子结点。树的存储结构、二叉树的存储结构。双亲存储结构（顺序存储）：用数组来存储，数组下标表示树的结点，数组元素的内容表示该结点的双亲结点；孩子兄弟存储结构。
考研数据结构代码合集
08-25
对于考研数据结构的代码合集，我可以为您提供一些常见的数据结构代码示例。以下是一些常见的数据结构及其对应的代码合集： 1. 数组(Array)： - 数组的初始化、插入、删除等操作。 - 数组的查找算法，如二分查找等...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

别云超

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值