王道数据结构代码题（C语言） 栈部分

1（存疑）.

#include <stdio.h>
#include <stdlib.h>
#define TYPE char
#define NODETYPE int
typedef struct Link    // 链表
{
    int data;
	struct Link *next;
}Link;

struct Stack    // 栈
{
    NODETYPE *arr;  // 内存首地址
    int len;   // 容量
    int top;   // 栈下标
};

Link *createLink(int num) {  //创建链表
	int n, data;
	char letter;
	printf("请输入创建链表的结点个数：");
	scanf("%d", &n);
	Link *q;
	Link *head = (Link*) malloc(sizeof(Link));
	head->next = NULL;
	q = head;
	for (int i = 0; i < n; i++) {
		Link *newP = (Link*) malloc(sizeof(Link));
		num ? printf("请输入第%d个结点的值(char)：",i+1): printf("请输入第%d个结点的值(int)：", i + 1);
		if (num==0) {  // 0代表创建整数型结点
			scanf("%d", &data);
			newP->data = data;

		}
		else {  // 1代表创建字符型结点
			getchar();
			scanf("%c", &letter);
			newP->data = letter;
		}
		newP->next = NULL;
		head->next = newP;
		head = head->next;// head要始终指向最新结点
	}
	head->next = NULL;
	head = q;   //最后head要指向头结点
	printf("打印链表：");
	printf("\n");
	while (head->next) {
		if (num==0) {
			printf("%d ", head->next->data);
		}
		else {
			printf("%c", head->next->data);
		}

		head = head->next;
	}
	printf("\n");
	head = q;
	return head;
}

void isSymmetry(Link *h) {
    struct Stack *s;
    int size;
    struct Stack *createLink(int);
    bool push(Stack * , char);
    bool empty(Stack *);
    char top(Stack *);
    bool pop(Stack *);
    void destory(Stack *);

    printf("请输入要创建的栈的大小：");
    scanf("%d", &size);
    s = createLink(size);
    Link *fast = h->next, *slow = h->next;
    while(fast->next && fast->next->next){
        fast = fast->next->next;
        slow = slow->next;
    }

    fast = h->next;
    while(slow->next){   // 中间结点之后的元素依次入栈
        push(s,slow->next->data);
        slow = slow->next;
    }
    while(!empty(s)){
        if(fast->data != top(s)){
            printf("该链表非中心对称");
            break;
        }
        fast = fast->next;
        pop(s);
    }
	if(empty(s)){
        printf("链表对称");
	}
	destory(s);  // 销毁栈
}

/* --------------以下为实现函数--------------------*/
//创建一个栈
Stack *createStack(int size) {
	Stack *stack = (Stack*)malloc(sizeof(Stack));//给栈分配空间
	stack->arr = (NODETYPE*)malloc(sizeof(NODETYPE)*size);//给内存首地址分配空间，大小用户指定
	stack->len = size;//栈容量
	stack->top = -1;//栈顶下标，当前无元素，故为-1
	return stack;
}
//判断栈满
bool full(Stack *stack) {
	return stack->top + 1 >= stack->len;
}
//判断栈空
bool empty(Stack *stack) {
	return stack->top == -1;
}
//入栈
bool push(Stack *stack, NODETYPE p) {
	if (full(stack)) return false;
	*(stack->arr + ++stack->top) = p;
	return true;
}

//出栈
bool pop(Stack *stack) {
	if (empty(stack)) return false;
	stack->top--;
	return true;

}

//查看栈顶元素
NODETYPE top(Stack *stack) {
	if (empty(stack)) return NULL;
	return *(stack->arr + stack->top);
}

//销毁
void destory(Stack *stack) {
	free(stack->arr);
	free(stack);

}
//判断是否含有某个元素
bool contain(Stack *stack, NODETYPE r) {
	if (empty(stack)) return false;
	for (int i = stack->top; i >= 0; i--) {
		if (r == *(stack->arr + i) ){//疯了，我居然把==写成了=
			return true;
		}
	}
	return false;
}
//打印栈中元素
void print(Stack *stack) {
	if (empty(stack)) return;
	for (int i = stack->top; i >= 0; i--) {
		printf("%c",stack->arr[i]);
	}
}



int main() {
	Link *head;
	//Link *createLink(int);
	head = createLink(0);


	isSymmetry(head);

	return 0;
}

2（存疑）.

#include<stdio.h>
#include<stdbool.h>
#include<stdlib.h>
#define TYPE char
struct Stack
{
	TYPE* arr;	//内存首地址
	int top[2]; 	//栈的下标
};

/* --------------以下为实现函数--------------------*/
//创建一个栈
Stack *createStack(int size) {
	Stack *stack = (Stack*)malloc(sizeof(Stack));//给栈分配空间
	stack->arr = (TYPE *)malloc(sizeof(TYPE)*size);//给内存首地址分配空间，大小用户指定
	stack->top[0] = -1;//栈顶下标，当前无元素，故为-1
	stack->top[1] = size;//栈顶下标，当前无元素，故为-1
	return stack;
}
//判断栈满
bool full(Stack *stack) {
	return stack->top[1]-stack->top[0] == 1;
}
//判断栈空
bool empty(int i,Stack *stack,int size) {
	switch (i) {
	case 0:
		return stack->top[0] == -1;
	case 1:
			return stack->top[0] == size;

	}
}
//入栈(具体值)
bool push(Stack *stack, TYPE data,int i) {
	if (full(stack)) return false;
	switch (i) {
	case 0:
		*(stack->arr + ++stack->top[i]) = data;
	case 1:
		*(stack->arr + --stack->top[i]) = data;
	}
	return true;
}

//出栈
bool pop(int i,Stack *stack,int size) {
	if (empty(i,stack,size)) return false;
	switch (i) {
	case 0:
		stack->top[i]--;
	case 1:
		stack->top[i]++;
	}
	return true;

}