C语言数据结构之栈

1.数组栈

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

typedef struct Stack 
{
	int* dataMemory;
	int top;
	int maxSize;
}STACK,*LPSTACK;

LPSTACK createStack(int maxSize) {
	LPSTACK arrStack = (LPSTACK)malloc(sizeof(LPSTACK));
	assert(arrStack);
	arrStack->dataMemory = (int*)malloc(sizeof(int) * maxSize);
	assert(arrStack->dataMemory);
	arrStack->maxSize = maxSize;
	arrStack->top = -1;
	return arrStack;
}
void push(LPSTACK pStack, int data) {
	if (pStack == NULL) {
		return;
	}
	if (pStack->top + 1 == pStack->maxSize) {
		printf("full stack!");
		return;
	}
	pStack->dataMemory[++(pStack->top)] = data;
}
void pop(LPSTACK pStack) {
	if (pStack == NULL || pStack->top == -1) {
		printf("empty stack!");
		return;
	}
	pStack->top--;
}
int top(LPSTACK pStack) {
	return pStack->dataMemory[pStack->top];
}
void pop_top(LPSTACK pStack,int* data) {
	if (pStack == NULL || pStack->top == -1) {
		printf("empty stack!");
		return;
	}
	*data = pStack->dataMemory[pStack->top--];
}
int size(LPSTACK pStack) {
	return pStack->top + 1;
}
int empty(LPSTACK pStack) {
	return pStack->top == -1;
}

int main() {
	LPSTACK pStack = createStack(10);
	for (int i = 0; i < 10; i++) {
		push(pStack, i);
	}
	while (!empty(pStack)) {
		printf("%d\n", top(pStack));
		pop(pStack);
	}
	printf("\n");
	return 0;
}

2.链式栈

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
//fisrt in last out
//头插法，头删法

//节点基本组成
typedef struct Node {
	int data;
	struct Node* pnext;
}NODE,*LPNODE;
//创建节点
LPNODE createNode(int data) {
	LPNODE newNode = (LPNODE)malloc(sizeof(NODE));
	assert(newNode);
	newNode->data = data;
	newNode->pnext = NULL;
	return newNode;
}
//栈基本结构
typedef struct Stack {
	LPNODE topStack;
	int curSize;
}STACK,*LPSTACK;
//创建栈
LPSTACK createStack() {
	LPSTACK newStack = (LPSTACK)malloc(sizeof(STACK));
	assert(newStack);
	newStack->topStack = NULL;
	newStack->curSize = 0;
}
//入栈
void push(LPSTACK pStack, int data) {
	//表头法插入
	LPNODE newNode = createNode(data);
	if (pStack->curSize == 0) {
		pStack->topStack = newNode;
	}
	else {
		newNode->pnext = pStack->topStack;
		pStack->topStack = newNode;
	}
	pStack->curSize++;
}
int size(LPSTACK pStack) {
	return pStack->curSize;
}
int empty(LPSTACK pStack) {
	return pStack->curSize == 0;
}

//获取栈顶元素
int top(LPSTACK pStack) {
	if (pStack->topStack == NULL || pStack->curSize == 0) {
		printf("empty stack!");
		return 0;
	}
	return pStack->topStack->data;
}
void pop(LPSTACK pStack) {
	//无头链表头删法
	if (pStack->topStack == NULL || pStack->curSize == 0) {
		printf("empty stack!");
		return;
	}
	LPNODE tempNode = pStack->topStack->pnext;
	free(pStack->topStack);
	pStack->topStack = tempNode;
	
	pStack->curSize--;
}

int main() {
	LPSTACK pStack = createStack();
	for (int i = 0; i < 10; i++) {
		push(pStack, i);
	}
	while (!empty(pStack)) {
		printf("%d\n", top(pStack));
		pop(pStack);
	}
	printf("\n");
	return 0;
}

3.双向栈

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

typedef struct Stack {
	int* dataMemory;
	int maxSize;
	int stackTop[2];	//一左一右
}STACK,*LPSTACK;
//选择入栈方法
enum WAY {
	LEFT,RIGHT
};
LPSTACK createStack(int maxSize) {
	LPSTACK pStack = (LPSTACK)malloc(sizeof(STACK));
	assert(pStack);
	pStack->maxSize = maxSize;
	pStack->dataMemory = (int*)malloc(sizeof(int) * maxSize);
	assert(pStack->dataMemory);
	pStack->stackTop[LEFT] = -1;
	pStack->stackTop[RIGHT] = maxSize;
	return pStack;

}
void push(LPSTACK pStack,int data,enum WAY way) {
	if (pStack->stackTop[LEFT] + 1 == pStack->stackTop[RIGHT]) {
		printf("full stack!");
		return;
	}
	switch (way)
	{
	case LEFT:
		pStack->dataMemory[++pStack->stackTop[LEFT]] = data;
		break;
	case RIGHT:
		pStack->dataMemory[--pStack->stackTop[RIGHT]] = data;
		break;
	default:
		break;
	}
}
void pop(LPSTACK pStack,int *data,enum WAY way) {
	
	switch (way)
	{
	case LEFT:
		if (pStack == NULL || pStack->stackTop[LEFT] == -1) {
			printf("run out of LEFT range!");
			return;
		}
		*data = pStack->dataMemory[pStack->stackTop[LEFT]--];
		break;
	case RIGHT:
		if (pStack == NULL || pStack->stackTop[RIGHT] == pStack->maxSize) {
			printf("run out of RIGHT range!");
			return;
		}
		*data = pStack->dataMemory[pStack->stackTop[RIGHT]++];
		break;
	default:
		break;
	}
}
int empty(LPSTACK pStack,enum WAY way) {
	return way == LEFT ? pStack->stackTop[LEFT] == -1 : pStack->stackTop[RIGHT] == pStack->maxSize;
}
int main() {
	srand((size_t)time(NULL));
	LPSTACK pStack = createStack(10);
	
	for (int i = 0; i < 10; i++) {
		push(pStack, rand() % 100, rand() % 2);
	}
	for (int i = 0; i < pStack->maxSize; i++) {
		printf("%d\t", pStack->dataMemory[i]);
	}
	printf("\n");
	int data = 0;

	while (!empty(pStack,LEFT))
	{
		pop(pStack, &data, LEFT);
		printf("Left data:%d\n", data);
	}
	while (!empty(pStack, RIGHT))
	{
		pop(pStack, &data, RIGHT);
		printf("Right data:%d\n", data);
	}
	
	
	return 0;
}

4.栈的应用

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
void testDtoB(int num) {
	int stack[10];
	int top = -1;

	while (num != 0)
	{
		stack[++top] = num % 2;		//入栈函数
		num /= 2;
	}
	//出栈
	while (top != -1) {
		printf("%d", stack[top--]);
	}
}

//括号匹配
//遇到(入栈，遇到)出栈
int match(const char* str) {
	char stack[1024];
	int top = -1;
	
	int i = 0;
	while (str[i] != '\0') {
		if (str[i] == '(') {
			stack[++top] = str[i];
		}
		else if (str[i] == ')') {
			if (top > -1) {
				top--;
			}
			else {
				return 1;
			}
		}
		i++;
	}
	if (top == -1) {
		return 0;
	}
	else {
		return 1;
	}
}

int main() {
	//实际中使用栈，直接用数组
	//用的栈思想
	//求进制转换
	while (1) {
		char str[1024];
		gets_s(str, 1024);
		int result = match(str);
		if (result == 1) {
			printf("not match!\n");
		}
		else {
			printf("match succeed!\n");
		}
	}



	return 0;
}