数据结构与算法（1）

最新推荐文章于 2024-02-01 22:09:47 发布

蒙宇

最新推荐文章于 2024-02-01 22:09:47 发布

阅读量129

点赞数

分类专栏： LINUX C

本文链接：https://blog.csdn.net/qq_40632341/article/details/104302779

版权

LINUX C 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

1 基于顺序表的堆栈
2 基于链式表的堆栈
3 基于顺序表的队列
4 基于链式表的队列
1 基于顺序表的堆栈
栈是一种特殊的线性表，是限定在线性表表尾进行插入删除操作的线性表。由栈的概念衍生出几个子概念，它们是：

1)栈顶，即允许进行插入、删除操作的一端，又称为表尾，用栈顶指针(top)来指示栈顶元素。

2)栈底，即固定端，又称为表头

3)空栈，即栈当中没有数据元素。

顺序栈是采用顺序存储结构的栈，即使用一组连续的存储单元（一般使用数组）来模拟栈，依次存放栈中的数据元素。

1.1 方案
顺序栈的基本操作包括：

初始化操作，在初始化操作中将建立一个空栈。
判断栈空，判断栈中的数据元素个数是否为0。
入栈，在栈中加入一个数据元素。
出栈，在栈中删除一个数据元素。
取栈顶元素，将栈顶元素取出，但并不在栈中删除该元素。

1.2 步骤
实现此案例需要按照如下步骤进行。

步骤一：定义栈

在C语言中：

1)定义一个一维数组来表示栈的顺序存储空间。

2)定义一个变量来指出栈顶的位置。

3)这两方面的信息共同描述一个栈，可将它们用结构体封装在一起。

代码如下：

#define LISTSIZE 10
typedef int DataType;
struct Stack {
DataType data[LISTSIZE];
int top; //除了记录大小还可以记录栈顶位置
};
上述代码中，以下代码：

#define LISTSIZE 100
是用一个宏常量来定义顺序表的容量，这样定义的好处是当需要修改顺序表的容量的时候，只需要修改该宏常量即可。

上述代码中，以下代码：

typedef int DataType;
是将数据类型int起了一个别名叫做DataType，并在后面的程序中只使用DataType，而不使用int。这样做的好处是当堆栈中的数据类型发生变化时，只需要修改此句中的int为要改变的数据类型，即可将程序中所有数据变量的数据类型变成指定的类型。

步骤二：初始化操作

在主程序中，定义栈结构体的变量。

在初始化函数中将该变量中的栈顶指针初始化为0，表示为空栈。

代码如下：

void init(struct Stack *stack)
{
stack->top = 0;
}
int main(int argc, const char * argv[])
{
struct Stack stack;
init(&stack);
}
步骤三：判断栈空

判断栈空实际上是判断栈顶指针是否为0，因为当栈顶指针为0时，代表栈中没有数据元素。

代码如下：

bool empty(struct Stack* stack) {
return stack->top == 0;
}
步骤四：入栈

入栈是在栈中加入一个数据元素，在入栈时，首先需要判断栈是否为满，如果栈满了，则就不能在向其中添加元素了，判断栈是否满的操作只有在顺序存储结构才会出现，因为采用顺序存储结构的栈是要事先定义栈的容量的。然后将数据元素放入栈中，并使栈顶指针加1，指向下一个位置。

代码如下：

void push(struct Stack* stack, DataType d) {
if (stack->top == LISTSIZE)
return;
stack->data[stack->top++] = d;
}
上述代码中，以下代码：

if (stack->top == LISTSIZE)

是判断栈是否满，判断栈顶指针是否与栈的容量相等，如果是，则表示栈已经满了。

步骤五：出栈

出栈操作实际上是将栈中的栈顶元素删除，在出栈时，首先判断栈是否为空，如果栈为空则代表栈中已经没有数据元素了，此时是不可能进行出栈操作的。然后，将栈顶指针减1。

代码如下：

