栈的学习和应用

首先栈的实现可以借助于线性表，因为栈就是特殊的线性表，只支持一端进出，先进先出，先给出线性表实现代码

#ifndef _MYLINKLIST_H_
#define _MYLINKLIST_H_

typedef void LinkList;
/*
typedef struct _tag_LinkListNode LinkListNode;
struct _tag_LinkListNode
{
	LinkListNode* next;
};
*/

typedef struct _tag_LinkListNode
{
	struct _tag_LinkListNode* next;
}LinkListNode;

LinkList* LinkList_Create();

void LinkList_Destroy(LinkList* list);

void LinkList_Clear(LinkList* list);

int LinkList_Length(LinkList* list);

int LinkList_Insert(LinkList* list, LinkListNode* node, int pos);

LinkListNode* LinkList_Get(LinkList* list, int pos);

LinkListNode* LinkList_Delete(LinkList* list, int pos);

#endif

#include "stdio.h"
#include "stdlib.h"
#include "string.h"
#include "linklist.h"

typedef struct _tag_LinkList
{
	LinkListNode header;
	int length;
}TLinkList;

LinkList* LinkList_Create() //O(1)
{
	TLinkList *ret = (TLinkList *)malloc(sizeof(TLinkList));
	if (ret == NULL)
	{
		return ret;
	}
	ret->header.next = NULL;
	ret->length = 0;
	return ret;
}

void LinkList_Destroy(LinkList* list) //O(1)
{
	if (list != NULL)
	{
		free(list);
	}
	return ;
}

void LinkList_Clear(LinkList* list) //O(1)
{
	TLinkList *tlist = list;
	if (tlist == NULL)
	{
		return;
	}
	tlist->header.next = NULL;
	tlist->length = 0;
	return ;
}

int LinkList_Length(LinkList* list) //O(1)
{
	TLinkList *tlist = list;
	if (tlist == NULL)
	{
		return -1;
	}
	return tlist->length;
}

int LinkList_Insert(LinkList* list, LinkListNode* node, int pos)  //O(n)
{
	LinkListNode *current = NULL;
	int i = 0;
	TLinkList *tlist = list;
	if (list==NULL || node==NULL || pos<0)
	{
		return -1;
	}
	current = (LinkListNode *)tlist;
	for (i=0; (i<pos)&&(current->next!=NULL); i++)
	{
		current = current->next;
	}
	node->next = current->next;
	current->next = node;
	tlist->length++;
	return 0;
}

LinkListNode* LinkList_Get(LinkList* list, int pos)  //O(n)
{
	LinkListNode *current = NULL;
	LinkListNode *ret = NULL;
	int i = 0;
	TLinkList *tlist = list;
	if (list==NULL || pos<0)
	{
		return NULL;
	}
	
	current = (LinkListNode *)tlist;
	for (i=0; i<pos; i++)
	{
		current = current->next;
	}
	ret = current->next;

	return ret;
}

LinkListNode* LinkList_Delete(LinkList* list, int pos)  //O(n)
{
	int i = 0;
	LinkListNode *ret = NULL;
	LinkListNode *current = NULL;
	TLinkList *tlist = list;
	if (list == NULL || pos<0)
	{
		return NULL;
	}
	current = (LinkListNode *)tlist;
	for (i=0; i<pos; i++)
	{
		current = current->next;
	}
	//做了一个缓存 把位置元素缓存下来
	ret = current->next;

	//执行删除操作
	current->next = ret->next;
	tlist->length --;

	return ret;
}

下面是站的实现代码

#ifndef _MY_LINKSTACK_H_
#define _MY_LINKSTACK_H_

typedef void LinkStack;

LinkStack* LinkStack_Create();

void LinkStack_Destroy(LinkStack* stack);

void LinkStack_Clear(LinkStack* stack);

int LinkStack_Push(LinkStack* stack, void* item);

void* LinkStack_Pop(LinkStack* stack);

void* LinkStack_Top(LinkStack* stack);

int LinkStack_Size(LinkStack* stack);

#endif //_MY_LINKSTACK_H_

#include "stdlib.h"
#include "stdio.h"
#include "string.h"
#include "linkstack.h"
#include "linklist.h"

