第十一周知识总结

1.学习了动态数组的栈

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include "动态数组的栈 .h"

void initial(Stack *S) { // 分配一段元素的长度，顶部指向 -1。
// 分配一段的元素的内存空间。
S->elem = (ElemType *) calloc(SEGMENT, SEGMENT*sizeof(ElemType));
S->top = -1; // 栈初始状态为空，顶部指向 -1。
S->capacity = SEGMENT; // 栈初始内存容量。
}

// 入栈，将一个元素推入栈中。
void push(Stack *S, ElemType e) {

S->elem[++S->top] = e; // 将元素 e 放入栈中，顶部往上移一个位置。
if (S->top>=S->capacity) {// 如果栈已满，将栈扩张一段元素。
// 重新分配内存空间，增加一段元素。
S->elem = (ElemType *) realloc(S->elem, (S->capacity+SEGMENT)*sizeof(ElemType));
S->capacity += SEGMENT; // 修改栈的内存容量。
}
}

// 出栈，将一个元素从栈弹出；若栈为空的，返回 -1。
ElemType pop(Stack *S) {
ElemType e; // 将弹出的元素。

if (S->top<0) return -1; // 栈上空的，不能出栈。
S->elem[S->top--] = e ; // 取出目前的顶部元素。
if (S->top<=S->capacity-SEGMENT*2) {
// 重新分配内存空间，减少一段元素。
S->elem = (ElemType *) realloc(S->elem,(S->capacity-SEGMENT)*sizeof(ElemType));
S->capacity -= SEGMENT; // 修改栈的内存容量。
}
return e; // 返回弹出的元素。
}

// 查看顶部元素；若栈为空的，返回 -1。
ElemType top(Stack S) {
if (S.top<0) return -1; // 栈上空的，没有顶部元素。
else return S.top; // 返回顶部元素。
}

// 查看栈是否为空；为空，返回 1；否则，返回 0。
int is_empty(Stack S) {
return S.top==-1; // 为空，返回 1；否则，返回 0。
}

// 查看栈的元素个数。(非基本操作)
int get_size(Stack S) {
return S.top + 1; // 返回元素个数。
}

// 将线性表 L 清空。
void clear(Stack *S) {
// 重新分配栈的内存空间。
S->elem = (ElemType *) realloc(S->elem, SEGMENT * sizeof(ElemType));
S->top = -1; // 重设栈为空。
S->capacity = SEGMENT; // 重设内存空间。
}

// 从底部到顶部打印栈的元素。(非基本操作)
void print_stack(Stack S) {
int i; // 循环变量。

printf("栈的内存容量：%3d 元素\n", S.capacity);
printf("栈的元素个数：%3d 元素\n", S.top+1);
printf("****从底部到顶部\n");

for (i=0; i<S.top+1; i++) {
printf("%3d ", S.elem[i]); // 打印第 i 个元素。
if ((i+1)%20==0) printf("\n"); // 每行 20 个元素。
}
if ((i%20)!=0) printf("\n"); // 若不足 20 个元素，打印一个换行。
printf("\n"); // 打印一个换行。
}

int main(void) {
Stack S; // 声明一个栈。
int trial_count; // 测试回数。
int push_count; // 每回入栈元素个数。
int pop_count; // 每回出栈元素个数。
int i, j; // 循环变量。

initial(&S); // 初始化栈 S。

srand(time(NULL)); // 随机数生成器的种子。

trial_count = 1;
printf("测试回数：%d\n\n", trial_count); // 打印测试回数。

for (i=0; i<trial_count; i++) {
push_count = rand() % 100 + 1; // 每回入栈元素个数，最多 100 个元素。
printf("\n入栈 %d 个元素，入栈后的 S：\n", push_count);

for (j=0; j<push_count; j++)
push(&S, rand()%100); // 将元素入栈。
print_stack(S); // 从底部到顶部打印栈的元素。

pop_count = rand() % get_size(S) + 1; // 每回出栈元素个数，最多目前元素个数。
printf("\n出栈 %d 个元素，出栈后的 S：\n", pop_count);
for (j=0; j<pop_count; j++)
pop(&S); // 将元素出栈。
print_stack(S); // 从底部到顶部打印栈的元素。
printf("-------------------------------------------------------------------\n"); // 打印分隔线。
}

return 0;
}

2.学了了动态数组的队列

#include <stdio.h>
#include <stdlib.h>
#include "动态数组的队列 .h"

//基本操作介面：
// 初始化队列。
void initial(Queue *Q) { // 分配一段元素的长度，顶部指向 -1。
// 分配队列内存空间。
Q->elem = (ElemType *) malloc(SEGMENT * sizeof(ElemType));
Q->head = -1; // 设定头部索引为 -1。
Q->tail = -1; // 设定尾部索引为 -1。
Q->capacity = SEGMENT; // 设定队列的初始容量。
}