void pop(struct Stack* stack) {
if (empty(stack))
return;
stack->top–;
}
步骤六：取栈顶元素

取栈顶元素操作实际上是仅返回栈顶元素，而栈顶指针并不变动。在取栈顶元素时，首先也要判断栈是否为空，因为空栈同样是不可能有数据元素的。

代码如下：

DataType topData(struct Stack* stack) {
return stack->data[stack->top - 1];
}
1.3 完整代码
本案例的完整代码如下所示：

#include <stdio.h>
#include <stdbool.h>
#define LISTSIZE 10
typedef int DataType;
struct Stack {
DataType data[LISTSIZE];
int top; //处了记录大小还可以记录栈顶位置
};
void init(struct Stack* stack)
{
stack->top = 0;
}
bool empty(struct Stack* stack) {
return stack->top == 0;
}
void push(struct Stack* stack, DataType d) {
if (stack->top == LISTSIZE)
return;
stack->data[stack->top++] = d;
}
void pop(struct Stack* stack) {
if (empty(stack))
return;
stack->top–;
}
DataType topData(struct Stack* stack) {
return stack->data[stack->top - 1];
}
int main()
{
struct Stack stack;
init(&stack);
push(&stack, 30);
push(&stack, 60);
push(&stack, 80);

while (!empty(&stack)) {
    printf("%d ", topData(&stack));
    pop(&stack);
}
printf("\n");

return 0;

}
2 基于链式表的堆栈
2.1 问题
链栈是采用链式存储结构的栈，即使用一组不要求连续的存储空间来模拟栈。每个栈元素为一个节点，每个节点中包含两个域，一个是数据域，用于存储栈元素的数据；另一个是指针域，用于存储下一个栈元素的地址。

2.2 方案
链栈的基本操作包括：

初始化操作，在初始化操作中将栈顶指针置空。
判断栈空，判断栈顶指针是否为空。
入栈，在栈中加入一个数据元素。
出栈，在栈中删除一个数据元素。
取栈顶元素，将栈顶元素取出，但并不在栈中删除该元素。

2.3 步骤
实现此案例需要按照如下步骤进行。

步骤一：定义栈元素节点

在C语言中：

1)定义一个变量来表示栈元素的数据。

2)定义一个指针来指向下一个栈元素的位置。

3)这两方面的信息共同描述一个栈元素节点，可将它们用结构体封装在一起。

代码如下：

typedef int DataType;
struct Stack {
DataType data;
struct Stack *next;
};
上述代码中，以下代码：

struct Stack *next;

是定义了一个指向下一个栈元素的指针，由于下一个栈元素的数据类型与当前栈元素的数据类型相同，所以指针的数据类型就是栈节点的指针数据类型。

步骤二：初始化操作

在主程序中，定义栈顶指针。

在初始化函数中将栈顶指针初始化为NULL，表示为空栈。

代码如下：

void init(struct Stack** top)
{
*top = NULL;
}
int main()
{
struct Stack *top;
init(&top);
return 0;
}
上述代码中，以下代码：

void init(struct Stack** top)
定义了初始化函数的函数头，该函数有一个形参，是栈元素结构体指针的指针。之所以使用指针的指针，是因为栈顶指针在函数执行过程中会被置空，而这种变化需要带回主函数。

步骤三：判断栈空

判断栈空操作实际上就是判断栈顶指针是否为空。

代码如下所示：

bool empty(struct Stack* top)
{
return top == NULL;
}
步骤四：入栈

入栈操作实际上就是在栈中加入一个数据元素，对于链栈，入栈操作本质上就是在栈中加入一个结点。

代码如下所示：

void push(struct Stack** top, DataType d)
{
struct Stack newNode = (struct Stack)malloc(sizeof(struct Stack));
newNode->data = d;
newNode->next = *top;
*top = newNode;
}
上述代码中，以下代码：

void push(struct Stack** top, DataType d)
定义了入栈函数的函数头，该函数有两个形参，第一个是栈结构的指针的指针，在这里使用指针的指针，还是因为需要将栈顶指针的变化带回主函数。第二个形参是需要入栈的数据。

