数据结构-栈

栈是特殊链表， 所有操作只能在表的头部操作；

link_list.h

#ifndef _LINKLIST_H_
#define _LINKLIST_H_


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


typedef void link_list;
typedef struct _tag_link_list_node link_list_node;
struct _tag_link_list_node
{
    link_list_node* next;
	int value;//为了调试方便加进去
};

typedef struct _tag_link_list_head link_list_head;
struct _tag_link_list_head
{
    link_list_node header;
    int length;
};

link_list_head* link_list_create(void);

int link_list_insert(link_list_head* list, link_list_node* node, int pos);

link_list_node* link_list_delete(link_list_head* list, int pos);

link_list_node* link_list_get(link_list_head* list, int pos);

void link_list_destory(link_list_head* list);

void link_list_clear(link_list_head* list);

int link_list_length(link_list_head* list);

void link_list_printf(link_list_head* list);

#endif

link_list.c

#include "link_list.h"

link_list_head* link_list_create(void)
{
    link_list_head* ret = (link_list_head*)malloc(sizeof(link_list_head));
    
    if( ret != NULL )
    {
        ret->length = 0;
        ret->header.next = NULL;
    }
    
    return ret;
}

int link_list_insert(link_list_head* list, link_list_node* node, int pos)
{
	int i;
	link_list_node* current = &(list->header);
	
	for (i=0; i<pos&&(current->next!=NULL); i++)
	{
		current = current->next;
	}
	
	node->next = current->next;
	current->next = node;
	
	list->length++;
	
	return 0;
}


link_list_node* link_list_delete(link_list_head* list, int pos)
{
	int i;
	link_list_node *current = &(list->header);
	link_list_node *ret;
	
	if (list->length ==0 )
	{
		return NULL;
	}
	for (i=0; i<pos&&(current->next!=NULL); i++)
	{
		current = current->next;
	}
	
	ret = current->next;
	current->next = ret->next;
	
	list->length--;
	return ret;
}

link_list_node* link_list_get(link_list_head* list, int pos)
{
	int i;
	link_list_node* current = &(list->header);
	
	if (list->length <= pos)
	{
		return NULL;
	}
	for (i=0; i<pos; i++)
	{
		if (current->next == NULL)
		{
			return NULL;
		}
		current = current->next;
	}
	
	return current->next;
}

void link_list_destory(link_list_head* list)
{
	free(list);
}


void link_list_clear(link_list_head* list)
{
	list->header.next = NULL;
	list->length = 0;
}

int link_list_length(link_list_head* list)
{
	return list->length;
}

void link_list_printf(link_list_head* list)
{
	int i;
	link_list_node* current = &(list->header);
	
	printf("link_list_printf-len:%d-",list->length);
	for (i=0; i<list->length; i++)
	{
		current = current->next;
		printf("[%d-%d]-",i,current->value);
	}
	printf("\n");
}

list_stack.h

#ifndef __LINK_STACK_H__
#define __LINK_STACK_H__

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

typedef void link_stack;

link_stack* link_stack_create(void);

void link_stack_destroy(link_stack* stack);

void link_stack_clear(link_stack* stack);

int link_stack_push(link_stack* stack, void* item);

void* link_stack_pop(link_stack* stack);

void* link_stack_top(link_stack* stack);

int link_stack_size(link_stack* stack);

#endif

link_stack.c

#include "link_stack.h"
#include "link_list.h"



typedef struct _tag_link_stack_node
{
    link_list_node header;
    void* item;
} t_link_stack_node;



link_stack* link_stack_create(void)
{
	return link_list_create();
}

void link_stack_destroy(link_stack* stack)
{
	link_list_destory(stack);
}


int link_stack_size(link_stack* stack)
{
	return link_list_length(stack);
}

int link_stack_push(link_stack* stack, void* item)
{
    t_link_stack_node* node = (t_link_stack_node*)malloc(sizeof(t_link_stack_node));
    int ret = (node != NULL) && (item != NULL);
	if (ret)
	{
		node->item = item;
		link_list_insert(stack,(link_list_node*)node,0);
	}
	return ret;
}

void* link_stack_pop(link_stack* stack)
{
	t_link_stack_node *ret=NULL;
	void *temp = NULL;
	ret = (t_link_stack_node*)link_list_delete(stack,0);
	
	if( ret != NULL )
	{
		temp = ret->item;
		free(ret);
	}
	return temp;
}

void* link_stack_top(link_stack* stack)
{
	t_link_stack_node *ret=NULL;
	
	ret = (t_link_stack_node*)link_list_get(stack,0);
	
	if( ret != NULL )
	{
		ret = ret->item;
	}
	return ret;
}

测试代码

#include "stdio.h"
#include "stdint.h"
//#include "link_list.h"
#include "link_stack.h"

int main(void)
{
	#define BUF_SIZE 10
	int i;
	int buf[BUF_SIZE];
	int *int32_tmp;
	link_stack *head;
	
	printf("hello\n");
	
	head = link_stack_create();
	
	for (i=0; i<BUF_SIZE; i++)
	{
		buf[i] = i + 1;
		link_stack_push(head,&buf[i]);
		int32_tmp = link_stack_top(head);
		printf("[%d-0x%x]",int32_tmp[0],&buf[i]);
	}
	printf("\n");
	
	
	
	printf("size:%d\n",link_stack_size(head));
	
	
	while(link_stack_size(head)>0)
	{
		int32_tmp = link_stack_pop(head);
		printf("%d-",int32_tmp[0]);
	}
	printf("\n");
	
	printf("size:%d\n",link_stack_size(head));
	
	
	link_stack_destroy(head);
	
}