// 入队，将一个元素放入队列中。
void enqueue(Queue *Q, ElemType e) {
ElemType *elemPtr; // 新的队列内存指针。
int size; // 队列元素个数。
int i; // 循环变量。

if (Q->tail==-1) { // 若队列是空的
Q->elem[0] = e; // 将元素放入索引为 0 的位置。
Q->head = 0; // 设定头部索引为 0。
Q->tail = 0; // 设定尾部索引为 0。
Q->capacity = SEGMENT; // 设定队列的初始容量。
}
else { // 加一个元素到队列。
Q->tail = (Q->tail + 1) % Q->capacity; // 设定新的尾部索引，循环索引。
Q->elem[Q->tail] = e; // 将元素放入尾部的位置。
size = get_size(*Q); // 取得队列元素个数。
if (Q->capacity-size==0) { // 若队列元素已满，扩增一段元素。
// 分配新的队列内存，容量扩增一段元素。
elemPtr = (ElemType *) malloc((Q->capacity + SEGMENT) * sizeof(ElemType));
for (i=0; i<size; i++) // 搬动队列的所有元素。
elemPtr[i] = Q->elem[(Q->head+i)%Q->capacity];
free(Q->elem); // 释放队列原来的内存空间。
Q->elem = elemPtr; // 置换成新的内存空间。
Q->head = 0; // 新的头部索引。
Q->tail = size - 1; // 新的尾部索引。
Q->capacity += SEGMENT; // 新的队列容量。
}
}
}
// 出队，将一个元素从队列移出；若队列为空的，返回 -1。
ElemType dequeue(Queue *Q) {
ElemType e; // 出队的元素。
ElemType *elemPtr; // 新的队列内存指针。
int size; // 队列元素个数。
int i; // 循环变量。

if (Q->head==-1) return -1; // 队列是空的，返回 -1。

e = Q->elem[Q->head]; // 取得队列的头部元素。
if (Q->head==Q->tail) clear(Q); // 队列只有一个元素，清除队列。
else { // 队列有多个元素。
// 设定新的头部索引，循环索引。
Q->head = (Q->head + 1) % Q->capacity;
size = get_size(*Q); // 取得队列元素个数。
if (Q->capacity-size>=SEGMENT*2) {
// 分配新的队列内存，容量缩减一段元素。
elemPtr = (ElemType *) malloc((Q->capacity - SEGMENT) * sizeof(ElemType));
for (i=0; i<size; i++) // 搬动队列的所有元素。
elemPtr[i] = Q->elem[(Q->head+i)%Q->capacity];
free(Q->elem); // 释放队列原来的内存空间。
Q->elem = elemPtr; // 置换成新的内存空间。
Q->head = 0; // 新的头部索引。
Q->tail = size - 1; // 新的尾部索引。
Q->capacity -= SEGMENT; // 新的队列容量。
}
}
return e; // 返回原来头部的元素。
}

// 查看头部元素；若队列为空的，返回 -1。
ElemType get_head(Queue Q) {
if (Q.head==-1) return -1; // 队列是空的，返回 -1。
else return Q.head; // 返回队列头部元素。
}

// 查看队列是否为空；为空，返回 1；否则，返回 0。
int is_empty(Queue Q) {
return Q.tail==-1; // 若尾部索引为 -1，则队列为空。
}

// 查看队列的元素个数。(非基本操作)
int get_size(Queue Q) {
// 计算队列元素个数，头部索引和尾部索引都是循环索引。
return (Q.tail - Q.head + Q.capacity) % Q.capacity + 1;
}

// 将队列清空，队列的容量改为一段元素的长度。(非基本操作)
void clear(Queue *Q) {
// 重新配置队列的内存。
Q->elem = (ElemType *) realloc(Q->elem, SEGMENT * sizeof(ElemType));
Q->head = -1; // 设定头部索引为 -1。
Q->tail = -1; // 设定尾部索引为 -1。
Q->capacity = SEGMENT; // 设定队列的初始容量。
}

// 从头部到尾部打印队列的元素。(非基本操作)
void print_queue(Queue Q) {
int size=get_size(Q); // 队列元素个数。
int i; // 循环变量。

printf("队列的内存容量：%3d 元素\n", Q.capacity);
printf("队列的元素个数：%3d 元素\n", size);
printf("****从头部到尾部\n");
for (i=0; i<size; i++) {
printf("%3d ", Q.elem[(Q.head+i+Q.capacity)%Q.capacity]); // 打印第 i 个元素。
if ((i+1)%20==0)
printf("\n"); // 每行 20 个元素。
}
if ((i%20)!=0)
printf("\n"); // 若不足 20 个元素，打印一个换行。
printf("\n"); // 打印一个换行。
}

int main(void) {
Queue Q; // 声明一个队列
int trial_count; // 测试回数。
int enqueue_count; // 每回入队元素个数。
int dequeue_count; // 每回出队元素个数。
int i, j; // 循环变量。

initial(&Q); // 初始化队列 Q。

srand(time(NULL)); // 随机数生成器的种子。

trial_count = 1; // 测试回数, 最多 10 回。
printf("测试回数：%d\n\n", trial_count); // 打印测试回数。

for (i=0; i<trial_count; i++) {
printf(">>>> 第 %d 回入队/出队\n", i+1);
enqueue_count = rand() % 100 + 1; // 每回入队元素个数，最多 100 个元素。
printf("入队 %d 个元素，入队后的 Q：\n", enqueue_count);
for (j=0; j<enqueue_count; j++) enqueue(&Q, rand()%100); // 将元素入队。
print_queue(Q); // 从头部到尾部打印队列的元素。

// 每回出队元素个数，最多目前元素个数。
dequeue_count = rand() % get_size(Q) + 1;
printf("出队 %d 个元素，出队后的 Q：\n", dequeue_count);
for (j=0; j<dequeue_count; j++) dequeue(&Q); // 将元素出队。
print_queue(Q); // 从头部到尾部打印队列的元素。
printf("-------------------------------------------------------------------\n"); // 打印分隔线。
}

return 0;
}