上述代码中，以下代码：

struct Stack *newNode = (struct Stack*)malloc(sizeof(struct Stack));

是构造一个新的栈元素节点。

上述代码中，以下代码：

newNode->data = d;

是将需要入栈的元素放入新的栈元素节点中。

上述代码中，以下代码：

newNode->next = *top;

是将新创建的栈元素节点加入到栈中原栈顶元素的前面，成为新的栈顶元素。

上述代码中，以下代码：

*top = newNode;

是栈顶指针指向新创建的栈顶元素。正是由于这行代码，使栈顶指针发生了变化，而这种变化需要带回到主程序，所以函数的第一个形参必须是指针的指针。

步骤五：出栈

出栈操作实际上就是从栈中删除栈顶位置的元素，对于链栈，出栈操作本质上就是在栈中删除一个结点。

代码如下所示：

void pop(struct Stack** top)
{
if (empty(*top))
return;
struct Stack *tempNode = *top;
*top = (*top)->next;
free(tempNode);
}
上述代码中，以下代码：

if (empty(*top))
    return;

是判断链栈是否为空，如果栈为空是不能从栈中删除元素的。

上述代码中，以下代码：

struct Stack *tempNode = *top;
*top = (*top)->next;
free(tempNode);

首先用一个临时指针保存原栈顶指针指向的栈元素地址，即出栈元素的地址，然后将栈顶指针指向下一个元素，这样栈中就减少了一个元素。最后释放临时指针指向的元素，即释放出栈元素所占的存储空间。

步骤六：取栈顶元素

取栈顶元素实际上就是将栈顶元素的值返回，对于链栈，本质上是将栈顶节点的数据返回。注意，在取栈顶元素时，首先要判断栈是否为空，空栈是没有数据元素的。

代码如下：

void topData(struct Stack* top, DataType* data)
{
if (empty(top))
return;
*data = top->data;
}
2.4 完整代码
本案例的完整代码如下所示：

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
typedef int DataType;
struct Stack {
DataType data;
struct Stack next;
};
void init(struct Stack* top)
{
top = NULL;
}
bool empty(struct Stack top)
{
return top == NULL;
}
void push(struct Stack** top, DataType d)
{
struct Stack newNode = (struct Stack)malloc(sizeof(struct Stack));
newNode->data = d;
newNode->next = top;
top = newNode;
}
void pop(struct Stack top)
{
if (empty(*top))
return;
struct Stack *tempNode = *top;
top = (top)->next;
free(tempNode);
}
void topData(struct Stack top, DataType data)
{
if (empty(top))
return;
*data = top->data;
}
int main()
{
struct Stack *top;
init(&top);
push(&top, 30);
push(&top, 60);
push(&top, 80);

while (!empty(top)) {
    int data;
    topData(top, &data);
    printf("%d ", data);
    pop(&top);
}
printf("\n");

return 0;

}
3 基于顺序表的队列
3.1 问题
队列是一种特殊的线性表，是限定在线性表表尾进行插入操作，而在线性表表头进行删除的线性表。由队列的概念衍生出几个子概念，它们是队首：允许进行删除的一端，又称为队头，用队首指针(front)来指示要删除的元素；队尾：允许进行插入的一端，用队尾指针(rear)来指示要插入元素的位置；空队，队列中没有元素时称为空队列。

顺序队是采用顺序存储结构的队，即使用一组连续的存储单元（一般使用数组）来模拟队，依次存放队中的数据元素。

顺序队中存在一个“假溢出”的现象，“假溢出”是指随着入队、出队的进行，使整个队列在数组中整体向后移动，队尾指针已经移到了数组的最后一个元素，再有元素入队就会出现溢出，而事实上，此时队列中并未真的“满员”的现象，因为出队会使位置空出，所以数组的前部仍然有空间。

