精华内容
下载资源
问答
  • 堆栈数据结构的c++实现,购物的实例实现。 堆栈的数据结构包括:所需变量和指针 堆栈的操作:空、满、入、出
  • 堆栈是一种数据结构的实现形式,是广泛用来存取数据的一种容器
  • 视觉堆栈 堆栈数据结构的图形表示 关于其用法的进一步说明:[点击这里]( )
  • 内存中的堆栈数据结构堆栈区别

    千次阅读 2019-06-26 16:43:19
    内存中的堆栈数据结构堆栈不是一个概念,可以说内存中的堆栈是真实存在的物理区,数据结构中的堆栈是抽象的数据存储结构。 1.内存中的堆栈 内存空间在逻辑上分为三部分:代码区、静态数据区和动态数据,动态数据区...


    内存中的堆栈和数据结构堆栈不是一个概念,可以说内存中的堆栈是真实存在的物理区,数据结构中的堆栈是抽象的数据存储结构。

    1.内存中的堆栈

    内存空间在逻辑上分为三部分:代码区静态数据区动态数据,动态数据区又分为栈区堆区

    代码区

    存储方法体的二进制代码。高级调度(作业调度)、中级调度(内存调度)、低级调度(进程调度)控制代码区执行代码的切换。

    静态数据区

    存储全局变量、静态变量、常量,常量包括final修饰的常量和String常量。系统自动分配和回收。

    栈区

    存储运行方法的形参、局部变量、返回值。由系统自动分配和回收。
    例如:int method(int a) {int b;} 栈中存储参数a、局部变量b、返回值temp。

    int main()
    {
    	int b;				//栈
    	char s[] = "abc"; 	//栈
    	char *p2;			//栈
    }
    

    其中函数中定义的局部变量按照先后定义的顺序依次压入栈中,也就是说相邻变量的地址之间不会存在其它变量。栈的内存地址生长方向与堆相反,由高到底,所以后定义的变量地址低于先定义的变量,比如上面代码中变量s的地址小于变量b的地址,p2地址小于s的地址。栈中存储的数据的生命周期随着函数的执行完成而结束。

    堆区

    new一个对象的引用地址存储在栈区,指向该对象存储在堆区中的真实数据。由程序员分配和回收(Java中由JVM虚拟机的垃圾回收机制自动回收)。
    例如:Class Student{int num; int age;} main方法中Student stu = new Student();分配堆区空间中存储的该对象的num、age,变量stu存储在栈中,里面的值是对应堆区空间的引用或地址

    堆的内存地址生长方向与栈相反,由低到高,但需要注意的是,后申请的内存空间并不一定在先申请的内存空间的后面,即p2指向的地址并不一定大于p1所指向的内存地址,原因是先申请的内存空间一旦被释放,后申请的内存空间则会利用先前被释放的内存,从而导致先后分配的内存空间在地址上不存在先后关系。堆中存储的数据的若未释放,则其生命周期等同于程序的生命周期。

    关于堆上内存空间的分配过程,首先应该知道操作系统有一个记录空闲内存地址的链表,当系统收到程序的申请时,会遍历该链表,寻找第一个空间大于所申请空间的堆节点,然后将该节点从空闲节点链表中删除,并将该节点的空间分配给程序。

    2.数据结构中的堆栈

    栈:是一种连续存储的数据结构,特点是存储的数据先进后出。
    堆:是一棵完全二叉树结构,特点是父节点的值大于(小于)两个子节点的值(分别称为大顶堆和小顶堆)。它常用于管理算法执行过程中的信息,应用场景包括堆排序,优先队列等。

    参考博客: https://blog.csdn.net/K346K346/article/details/80849966

    展开全文
  • DNA计算机中的堆栈数据结构,丁永生,李汪根,本文提出了DNA计算机中堆栈数据结构的一种设计方法,给出了具体的DNA编码及实现。首先给出了堆栈存储结构、堆栈元素等DNA编码的形式
  • 数据结构-堆栈

    2017-04-09 15:34:59
    数据结构讲义之堆栈
  • 首先采用Alpha Matting算法获取物体的边界信息,按照物体的边界信息在(x,y)空间中对聚焦堆栈进行精确划分,在深度方向上对聚焦堆栈数据进行筛选,获得聚焦堆栈单体数据子集。然后根据聚焦测度对单体数据子集进行深度...
  • 数据结构之堆栈

    千次阅读 2019-03-17 11:44:35
    堆栈 @[.DataStructure] ... 堆栈应用:求表达式的值数据结构动图资源 1. 抽象数据结构 操作集合 解释 Stack CreateStack(int MaxSize) 初始化一个堆栈 bool IsFull(Stack S) 判断堆栈S是...

    堆栈

    @[.DataStructure]

    1. 抽象数据结构

    操作集合解释
    Stack CreateStack(int MaxSize)初始化一个堆栈
    bool IsFull(Stack S)判断堆栈S是否已满 已满返回 f a l s e false false
    bool Push(Stack S, ElementType X)将元素X压入堆栈。若堆栈已满,返回 f a l s e false false,否则将数据元素X插入到堆栈S栈顶处,并返回 t r u e true true
    bool IsEmpty(Stack S)判断堆栈S是否为空,若是返回 t r u e true true,否则返回 f a l s e false false
    ElementType Pop(Stack S)删除并返回栈顶元素。若堆栈为空,返回错误信息;否则将栈顶元素删除并返回

    2. 出堆栈序列问题

    如果将ABCD四个自符按顺序压入堆栈,是不是ABCD的所有排列都可能是出堆栈的序列?可以产生CABD这样的序列吗?

    3. 动态数组堆栈实现

    3.1 动态数组实现

    以下这句话太强了

    方式一:

    	#define MaxSize 100
    	int * Data;
    	Data = (int *)malloc(MaxSize * sizeof(int)); //暂时未彻底理解这句话。
    

    方式二:

    int Data[100];
    

    相比于方式二,方式一的优势在于可以根据实际问题的需要在程序运行的时候动态创建 长度不一样的数组。这就是C语言的核心和灵魂所在 而方式二,一旦程序编译之后Data的长度就不能改变了。


    3.2 全部代码

    #define ElementType int
    #define MAXSIZE 100
    
    #include<iostream>
    #include<cstdio>
    using namespace std;
    
    typedef int Position;
    typedef struct SNode * PtrtoSNode;
    struct SNode
    {
    	ElementType * Data;
    	Position Top;
    	int MaxSize;
    };
    
    typedef PtrtoSNode Stack;
    
    
    Stack CreatStack(int MaxSize)
    {
    	Stack S = (Stack)malloc(sizeof(struct SNode));
    	S->Data = (ElementType *)malloc(MaxSize * sizeof(ElementType)); // 说实话这句话不懂
    	S->Top = -1;
    	S->MaxSize = MaxSize;
    
    	return S;
    }
    
    
    
    bool IsFull(Stack S)
    {
    	return(S->Top == S->MaxSize - 1);
    }
    
    bool Push(Stack S, ElementType X)
    {
    	if (IsFull(S)) {
    		cout << "The Stack is full" << endl;
    		return false;
    	}
    	else
    	{
    		S->Data[++(S->Top)] = X;
    		return true;
    	}
    
    }
    
    
    bool IsEmpty(Stack S)
    {
    	return(S->Top == -1);
    }
    
    
    #define Error -100
    
    ElementType Pop(Stack S)
    {
    	if (IsEmpty(S))
    	{
    		cout << "the Stack is Empty" << endl;
    		return Error;
    	}
    	else
    	{
    		return(S->Data[(S->Top)--]);
    	}
    
    }
    
    
    
    int main()
    {
    	Stack S = CreatStack(100);
    	for (size_t i = 0; i < 200; i++)
    	{
    		Push(S, i);
    	}
    	return 0;
    }
    
    
    

    4. 双堆栈实现

    #define ElementType int
    #define MAXSIZE 100
    
    #include<iostream>
    #include<cstdio>
    using namespace std;
    
    typedef int Position;
    typedef struct SNode * PtrtoSNode;
    struct SNode
    {
    	ElementType * Data;
    	Position Top1;
    	Position Top2;
    
    	int MaxSize;
    };
    
    typedef PtrtoSNode Stack;
    
    
    Stack CreatStack(int MaxSize)
    {
    	Stack S = (Stack)malloc(sizeof(struct SNode));
    	S->Data = (ElementType *)malloc(MaxSize * sizeof(ElementType)); // 说实话这句话不懂
    	S->Top1 = -1;
    	S->Top2 = MaxSize;
    
    	S->MaxSize = MaxSize;
    
    	return S;
    }
    
    
    
    
    bool Push(Stack S, ElementType X, int Tag)
    {
    	if (S->Top2 - S->Top1 == 1)
    	{
    		cout << "The Stack is full" << endl;
    		return false;
    	}
    	else
    	{
    		if (Tag == 1)
    		{
    			S->Data[++(S->Top1)] = X;
    		}
    		else
    		{
    			S->Data[--(S->Top2)] = X;
    		}
    		return true;
    	}
    
    }
    
    
    
    #define Error -100
    
    ElementType Pop(Stack S, int Tag)
    {
    	if (Tag == 1) {
    		if (S->Top1 == -1)
    		{
    			cout << "The stack1 is Empty";
    			return Error;
    		}
    		else
    		{
    			return S->Data[(S->Top1)--];
    		}
    	}
    	else
    	{
    		if (S->Top2 = S->MaxSize)
    		{
    			cout << "The stack2 is empty";
    			return Error;
    		}
    		else
    		{
    			return S->Data[(S->Top2)++];
    		}
    	}
    }
    
    
    
    int main()
    {
    	Stack S = CreatStack(100);
    	for (size_t i = 0; i < 200; i++)
    	{
    		Push(S, i, 1);
    		Push(S, i, 2);
    
    	}
    	return 0;
    }
    

    5. 链表堆栈实现

    #define ElementType int
    #define MAXSIZE 100
    
    #include<iostream>
    #include<cstdio>
    using namespace std;
    
    typedef struct SNode * PtrtoSNode;
    struct SNode
    {
    	ElementType Data;
    	PtrtoSNode Next;
    };
    
    typedef PtrtoSNode Stack;
    
    
    bool IsEmpty(Stack S)
    {
    	return(S->Next == NULL);
    }
    
    
    
    
    
    
    Stack CreatStack()
    {
    	Stack S = (Stack)malloc(sizeof(struct SNode));
    	S->Next = NULL;
    
    	return S;
    }
    
    
    
    
    bool Push(Stack S, ElementType X)
    {
    
    	PtrtoSNode TmpCell;
    	TmpCell = (PtrtoSNode)malloc(sizeof(struct SNode));
    	TmpCell->Data = X;
    	TmpCell->Next = S->Next;
    	S->Next = TmpCell;
    	return true;
    
    }
    
    
    
    #define Error -100
    
    ElementType Pop(Stack S)
    {
    	//删除并返回栈顶元素
    	PtrtoSNode FirstCell;
    	ElementType TopElem;
    
    	if (IsEmpty(S))
    	{
    		cout << "the stack is empty" << endl;
    		return Error;
    	}
    	else
    	{
    		FirstCell = S->Next;
    		TopElem = FirstCell->Data;
    		S->Next = FirstCell->Next;
    		free(FirstCell);
    		return TopElem;
    
    	}
    
    }
    
    
    
    int main()
    {
    	Stack S = CreatStack();
    	for (size_t i = 0; i < 200; i++)
    	{
    		Push(S, i);
    		Push(S, i);
    
    	}
    	return 0;
    }
    

    数据结构动图资源

    https://www.cs.usfca.edu/~galles/visualization/Algorithms.html

    展开全文
  • Javascript 中的堆栈数据结构实现。 ###安装 npm install stack-js ###初始化堆栈: var myStack = new Stackjs(); ###新增项目 : myStack.push(data); ###除去项目 : myStack.pop(); ###Peek ...
  • 数据结构堆栈

    2012-12-28 18:54:14
    这是一个关于堆栈的完整代码, SeqStack<String> stack = new SeqStack(expstr.length()); //创建运算符栈,顺序
  • Python 数据结构_堆栈

    千次阅读 2016-08-30 16:41:02
    堆栈堆栈堆栈是一个后进先出(LIFO)的数据结构. 堆栈这个数据结构可以用于处理大部分具有后进先出的特性的程序流 . 在堆栈中, push 和 pop 是常用术语: push: 意思是把一个对象入栈. pop: 意思是把一个对象出栈. ...

    目录

    堆栈

    堆栈是一个后进先出(LIFO)的数据结构. 堆栈这个数据结构可以用于处理大部分具有后进先出的特性的程序流 .
    在堆栈中, pushpop 是常用术语:

    • push: 意思是把一个对象入栈.
    • pop: 意思是把一个对象出栈.

    下面是一个由 Python 实现的简单的堆栈结构:

    
    stack = []                 # 初始化一个列表数据类型对象, 作为一个栈
    
    def pushit():              # 定义一个入栈方法
        stack.append(raw_input('Enter New String: ').strip())      
        # 提示输入一个入栈的 String 对象, 调用 Str.strip() 保证输入的 String 值不包含多余的空格
    
    def popit():               # 定义一个出栈方法
        if len(stack) == 0:
            print "Cannot pop from an empty stack!"
        else:
            print 'Remove [', `stack.pop()`, ']'
            # 使用反单引号(` `)来代替 repr(), 把 String 的值用引号扩起来, 而不仅显示 String 的值
    
    def viewstack():           # 定义一个显示堆栈中的内容的方法
            print stack
    
    CMDs = {'u':pushit, 'o':popit, 'v':viewstack}
    # 定义一个 Dict 类型对象, 将字符映射到相应的 function .可以通过输入字符来执行相应的操作
    
    def showmenu():            # 定义一个操作菜单提示方法
        pr = """
        p(U)sh
        p(O)p
        (V)iew
        (Q)uit
    
        Enter choice: """
    
        while True:
            while True:
                try:
                    choice = raw_input(pr).strip()[0].lower()
                    # Str.strip() 去除 String 对象前后的多余空格
                    # Str.lower() 将多有输入转化为小写, 便于后期的统一判断
                    # 输入 ^D(EOF, 产生一个 EOFError 异常)
                    # 输入 ^C(中断退出, 产生一个 keyboardInterrupt 异常)
    
                except (EOFError, KeyboardInterrupt, IndexError):
                    choice = 'q'
    
                print '\nYou picked: [%s]' % choice
    
                if choice not in 'uovq':
                    print 'Invalid option, try again'
                else:
                    break
    
    
            if choice == 'q':
                break
            CMDs[choice]()
            # 获取 Dict 中字符对应的 functionName, 实现函数调用
    
    if __name__ == '__main__':
        showmenu()

    NOTE: 在堆栈数据结构中, 主要应用了 List 数据类型对象的 容器可变 等特性, 表现在 List.append()List.pop() 这两个列表类型内建函数的调用.

    展开全文
  • 除了能够以批处理模式分析大型数据集之外,现代数据驱动型组织还...在Lambda架构中,一个“慢”大数据处理框架(如Hadoop堆栈)与一个“快速”的流处理框架(如Apache Storm)组合在一起。由快速框架处理的数据或者与
  • 数据结构-链式堆栈

    2016-09-12 15:13:24
    1、实现链式堆栈相关API函数 2、泛型编程思想 3、实体数据可以是基本类型或者复合类型 4、遍历时,使用回调函数。实现“策略”与“机制”分离 5、使用动态内存,保存链表节点及用户数据
  • 数据结构复习:堆栈

    2019-03-15 00:03:31
    1、堆栈的抽象数据类型描述 堆栈(Stack):具有一定操作约束的线性表。只在一端(栈顶,Top)做插入、删除 插入数据:入栈(push) 删除数据:出栈(pop) 后入先出:Last In First Out(LIFO) 数据对象集:一个...

    1、堆栈的抽象数据类型描述

    堆栈(Stack):具有一定操作约束的线性表。只在一端(栈顶,Top)做插入、删除

    • 插入数据:入栈(push)
    • 删除数据:出栈(pop)
    • 后入先出:Last In First Out(LIFO)

    数据对象集:一个有0个或多个元素的有穷线性表

    操作集:长度为MaxSize的堆栈S属于Stack,堆栈元素item属于ElementType

    • Stack CreateStack(int MaxSize):生成空堆栈,其最大长度为Maxsize
    • int IsFull(Stack S,int MaxSize):判断堆栈S是否已满
    • void Push(Sstack S,ElementType item):将元素item压入堆栈
    • int IsEmpty(Stack S):判断堆栈S是否为空
    • ElementType Pop(Stack S):删除并返回栈顶元素

     如上图所示:先创建一个堆栈,然后pushA,B,C,D,然后一直pop出来的序列是DCBA

     

    2、堆栈的顺序存储实现

    栈的顺序存储结构通常由一个一维数组和一个记录栈顶元素位置的变量组成。

    可用一个结构来表示堆栈:

    #define MaxSize <存储数据元素的最大个数>
    typedef struct SNode*Stack;
    struct SNode{
            ElementType Data[MaxSize];   //数组,数组的分量是ElementType类型
            int Top;    //指示栈顶的位置,实际上是栈顶数据的下标是多少
    };

    (1)入栈

     

    (2)出栈 

    (3)【例】用一个数组实现两个堆栈,要求最大的利用数组空间,使数组只要有空间入栈操作就可以成功。

    【分析】一种较好的方法是使两个栈分别从数组的两头开始向中间生长,当两个栈的栈顶指针相遇时,表示两个栈都满了。

    定义其堆栈结构:

    其push和pop操作:

     

    3、堆栈的链式存储实现

    栈的链式存储结构实际上就是一个单链表,叫做链栈。插入和删除操作只能在链栈的栈顶进行。

    栈顶指针Top应该在链表的哪一头呢?(一定是指向链表的头部)

     

     

     

    定义其结构,包含两个域:data域和next域

    typedef struct SNode *Stack;
    struct SNode{
            ElementType Data;
            struct SNode *Next;
    };
    Stack CreateStack()    //生成堆栈的头结点
    { /* 构建一个堆栈的头结点,返回指针 */
        Stack S;
        S =(Stack)malloc(sizeof(struct SNode));
        S->Next = NULL;
        return S;
    }
    
    int IsEmpty(Stack S)
    {                     
        /*判断堆栈S是否为空,若为空函数返回整数1,否则返回0 */
        return ( S->Next == NULL );
    }
    void Push( ElementType item, Stack S)
    { /* 将元素item压入堆栈S */
        struct SNode *TmpCell;
        TmpCell=(struct SNode *)malloc(sizeof(struct SNode));
        TmpCell->Element = item;
        TmpCell->Next = S->Next;
        S->Next = TmpCell;
    }
    ElementType Pop(Stack S)
    { /* 删除并返回堆栈S的栈顶元素 */
        struct SNode *FirstCell;
        ElementType TopElem;
        if( IsEmpty( S ) ) {
        printf(“堆栈空”); return NULL;
        } else {
            FirstCell = S->Next;
            S->Next = FirstCell->Next;
            TopElem = FirstCell ->Element;
            free(FirstCell);
            return TopElem;
        }
    }

     

    4、堆栈应用:表达式求值。中缀表达式转换为后缀表达式

    中缀表达式求值:

    基本策略:将中缀表达式转换为后缀表达式,然后求值。

    观察一个简单的例子: 2+9/3-5     的后缀表达式为   2 9 3 / + 5 -

           1.运算数相对顺序不变

           2.运算符号顺序发生改变(需要存储等待中的运算符号用到堆栈。要将当前运算符与等待中最后一个运算符比较)

    • 上述例子意思是:
    • 来了一个a,输出;
    • 来了个 * 号,push进堆栈;
    • 左括号( ,push进堆栈 ; 
    • b,输出
    • +号,push进堆栈
    • c,输出
    • 右括号 ),pop出+号,左括号。堆栈里只剩下*号
    • / 号,抛出称号,push进除号

     

    中缀表达式如何转换为后缀表达式

    中缀转换为后缀实例: ( 2*(9+6/3-5)+4 )

     

     

     

    参考:浙大公开课《数据结构》——陈越、何钦铭

     

    展开全文
  • 堆栈是一个后进先出(LIFO)的数据结构. 堆栈这个数据结构可以用于处理大部分具有后进先出的特性的程序流 . 在堆栈中, push 和 pop 是常用术语: push: 意思是把一个对象入栈. pop: 意思是把一个对象出栈. 下面是一...
  • 嵌入式常用数据结构-链表、队列、堆栈、可删除key值链表、优先级队列,消息队列
  • 数据结构——堆栈

    2016-03-10 08:37:39
    数据结构——堆栈   宗旨:技术的学习是有限的,分享的精神是无限的。   1、特性:先进后出(FILO)   2、应用:  子程序的调用  处理递归调用  表达式转换与求值  二叉树的遍历  图形的深度优化...
  • 数据结构-顺序堆栈

    2016-09-12 14:56:26
    1、实现顺序堆栈相关API函数 2、泛型编程思想,由主调函数提供内存空间 3、实体数据可以是基本类型或者复合类型 4、遍历时,使用回调函数。实现“策略”与“机制”分离
  • 简单理解内存中的堆栈数据结构中的堆栈
  • 数据寻址——堆栈寻址

    千次阅读 2021-05-15 16:47:59
    文章目录堆栈寻址完成一次加法的过程 堆栈寻址 堆栈寻址:操作数存放在堆栈中,隐含使用堆栈指针(SP)作为操作数地址。 堆栈是存储器(或专用寄存器组)中一块特定的按“后进先出(LIFO)”原则管理的存储区,该存储...
  • 数据结构的堆栈的游戏 数据结构的堆栈的游戏
  • 系统堆栈的故事+数据结构中的堆和栈
  • 一个(令人愉快的)堆栈数据结构 ##安装 npm install delightful-stack --save ##API 获取对 Stack 构造函数的引用并创建一个新堆栈: var Stack = require ( 'delightful-stack' ) ; var stack = new Stack ...
  • full-stack-data-science, 在 python 中,完整的堆栈数据科学 全堆栈数据科学"所有交易的杰克,没有任何东西,尽管经常比一个人更好。"在大型组织中我们遇到的一个常见的难点是数据科学应用程序的最后一英里交付。...
  • 堆栈及静态数据区详解
  • 主要介绍了LinkedList学习示例,模拟一个堆栈与队列数据结构,大家参考使用吧

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 377,968
精华内容 151,187
关键字:

堆栈数据结果