链栈

1、链栈

1.2、算法

• 1、初始化栈
  void init(PSTACK);//初始化

• 2、压栈
  void push(PSTACK,int);

• 3、遍历栈
  void traverse(PSTACK);

• 4、出栈
  bool pop(PSTACK pS,int pVal);*

• 清空
  void clear();

1.3实现

1.3.1定义数据类型

1.3.1.0功能代码

#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
typedef struct Node
{
	int data;
	struct Node* pNext;
}*PNODE,NODE;//这两个顺序无要求NODE等价于struct Node   PNODE 等价于struct Node*
typedef struct Stack
{
	PNODE pTop;
	PNODE pBottom;
}STACK,*PSTACK;//这两个顺序无要求NODE等价于struct Stack   PNODE 等价于struct Stack*
int main()
{
	STACK S;//这句代码执行后在内存空间有一个变量S，并开辟空间，空间里有两个区pTop和pBottom只不过里面没有存储东西
	
	return 0;
}

1.3.1.1内存分析

1.3.2初始化

1.3.2.0功能代码

void init(PSTACK pS)//初始化
{
    pS->pTop = (PNODE)malloc(sizeof(NODE));//注意 pS->pTop = (PSTACK)malloc(sizeof(STACK))
	if(NULL == pS->pTop)
	{
		printf("分配失败！");
		exit(-1);	
	}
	else
	{
		pS->pBottom = pS->pTop;
		pS->pTop->pNext = NULL;//或者pS->pBotton->pNext = NULL
	}
}

1.3.2.1内存分析

1.3.3压栈

1.3.3.0功能代码

void push(PSTACK pS,int val)//压栈
{
	PNODE pNew = (PNODE)malloc(sizeof(NODE));//建立新节点
	pNew->data = val;//为新节点赋值
	pNew->pNext = pS->pTop;//不能写pNew->pNext = pS->pBottom;
	pS->pTop = pNew;//栈顶指针指向新节点

}

1.3.3.1内存分析

1.3.4遍历

1.3.4.0功能代码

void traverse(PSTACK pS)//遍历
{
	PNODE p = pS->pTop;//声明一个变量永远指向栈顶
	while(p != pS->pBottom)
	{
		printf("%d\n",p->data);
		p = p->pNext;
	}
}

1.3.4.1内存分析

1.3.5出栈

1.3.5.0功能代码

bool pop(PSTACK pS,int* pVal)//出栈
{
	if(empty(pS))
	{
		return false;
	}
	else
	{
		PNODE p = pS->pTop;
		*pVal = p->data;
		pS->pTop = p->pNext;
		free(p);
		p = NULL;
	}
}

1.3.5.1内存分析

1.3.6清空

1.3.6.0功能代码

void clear(PSTACK pS)
{
	if(empty(pS))
	{
		return ;
	}
	else
	{
		/*
		PNODE p = pS->pTop;
		PNODE q = p->pNext;
		while(p != pS->pBottom)
		{
			free(p);
			//p = NULL;//因为下面还有值所以先不用写最后写就行
			p = q;
			q = q->pNext
		}
		free(p)
		*/
		
		PNODE p = pS->pTop;
		PNODE q = NULL;
		while(p != pS->pBottom)//很有韵味，判断出是否为空
		{
			q = p->pNext;
			free(p);
			p = q; 
		}
		p = NULL;
		pS->pTop = pS->pBottom;
	}
}

1.3.6.1内存分析

完整代码

#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
typedef struct Node
{
	int data;
	struct Node* pNext;
}*PNODE,NODE;
typedef struct Stack
{
	PNODE pTop;
	PNODE pBottom;
}STACK,*PSTACK;
void init(PSTACK);//初始化
void push(PSTACK,int);//压栈
void traverse(PSTACK);//遍历
bool pop(PSTACK pS,int* pVal);//出栈
void clear();


int main()
{
	STACK S;//这句代码执行后在内存空间有一个变量S，并开辟空间，空间里有两个区pTop和pBottom只不过里面没有存储东西
	init(&S);
	push(&S,1);
	push(&S,2);
	push(&S,3);
	push(&S,4);
	push(&S,5);
	push(&S,6);
	traverse(&S);
	return 0;
}
void init(PSTACK pS)//初始化
{
    pS->pTop = (PNODE)malloc(sizeof(NODE));//注意 pS->pTop = (PSTACK)malloc(sizeof(STACK))
	if(NULL == pS->pTop)
	{
		printf("分配失败！");
		exit(-1);	
	}
	else
	{
		pS->pBottom = pS->pTop;
		pS->pTop->pNext = NULL;//或者pS->pBotton->pNext = NULL
	}
}

void push(PSTACK pS,int val)//压栈
{
	PNODE pNew = (PNODE)malloc(sizeof(NODE));//建立新节点
	pNew->data = val;//为新节点赋值
	pNew->pNext = pS->pTop;//不能写pNew->pNext = pS->pBottom;
	pS->pTop = pNew;//栈顶指针指向新节点

}
void traverse(PSTACK pS)//遍历
{
	PNODE p = pS->pTop;//声明一个变量永远指向栈顶
	while(p != pS->pBottom)
	{
		printf("%d\n",p->data);
		p = p->pNext;
	}
}

//把pS所指向的栈进行出栈一次，并把出栈的元素存入pVal形参所指向的变量中，如果出栈成功返回true失败返回false
bool empty(PSTACK pS)
{
	if(pS->pBottom == pS->pTop)
		return true;
	else
		return false;
	

}

bool pop(PSTACK pS,int* pVal)//出栈
{
	if(empty(pS))
	{
		return false;
	}
	else
	{
		PNODE p = pS->pTop;
		*pVal = p->data;
		pS->pTop = p->pNext;
		free(p);
		p = NULL;
	}
}
void clear(PSTACK pS)
{
	if(empty(pS))
	{
		return ;
	}
	else
	{
		/*
		PNODE p = pS->pTop;
		PNODE q = p->pNext;
		while(p != pS->pBottom)
		{
			free(p);
			//p = NULL;//因为下面还有值所以先不用写最后写就行
			p = q;
			q = q->pNext
		}
		free(p)
		*/
		
		PNODE p = pS->pTop;
		PNODE q = NULL;
		while(p != pS->pBottom)//很有韵味，判断出是否为空
		{
			q = p->pNext;
			free(p);
			p = q; 
		}
		p = NULL;
		pS->pTop = pS->pBottom;
	}
}

/****************************************************
因为我们的栈是STACK s 是静态的不能手动销毁。


*****************************************************
*/

• 去年暑假练的代码。算法实现思想有时间在补充