为充分利用数组空间，克服“假溢出”现象，将队列分配的向量空间看成为一个首尾相接的圆环，并称这种队列为循环队列。

3.2 方案
顺序队的基本操作包括：

初始化操作，在初始化操作中将建立一个空队。
判断队空，判断队中的数据元素个数是否为0。
入队，在队中加入一个数据元素。
出队，在队中删除一个数据元素。
取队首元素，将队首元素取出，但并不在队中删除该元素。

3.3 步骤
实现此案例需要按照如下步骤进行。

步骤一：定义队

在C语言中：

1)定义一个一维数组data，来表示队的顺序存储空间。

2)定义一个变量front，来存储队首的位置。

3)定义一个变量rear，来存储队尾的位置。

4)这三方面的信息共同描述一个队，可将它们封装在一起。

代码如下：

typedef int DataType;
struct Queue2 {
DataType data[6];
int front; //队首指针
int rear; //队尾指针
};
上述代码中，以下代码：

typedef int DataType;
是将数据类型int起了一个别名叫做DataType，并在后面的程序中只使用DataType，而不使用int。这样做的好处是当队列中的数据类型发生变化时，只需要修改此句中的int为要改变的数据类型，即可将程序中所有数据变量的数据类型变成指定的类型。

步骤二：初始化操作

在主程序中，定义队结构体的变量。

在初始化函数中将该变量中的队首、队尾指针初始化为0，表示为空队。

代码如下：

void init(struct Queue2 *q)
{
q->front = q->rear = 0;
}
int main(int argc, const char * argv[])
{
Queue2 q2;
init(&q2);
}
步骤三：判断队空

判断队空实际上是判断队首指针与队尾指针是否相同，当队首指针与队尾指针相同时，代表队中没有数据元素。

代码如下：

bool empty(struct Queue2 *q) {
return q->rear - q->front == 0;
}
步骤四：入队

入队是在队中加入一个数据元素，在入队时，首先需要判断队是否为满，如果队满了，则就不能在向其中添加元素了，判断队是否满的操作只有在顺序存储结构才会出现，因为采用顺序存储结构的队是要事先定义队的容量的。然后将数据元素放入栈中，并使队首指针加1，指向下一个位置。

代码如下：

bool push(struct Queue2 *q, DataType d) {
if (q->rear - q->front == 6) return false;
q->data[q->rear++ % 6] = d;
return true;
}
上述代码中，以下代码：

if (q->rear - q->front == 6) return false;

是判断队是否满，当队尾指针与队首指针的差值为6时，则表示队已经满了。6是步骤一定义队时定义的队容量。

上述代码中，以下代码：

q->data[q->rear++ % 6] = d;

是将入队元素d放置在队尾指针指向的位置。其中q->rear++ % 6是形成循环队列的关键，队尾指针对6求余数，则保证了数组q->data[]的下标永远在0_{5之间变化，因为任何正整数对6求余数，余数只能是0}5，这样就保证数组不会越界访问，即防止了“假溢出”现象的出现。

步骤五：出队

出队操作实际上是将队中的队首元素删除，在出队时，首先判断队是否为空，如果队为空则代表队中已经没有数据元素了，此时是不可能进行出队操作的。然后，将队首指针加1。

代码如下：

bool pop(struct Queue2 *q) {
if (empty(q)) return false;
q->front++;
return true;
}
步骤六：取队首元素

取队首元素操作实际上是仅返回队首元素，而队首指针并不变动。在取队首元素时，首先也要判断队是否为空，因为空队同样是不可能有数据元素的。

代码如下：

DataType getFront(struct Queue2 *q) {
return q->data[q->front % 6];
}
上述代码中q->front % 6同样是形成循环队列的关键，队首指针对6求余数，则保证了数组q->data[]的下标永远在0_{5之间变化，因为任何正整数对6求余数，余数只能是0}5，这样就保证数组不会越界访问，即防止了“假溢出”现象的出现。

3.4 完整代码
本案例的完整代码如下所示：

