链表模拟堆栈

#include "stdafx.h"
#include <stdio.h>
#include <stdlib.h>
typedef struct stack
{
 int data;
 struct stack *next;
}STACK;
STACK *head,*pr;
int nodeNum = 0;
STACK *Createnote(int num);
STACK *PushStack(int num);
int PopStack(void);
int main()
{
 int pushNum[5] = {111,222,333,444,555},popNum[5],i;
 for(i = 0;i < 5;i++)
 {
  PushStack(pushNum[i]);
  printf_s("Push %dth Data: %d\n",i+1,pushNum[i]);
 }
 for(i = 0;i < 5;i++)
 {
  popNum[i] = PopStack();
  printf_s("Pop %dth Data: %d\n",5-i,popNum[i]);
 }
 system("pause");
 return 0;
}
STACK *CreateNode(int num)
{
 STACK *p;
 p = (STACK *)malloc(sizeof(STACK));
 if(p == NULL)
 {
  printf_s("No enough memory!\n");
  exit(0);
 }
 p ->next = NULL;
 p ->data = num;
 return p;
}
STACK *PushStack(int num)
{
 if(nodeNum == 0)
 {
  head = CreateNode(num);
        pr = head;
  nodeNum++;
 }
 else
 {
  pr ->next = CreateNode(num);
  pr = pr ->next;
  nodeNum++;
 }
 return pr;
}
int PopStack(void)
{
 STACK *p = head;
 int result;
 for(;;)
 {
  if(p ->next ==NULL)
  {
   break;
  }
  else
  {
   pr = p;
   p = p->next;
   nodeNum--;
  }
 }
 pr ->next = NULL;
 result = p ->data;
 free(p);
 return result;
}

时间: 2024-11-05 22:54:51

链表模拟堆栈的相关文章

算法学习(二) 全排列问题的非递归算法——模拟堆栈

前一段时间总结了全排列问题的几种递归解法,今天再总结一下如何通过对系统栈行为的模拟来非递归的实现全排列问题. 我们用一个数组stack[]来表示一个栈,用一个top指针来表示栈顶,用一个flags[]数组来标示每一个数字的可用性:用i来表示当前的状态. 初始状态top=0:i=-1:flags数组全为1: i递增,如果i没有越界并且flags[i]==1,那么就将i写入栈中,栈顶往前移动一位:最后把flags[i]赋值为0,i回溯到初始状态-1: 当栈顶越界,就将整个栈的信息打印出来,然后top

数组模拟堆栈的存储方式代码实践

堆栈的模式是先进后出,取出后堆栈中就没有取出的元素了,所以在模拟时候要注意这些问题. 1 import java.util.Arrays; 2 3 /* 4 5 需求:编写一个类使用数组模拟堆栈的存储方式. 6 7 堆栈存储特点: 先进后出,后进先出. 8 9 注意: 不再使用的对象,应该不要让变量指向该对象,要让该对象尽快的被垃圾回收期回收. 10 11 12 */ 13 class StackList{ 14 15 Object[] elements; 16 17 int index = 0

《Java数据结构与算法》笔记-CH5-链表-4用链表实现堆栈

1 //用链表实现堆栈 2 /** 3 * 节点类 4 */ 5 class LinkS { 6 private long data; 7 public LinkS next; 8 9 public LinkS(long d) { 10 this.data = d; 11 } 12 13 public String toString() { 14 return String.valueOf(data); 15 } 16 } 17 18 /** 19 * 链表类 20 */ 21 class Li

单向链表模拟

为什么出这个真理文档呢?方面以后我们的视频不断跟进,高级部分关于JDK源码的学习,所以有些基本的思维要叙述一下,包括AQS,常用数据结构,线程等等.这一个帖子主要是我以前写的模拟常用数据结构的代码,可能有些bug 并且不规范,但是重在学习思维.并没有JDK源码部分考虑多,只是简单的写了一点.分享给大家,关于线程同步器的学习我觉得先会用  然后看源码,接着模拟.好开始数据结构了. 注意:在java数据结构中模拟的话 通过数组和引用可以模拟几乎所有的结构. 链表结构的模拟 1.单向链表 a.基础结构

堆栈二链表实现堆栈

用链表来实现堆栈的优点是随时可以动态改变链表的长度,能够有效利用内存资源,缺点就是设计的算法比较复杂 class Node: #堆栈链结节点的声明 def __init__(self): self.data=0 #堆栈数据的声明 self.next=None #堆栈中用来指向下一个节点 top=None 判断链表是否为空 def isEmpty(): global top if(top==None): return 1 else: return 0 将指定的数据压入堆栈 #将指定的数据压入堆栈

Python模拟 堆栈,队列,链表

1. 堆栈 class my_stack(object): def __init__(self, value): self.value = value # 前驱 self.before = None # 后继 self.behind = None def __str__(self): return str(self.value) def top(stack): if isinstance(stack, my_stack): # 判断对象是否合法 if stack.behind is not No

数组、链表、堆栈和队列

链表,队列,堆栈的区别1.栈是个有底的口袋,像袜子.队列是没底的口袋,像通心粉.所以:栈的特点是先进后出,队列的特点是先进先出.2.主要区别是适用的地方不一样,     链表实际上可以认为是一种数据的物理组织形式,是用指针或对象的引用组织起的一种数据的存储方式.     队列和堆栈是一个更高层次的概念,其底层可以是用链表也可以是用数组来实现.     队列和堆栈的主要区别是进出的顺序不一样,     队列是先进先出,堆栈是后进先出.   3.cooled(经典中--经过非典中)   说的很详细了

python列表模拟堆栈和队列

对列特点:先进先出.后进后出 用列表insert.pop模拟进队出队: 1 >>> l = [] 2 >>> l.insert(0,'p1') # 索引0插入到列表最前面 3 >>> l.insert(0,'p2') 4 >>> l.insert(0,'p3') 5 >>> l 6 ['p3', 'p2', 'p1'] 7 >>> l.pop() # pop默认弹出最后一个元素 8 'p1' 9 &

C数组模拟堆栈

#include <stdio.h> #include <string.h> #include <stdlib.h> #define MAXSIZE 8 typedef int dataType; typedef struct Stack {     dataType date[MAXSIZE];     int top; }Stack; void initStack(Stack *s)//初始化堆栈函数 {     s->top=-1;  //初始化top指向堆