数据结构-栈1（学习笔记）

定义：

1.栈是一种特殊的线性表

2.栈仅能在线性表的一端进行操作

2.1栈顶(Top)：允许操作的一端

2.2栈底(Bottom)：不允许操作的一端

性质：

后进先出

常用操作：

1.创建栈

2.销毁栈

3.清空栈

4.进栈

5.出栈

6.获取栈顶元素

7.获取栈的大小

两种实现方式：

1.顺序存储实现

2.链式存储实现

一.链式存储实现方式：

1.链式线性表的实现之前有贴过代码现在还是贴出来看下

头文件：LinkList.h

#ifndef _LINKLIST_H_
#define _LINKLIST_H_

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

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

c文件LinkList.c

#include <stdio.h>
#include <malloc.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 )
{
ret->length = 0;
ret->header.next = NULL;
}

return ret;
}

void LinkList_Destroy(LinkList* list) // O(1)
{
free(list);
}

void LinkList_Clear(LinkList* list) // O(1)
{
TLinkList* sList = (TLinkList*)list;

if( sList != NULL )
{
sList->length = 0;
sList->header.next = NULL;
}
}

int LinkList_Length(LinkList* list) // O(1)
{
TLinkList* sList = (TLinkList*)list;
int ret = -1;

if( sList != NULL )
{
ret = sList->length;
}

return ret;
}

int LinkList_Insert(LinkList* list, LinkListNode* node, int pos) // O(n)
{
TLinkList* sList = (TLinkList*)list;
int ret = (sList != NULL) && (pos >= 0) && (node != NULL);
int i = 0;

if( ret )
{
LinkListNode* current = (LinkListNode*)sList;

for(i=0; (i<pos) && (current->next != NULL); i++)
{
current = current->next;
}

node->next = current->next;
current->next = node;

sList->length++;
}

return ret;
}

LinkListNode* LinkList_Get(LinkList* list, int pos) // O(n)
{
TLinkList* sList = (TLinkList*)list;
LinkListNode* ret = NULL;
int i = 0;

if( (sList != NULL) && (0 <= pos) && (pos < sList->length) )
{
LinkListNode* current = (LinkListNode*)sList;

for(i=0; i<pos; i++)
{
current = current->next;
}

ret = current->next;
}

return ret;
}

LinkListNode* LinkList_Delete(LinkList* list, int pos) // O(n)
{
TLinkList* sList = (TLinkList*)list;
LinkListNode* ret = NULL;
int i = 0;

if( (sList != NULL) && (0 <= pos) && (pos < sList->length) )
{
LinkListNode* current = (LinkListNode*)sList;

for(i=0; i<pos; i++)
{
current = current->next;
}

ret = current->next;
current->next = ret->next;

sList->length--;
}

return ret;
}

栈头文件LinkStack.h

#ifndef _LINKSTACK_H_

#define _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

c文件LinkStack.c

#include <stdio.h>

#include <malloc.h>

#include "LinkStack.h"

#include "LinkList.h"

typedef struct _tag_LinkStackNode

{

LinkListNode header;

void* item;

} TLinkStackNode;

LinkStack* LinkStack_Create()

{

return LinkList_Create();

}

void LinkStack_Destroy(LinkStack* stack)

{

LinkStack_Clear(stack);

LinkList_Destroy(stack);

}

void LinkStack_Clear(LinkStack* stack)

{

while( LinkStack_Size(stack) > 0 )

{

LinkStack_Pop(stack);

}

}

int LinkStack_Push(LinkStack* stack, void* item)

{

TLinkStackNode* node = (TLinkStackNode*)malloc(sizeof(TLinkStackNode));

int ret = (node != NULL) && (item != NULL);

if( ret )

{

node->item = item;

ret = LinkList_Insert(stack, (LinkListNode*)node, 0);

}

if( !ret )

{

free(node);

}

return ret;

}

void* LinkStack_Pop(LinkStack* stack)

{

TLinkStackNode* node = (TLinkStackNode*)LinkList_Delete(stack, 0);

void* ret = NULL;

if( node != NULL )

{

ret = node->item;

free(node);

}

return ret;

}

void* LinkStack_Top(LinkStack* stack)

{

TLinkStackNode* node = (TLinkStackNode*)LinkList_Get(stack, 0);

void* ret = NULL;

if( node != NULL )

{

ret = node->item;

}

return ret;

}

int LinkStack_Size(LinkStack* stack)

{

return LinkList_Length(stack);

}

测试文件

#include <stdio.h>
#include <stdlib.h>
#include "LinkStack.h"

/* run this program using the console pauser or add your own getch, system("pause") or input loop */

int main(int argc, char *argv[]) {
LinkStack* stack = LinkStack_Create();
int a[10];
int i = 0;

for(i=0; i<10; i++)
{
a[i] = i;

LinkStack_Push(stack, a + i);
}

printf("Top: %d\n", *(int*)LinkStack_Top(stack));
printf("Length: %d\n", LinkStack_Size(stack));

while( LinkStack_Size(stack) > 0 )
{
printf("Pop: %d\n", *(int*)LinkStack_Pop(stack));
}

LinkStack_Destroy(stack);
return 0;
}

运行结果：



顺序存储实现的方式下一篇在给出吧