//循环队列
#include <stdio.h>
#include <stdbool.h>
typedef int DataType;
struct Queue2 {
DataType data[6];
int front; //开始位置
int rear; //结束位置
};
void init(struct Queue2 *q)
{
q->front = q->rear = 0;
}
bool empty(struct Queue2 *q) {
return q->rear - q->front == 0;
}
bool push(struct Queue2 *q, DataType d) {
if (q->rear - q->front == 6) return false;
q->data[q->rear++ % 6] = d;
return true;
}
bool pop(struct Queue2 *q) {
if (empty(q)) return false;
q->front++;
return true;
}
DataType getFront(struct Queue2 *q) {
return q->data[q->front % 6];
}
int main() {

struct Queue2 q2;
init(&q2);
for (int i = 0; i < 6; i++) {
    push(&q2, i);
}
pop(&q2);
push(&q2, 300);
pop(&q2);
pop(&q2);
push(&q2, 200);
while (!empty(&q2)) {
    printf("%d ", getFront(&q2));
    pop(&q2);
}
printf("\n");

return 0;

}
4 基于链式表的队列
4.1 问题
链队是采用链式存储结构的队，即使用一组不要求连续的存储空间来模拟队。每个队元素为一个节点，每个节点中包含两个域，一个是数据域，用于存储队元素的数据；另一个是指针域，用于存储下一个队元素的地址。

4.2 方案
链队的基本操作包括：

初始化操作，在初始化操作中将队头、队尾指针置空。
判断队空，判断队首指针(front)是否为空。
入队，在队中加入一个数据元素。
出队，在队中删除一个数据元素。
取队首元素，将队首元素取出，但并不在队中删除该元素。

4.3 步骤
实现此案例需要按照如下步骤进行。

步骤一：定义队元素节点

在C语言中：

1)定义一个变量来表示队元素的数据。

2)定义一个指针来指向下一个队元素的位置。

3)这两方面的信息共同描述一个队元素节点，可将它们用结构体封装在一起。

代码如下：

typedef int DataType;
struct Queue {
DataType data;
struct Queue *next;
};
上述代码中，以下代码：

struct Queue *next;

是定义了一个指向下一个队元素的指针，由于下一个队元素的数据类型与当前队元素的数据类型相同，所以指针的数据类型就是队节点的指针数据类型。

步骤二：初始化操作

在主程序中，定义队头、队尾指针。

在初始化函数中将队头、队尾指针初始化为NULL，表示为空栈。

代码如下：

void init(struct Queue** front, struct Queue** rear)
{
*front = NULL;
*rear = NULL;
}
int main()
{
struct Queue *front, *rear;
init(&front, &rear);
return 0;
}
上述代码中，以下代码：

void init(struct Queue** front, struct Queue** rear)
定义了初始化函数的函数头，该函数有两个形参，都是队元素结构体指针的指针。之所以使用指针的指针，是因为队头、队尾指针在函数执行过程中会被置空，而这种变化需要带回主函数。

步骤三：判断队空

判断队空操作实际上就是判断队头或队尾是否为空。

代码如下所示：

bool empty(struct Queue* node)
{
return node == NULL;
}
步骤四：入队

入队操作实际上就是在队中加入一个数据元素，对于链队，入队操作本质上就是在队中加入一个结点。

代码如下所示：

void push(struct Queue** front, struct Queue** rear, DataType d)
{
struct Queue newNode = (struct Queue)malloc(sizeof(struct Queue));
newNode->data = d;
newNode->next = NULL;
if (*rear != NULL)
(*rear)->next = newNode;
*rear = newNode;
if (*front == NULL)
*front = *rear;
}
上述代码中，以下代码：

void push(struct Queue** front, struct Queue** rear, DataType d)
定义了入队函数的函数头，该函数有三个形参，前两个是队结构的指针的指针，在这里使用指针的指针，还是因为需要将队头、队尾指针的变化带回主函数。第三个形参是需要入栈的数据。