typedef struct _tag_LinkStackNode
{
	LinkListNode node;
	void *item;
}TLinkStackNode;

LinkStack* LinkStack_Create()
{

	return LinkList_Create();
}

void LinkStack_Destroy(LinkStack* stack)
{
	LinkStack_Clear(stack);
	LinkList_Destroy(stack);
	return ;
}


void LinkStack_Clear(LinkStack* stack)
{
	while (LinkStack_Size(stack) > 0)
	{
		LinkStack_Pop(stack);
	}
	return ;
}

int LinkStack_Push(LinkStack* stack, void* item)
{
	int ret = 0;
	TLinkStackNode *node = (TLinkStackNode *)malloc(sizeof(TLinkStackNode));
	if (node == NULL || item == NULL)
	{
		return -1;
	}
	node->item = item;
	ret = LinkList_Insert(stack, (LinkListNode*)node, 0);
	if (ret != 0)
	{
		free(node);
	}
	return ret;
}


void* LinkStack_Pop(LinkStack* stack)
{
	void *ret = NULL;
	TLinkStackNode *node = NULL;
	if (stack == NULL)
	{
		return NULL;
	}
	node = (TLinkStackNode *)LinkList_Delete(stack, 0);
	if (node == NULL)
	{
		return NULL;
	}
	ret = node->item;

	//注意 释放内存不要忘记
	if (node != NULL) 
	{
		free(node);
	}

	return ret;
}

void* LinkStack_Top(LinkStack* stack)
{
	void *ret = NULL;
	TLinkStackNode *node = NULL;
	if (stack == NULL)
	{
		return NULL;
	}
	node = (TLinkStackNode *)LinkList_Get(stack, 0);
	if (node == NULL)
	{
		return NULL;
	}
	ret = node->item;
	return ret;
}

int LinkStack_Size(LinkStack* stack)
{
	return LinkList_Length(stack);
}

下面是栈的一个应用

语法检测，实现括号的匹配，当然栈的经典应用还有别的，比如中缀转后缀表达式，遍历二叉树

#include "stdio.h"
#include "stdlib.h"
#include "linkstack.h"

int isLeft(char c)
{
	int ret = 0;

	switch(c)
	{
	case '<':
	case '(':
	case '[':
	case '{':
	case '\'':
	case '\"':
		ret = 1;
		break;
	default:
		ret = 0;
		break;
	}

	return ret;
}

int isRight(char c)
{
	int ret = 0;

	switch(c)
	{
	case '>':
	case ')':
	case ']':
	case '}':
	case '\'':
	case '\"':
		ret = 1;
		break;
	default:
		ret = 0;
		break;
	}

	return ret;
}

int match(char left, char right)
{
	int ret = 0;

	switch(left)
	{
	case '<':
		ret = (right == '>');
		break;
	case '(':
		ret = (right == ')');
		break;
	case '[':
		ret = (right == ']');
		break;
	case '{':
		ret = (right == '}');
		break;
	case '\'':
		ret = (right == '\'');
		break;
	case '\"':
		ret = (right == '\"');
		break;
	default:
		ret = 0;
		break;
	}

	return ret;
}

int scanner(const char* code)
{
	LinkStack* stack = LinkStack_Create();
	int ret = 0;
	int i = 0;

	while( code[i] != '\0' )
	{
		if( isLeft(code[i]) )
		{
			LinkStack_Push(stack, (void*)(code + i));
		}

		if( isRight(code[i]) )
		{
			char* c = (char*)LinkStack_Pop(stack);

			if( (c == NULL) || !match(*c, code[i]) )
			{
				printf("%c does not match!\n", code[i]);
				ret = 0;
				break;
			}
		}

		i++;
	}

	if( (LinkStack_Size(stack) == 0) && (code[i] == '\0') )
	{
		printf("Succeed!\n");
		ret = 1;
	}
	else
	{
		printf("Invalid code!\n");
		ret = 0;
	}

	LinkStack_Destroy(stack);

	return ret;
}

void main()
{
	const char* code = "#include <stdio.h> int main() { int a[4][4]; int (*p)[4]; p = a[0]; return 0;";

	scanner(code);
	system("pause");
	return ;
}