栈和队列

栈和队列

1.栈

1.1概念：栈是一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的元素遵守后进先出LIFO（Last In First Out）的原则。

压栈：栈的插入操作叫做进栈、压栈或入栈，插入数据在栈顶。

出栈：栈的删除操作叫做出栈。出数据也在栈顶。

1.2栈的实现：栈的实现一般可以使用 数组或链表来实现，相对而言数组的结构实现更好一点。因为数组的尾插的代价更小一点。

下面是我的实现栈的一些接口：

typedef struct Stack {
	int array[100];
	int top;
}	Stack;

// 初始化
void StackInit(Stack *stack) {
	stack->top = 0;
}

// 压栈（尾插）
void StackPush(Stack *stack, int value) {
	stack->array[stack->top] = value;
	stack->top++;
}

// 出栈、弹出（尾删）
void StackPop(Stack *stack) {
	stack->top--;
}

// 返回栈顶元素
int StackTop(const Stack *stack) {
	return stack->array[stack->top - 1];
}

// 判断是否为空
int StackEmpty(const Stack *stack) {
	return stack->top == 0 ? 1 : 0;
}

// 获取 size
int StackSize(const Stack *stack) {
	return stack->top;
}


// 1. 括号匹配
bool isValid(char* s) {
	Stack	stack;
	StackInit(&stack);
	
	while (*s != '\0') {
		switch (*s) {
		case '{':
		case '[':
		case '(':
			StackPush(&stack, (int)*s);
			break;
		case '}':
		case ']':
		case ')': {
					  if (StackEmpty(&stack)) {
						  return false;
					  }

					  char left = (char)StackTop(&stack);
					  StackPop(&stack);
					  if (!(left == '(' && *s == ')'
						  || left == '[' && *s == ']'
						  || left == '{' && *s == '}')) {
						  return false;
					  }
			break;
		}
		default:
			break;
		}

		s++;
	}

	if (!StackEmpty(&stack)) {
		return false;
	}

	return true;
}

---

2.队列

2.1队列的概念：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出FIFO（First In First Out）的原则。

入队列：进行插入操作的一端称为 队尾。

出队列：进行删除操作的一端称为 队头。

2.2队列的实现：队列可以用数组也可以用链表。但是这里使用链表更好一点。因为数组在出队的时候需要移动整个数组，效率低。

下面是我实现队列的一些接口：

typedef struct Node {
	int value;
	struct Node *next;
}	Node;

// 头删 + 尾插
typedef struct Queue {
	Node *front;		// 链表的第一个结点
	Node *rear;			// 链表的最后一个结点
	int size;			// 数据个数
}	Queue;

// 初始化
void QueueInit(Queue *queue) {
	queue->front = NULL;
	queue->rear = NULL;
	queue->size = 0;
}
// 销毁
void QueueDestroy(Queue *queue) {
	Node *node, *next;
	for (node = queue->front; node != NULL; node = next) {
		next = node->next;
		free(node);
	}

	queue->front = queue->rear = NULL;
	queue->size = 0;
}

// Push ，队尾插入，即链表的尾插
void QueuePush(Queue *queue, int val) {
	Node *node = (Node *)malloc(sizeof(Node));
	node->value = val;
	node->next = NULL;
	queue->size++;

	if (queue->rear != NULL) {
		queue->rear->next = node;
		queue->rear = node;
	}
	else {
		queue->front = queue->rear = node;
	}
}

// Pop， 队首出列，即链表的头删
void QueuePop(Queue *queue) {
	assert(queue->size > 0);
	queue->size--;
	Node *front = queue->front;
	queue->front = queue->front->next;
	free(front);

	if (queue->front == NULL) {
		// 处理只有一个结点的情况
		queue->rear = NULL;
	}
}

// Front	返回队首元素
int QueueFront(const Queue *queue) {
	return queue->front->value;
}


// Rear		返回队尾元素
int QueueRear(const Queue *queue) {
	return queue->rear->value;
}
// Empty	是否为空
int QueueEmpty(const Queue *queue) {
	return queue->size == 0 ? 1 : 0;
}
// Size
int QueueEmpty(const Queue *queue) {
	return queue->size;
}