上述代码中，以下代码：

struct Queue *newNode = (struct Queue*)malloc(sizeof(struct Queue));

是构造一个新的队元素节点。

上述代码中，以下代码：

newNode->data = d;
newNode->next = NULL;

是将需要入队的元素放入新的队元素节点中。

上述代码中，以下代码：

if (*rear != NULL)
    (*rear)->next = newNode;
*rear = newNode;

首先判断队尾指针是否为空，如果不为空，则将新创建的队元素节点加入到队中原队尾元素的后面，成为新的队尾元素，并将队尾指针指向新创建的队元素节点。如果队尾指针为空，则表示此时队中没有元素，所以直接将队尾指针指向新创建的队元素节点即可。正是由于第三行代码，使队尾指针发生了变化，而这种变化需要带回到主程序，所以函数的第二个形参必须是指针的指针。

上述代码中，以下代码：

if (*front == NULL)
    *front = *rear;

是判断队头指针是否为空，如果为空，则表示队中没有元素，此时入队的元素为队中的唯一一个元素，所以此时队头、队尾指针均指向它。由于第二行代码，使队头指针发生了变化，而这种变化需要带回到主程序，所以函数的第一个形参必须是指针的指针。

步骤五：出队

出队操作实际上就是从队中删除队尾位置的元素，对于链队，出队操作本质上就是在队中删除一个结点。

代码如下所示：

void pop(struct Queue** front, struct Queue** rear)
{
if (empty(*rear))
return;
struct Queue *tempNode = *front;
*front = (*front)->next;
free(tempNode);
if (*front == NULL)
*rear = NULL;
}
上述代码中，以下代码：

if (empty(*rear))
    return;

是判断链队是否为空，如果队为空是不能从队中删除元素的。

上述代码中，以下代码：

struct Queue *tempNode = *front;
*front = (*front)->next;
free(tempNode);

首先用一个临时指针保存原队头指针指向的队元素地址，即出队元素的地址，然后将队头指针指向下一个元素，这样队中就减少了一个元素。最后释放临时指针指向的元素，即释放出队元素所占的存储空间。

上述代码中，以下代码：

if (*front == NULL)
    *rear = NULL;

是判断删除一个队元素后，队是否为空，如果队中没有元素了，也应该将队尾指针置为空，否则队尾指针将是野指针。

步骤六：取队首元素

取队首元素实际上就是将队头元素的值返回，对于链队，本质上是将队头节点的数据返回。注意，在取队首元素时，首先要判断队是否为空，空队是没有数据元素的。

代码如下：

void topData(struct Queue* front, DataType* data)
{
if (empty(front))
return;
*data = front->data;
}
4.4 完整代码
本案例的完整代码如下所示：

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
typedef int DataType;
struct Queue {
DataType data;
struct Queue next;
};
void init(struct Queue* front, struct Queue** rear)
{
front = NULL;
rear = NULL;
}
bool empty(struct Queue node)
{
return node == NULL;
}
void push(struct Queue* front, struct Queue** rear, DataType d)
{
struct Queue newNode = (struct Queue)malloc(sizeof(struct Queue));
newNode->data = d;
newNode->next = NULL;
if (*rear != NULL)
(*rear)->next = newNode;
rear = newNode;
if (front == NULL)
front = rear;
}
void pop(struct Queue front, struct Queue rear)
{
if (empty(*rear))
return;
struct Queue *tempNode = *front;
*front = (*front)->next;
free(tempNode);
if (front == NULL)
rear = NULL;
}
void topData(struct Queue front, DataType data)
{
if (empty(front))
return;
*data = front->data;
}
int main()
{
struct Queue *front, *rear;
init(&front, &rear);
push(&front, &rear, 30);
push(&front, &rear, 60);
push(&front, &rear, 80);

while (!empty(front)) {
    int data;
    topData(front, &data);
    printf("%d ", data);
    pop(&front, &rear);
}
printf("\n");
return 0;

}

蒙宇

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录