精华内容
下载资源
问答
  • 今天难得弄懂了关于栈的四种操作方法,做个笔记。 - 对于的操作一共有四种:空减LDMED、空增LDMEA,满减LDMFD、满增LDMFA。ARM常用的是满减LDMFD。 LDM是对内存数据批量操作 F-full(满) E-空 ...
    最近在学ARM的寻址方式,由于对底层并不是特别熟悉,有些问题理解起来有些困难。今天难得弄懂了关于栈的四种操作方法,做个笔记。
    																	-
    对于栈的操作一共有四种:空减LDMED、空增LDMEA,满减LDMFD、满增LDMFA。ARM常用的是满减LDMFD。
    	LDM是对内存数据批量操作
    	F-full(满)        E-空
    	D-减               A-增	
    满:sp指向的是一个实际数据,数据入栈时应先修改SP;
    空:是SP指向一个空的位置,数据入栈时,先数据,再修改栈针。
    减:是指栈向地址小的方向增长
    增:是指栈向地址大的方向增长
    																																					-
    堆栈保存数据和读取数据都是通过唯一的堆栈指针SP来实现的,SP是一个8位专用寄存器(r13),它批示出堆栈顶部在内部RAM块中的位置。
    																	-
    **如果是满减栈,在存储数据时,就先修改栈针,再存储数据。例如,将一个字的数据入栈。先sp(r13)-4,然后存入数据。
    如果是空减栈,那么,就要先存入数据,再修改栈针sp-4->sp。**
    此外还有满增栈与空增栈。
    																																				-
    	LDMFD sp,[r0-r8]            ;在这条指令执行后,SP不发生变化,r0-r8共9个寄存器的内容存入指定的内存区。
    	LDMFD sp!,[r0,r5,r1,r8]    ;将寄存器r0、r5、r1、r8中的数据存入
    																																					-
    需要注意的是,在数据存入时,寄存器序号大的,存在大地址的位置,而寄存器序号小的存在小地址的位置。它们的存储与写在指令中的顺序无关。
    																																														-
    有没有!的区别是:
    				没有!,数据存入后,sp指针回到起始位置(sp指针的位置不变)
    				有!,数据存入后,sp指针指向最后存入数据位置(sp指针位置发生变化)
    																																												-
    例:设内存地址0x3000是SP(R13)的内容
    		现在我们将r0 = 0x12 r1=0x34 r5=0x67 r8=0x90
    		LDMFD sp!,[r0,r5,r1,r8]
    		解:满减LDMFD:先sp(r13)-4,然后存入数据。![寄存器数据存入满减栈](https://img-blog.csdnimg.cn/20200305170356631.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RpQW1vXzk5,size_16,color_FFFFFF,t_70)
    作业:分别用图、表和数据来描述四种栈,一种普通内存块的操作。
    		解:设内存地址0x2000是SP(R13)的内容,先将数据0x12345678存入栈(小端序)![数据入栈的四种结果](https://img-blog.csdnimg.cn/20200305165019605.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RpQW1vXzk5,size_16,color_FFFFFF,t_70)
    		相关理解:(1)关于大小端:
    						大端模式,是指数据的高字节保存在内存的低地址中,而数据的低字节保存在内存的高地址中。
    						小端模式,是指数据的高字节保存在内存的高地址中,而数据的低字节保存在内存的低地址中。
    						例:0x12345678
    							大端序:12 34 56 78 
    							小端序:78 56 34 12
    						(2)关于栈的数据存储:
    							栈是先进后出,存储数据都是在sp指针位置向后插入。(解释为什么空增和空减是一样的)
    							(这是我自己的理解,不知道有没有更专业的说法...)
    						(3)sp指针位置:
    							满——sp指向有数据——先加减sp再存入数据
    							空——sp指向无数据——先存入数据再加减sp
    																																												-
    		**注意:当寄存器入栈时,存储位置只与序号有关,与寄存器在指令中的顺序无关!**
    
    展开全文
  • 2020-10-04 00:15:11
    题目描述:请你定义一个顺序,可以对顺序进行“将某个元素入栈”、“弹出栈顶元素”、“取栈顶元素(不删除)”、“判断是否为空”、“清空”等操作。键盘输入一些命令,可以执行上述操作。本题中,顺序...

    数组实现

    1.顺序栈的基本运算

    描述

    栈的顺序存储结构与操作

    题目描述:请你定义一个顺序栈,可以对顺序栈进行“将某个元素入栈”、“弹出栈顶元素”、“取栈顶元素(不删除)”、“判断栈是否为空”、“清空栈”等操作。键盘输入一些命令,可以执行上述操作。本题中,顺序栈元素为int数字,顺序栈的最大长度为10。

    #include <iostream>
    using namespace std;
    class Seqlist
    {
    public:
    	Seqlist()
    	{
    		top = -1;
    	}
    	~Seqlist(){}
    	void Push(int x);
    	int Pop();
    	int Gettop()
    	{
    		if (top != -1)
    			return data[top];
    	}
    	int Empty()
    	{
    		if (top == -1)
    			return 1;
    		else
    			return 0;
    	}
        
    	void Least()
    	{
    		top = -1;
    	}
    private:
    	int data[10];
    	int top;
    };
    //入栈,需补全代码
    void Seqlist::Push(int x)
    {
    	//TODO
    	if (top < 9) {
    		top++;
    		data[top] = x;
    	}
    	return;
    }
    
    //出栈,需补全代码
    int Seqlist::Pop()
    {
    	//TODO
    	if (top != -1) {
    		return data[top--];
    	}
    	else {
    		return -1;
    	}
    }
    
    int main()
    {
    	char c;
    	cin >> c;
    	Seqlist S;
    	while (c != 'E')
    	{
    		if (c == 'P')
    		{
    			int x;
    			cin >> x;
    			S.Push(x);
    		}
    		if (c == 'D')
    		{
    			int a = S.Pop();
    			if (a != -1)
    				cout << a << endl;
    			else
    				cout << "None";
    		}
    		if (c == 'G')
    		{
    			int a = S.Gettop();
    			cout << a << endl;
    		}
    		if (c == 'T')
    		{
    			S.Least();
    
    		}
    		if (c == 'Y')
    		{
    			int a = S.Empty();
    			if (a == 1)
    				cout << "Yes" << endl;
    			else
    				cout << "No" << endl;
    		}
    		cin >> c;
    	}
    	return 0;
    }
    
    

    链表实现

    1.链栈的基本运算

    描述

    题目描述:

    请你定义一个链栈,可以对链栈进行 “将某个元素入栈”、“弹出栈顶元素”、“取栈顶元素(不删除)”、“判断栈是否为空”、 “清空栈”等操作。键盘输入一些命令,可以执行上述操作。本题中,栈的元素为字符。

    #include<iostream>
    using namespace std;
    class Node
    {
    public:
    	char data;
    	Node* next;
    };
    class LinkStack
    {
    public:
    	LinkStack() { top = NULL; }
    	~LinkStack();
    	void Push(char x);
    	char Pop();
    	void Delete();
        //获得栈顶元素
    	char GetTop()
    	{
    		//ToDo
    		return top->data;
    	}
        //判断是否为空
    	int Empty()
    	{
    		//ToDo
    		if (top == NULL) {
    			return 1;
    		}
    		else {
    			return 0;
    		}
    	}
    private:
    	Node* top;
    };
    LinkStack::~LinkStack()
    {
    	//ToDo
    }
    //入栈操作
    void LinkStack::Push(char x)
    {
    	//ToDo 
    	Node* s = new Node;
    	s->data = x;
    	s->next = top;
    	top = s;
    }
    //出栈操作
    char LinkStack::Pop()
    {
    	//ToDo
    	char x = NULL;
    	if (top != NULL) {
    		Node* pmiddle = top;
    		top = top->next;
    		x = pmiddle->data;
    		delete pmiddle;
    		return x;
    	}
    	return x;
    }
    void LinkStack::Delete()
    {
    	//ToDo
    	Node* pmiddle = top;
    	while (top != NULL) {
    		top = top->next;
    		delete pmiddle;
    		pmiddle = top;
    	}
    }
    int main()
    {
    	LinkStack Seq;
    	char str, x;
    	while (1){
    		cin >> str;
    		//ToDo
    		if (str == 'P'){
    			cin >> x;
    			Seq.Push(x);
    		}
    		if (str == 'D'){
    			x = Seq.Pop();
    			if (x == NULL) {
    				cout << "None" << endl;
    			}
    			else {
    				cout << x << endl;
    			}
    		}
    		if (str == 'G'){
    			x = Seq.GetTop();
    			cout << x << endl;
    		}
    		if (str == 'T'){
    			Seq.Delete();
    
    		}
    		if (str == 'Y'){
    			int a = Seq.Empty();
    			if (a == 1)
    				cout << "Yes" << endl;
    			else
    				cout << "No" << endl;
    		}
    		if (str == 'E'){
    			break;
    		}
    	}
    	return 0;
    }
    

    2.十进制转八进制数

    描述

    将十进制转成八进制

    题目描述:请你定义一个顺序栈,可以对顺序栈进行“将某个元素入栈”、“弹出栈顶元素”、“判断栈是否为空”操作,利用该顺序栈完成十进制数转成八进制数操作。

    最后输出的是八进制序列,就是说把十进制转换成八进制的位数一个个入栈

    #include <iostream>
    using namespace std;
    
    class SeqStack
    {
    public:
    	SeqStack()
    	{
    		top=-1;
    	}
    	
    	~SeqStack(){}
        void Push(int x); 
        int Pop();
    	int GetTop()
    	{
    		if(top!=-1)
    			return data[top];
    	}
        
    	int Empty()
    	{
    		if(top==-1)
    			return 1;
    		else
    			return 0;
    	}
        
    	void Least()
        {
    		top=-1;
    	}
    	
    private:
    	int data[10];
    	int top;
    };
    
    void SeqStack::Push(int x)
    {	
    	if(top==9){
    		cout << "None"<<endl;
    	}
    	else 
    		data[++top]=x;
    }
    
    int SeqStack::Pop()
    {
    	if(top==-1){
    		cout << "None"<<endl;
    		return -1;
    	}else {
    		int x=data[top--];
    		return x;
    	}
    }
    
    int main()
    {
    	SeqStack s;
        int N;
        cin>>N;
         try{
           //ToDo:利用栈s完成十进制数转成八进制,将八进制结果入栈
            while(N){
            s.Push(N%8);
    		N=N/8;
    	    }
         }catch(char s[]){}
    //ToDo:完成出栈并输出,即输出八进制数序列
        while(!s.Empty()){
            cout << s.Pop();
        }
        cout << endl;
    	return 0;
    }
    
    展开全文
  • 关于堆内存和内存的简单描述

    千次阅读 2016-10-27 15:02:59
    内存:内存地址连续,先进来的存放在底,所以先进后出,由系统自动分配空间。如:user user;此时,系统已经在内存中为user分配了空间,现在处于顶部,后面再来的会将这个往下推,直到user被推到了最低的内存...

    栈内存:内存地址连续,先进来的存放在栈底,所以先进后出,由系统自动分配空间。如:user user;此时,系统已经在栈内存中为user分配了空间,现在处于栈顶部,后面再来的会将这个往下推,直到user被推到了最低的内存块,则内存占满。栈内存又称为静态内存。这个内存的大小是固定的。

    堆内存:内存地址不连续,由开发者自行申请、释放(由于java存在jvm,所以释放也是自动的;C语言使用free(XX)方法释放该堆内存)。上面的例子,user user;如果只是这样写,则只有user这个栈内存,堆内存中并没有,当user=new user();或者在C中使用malloc()方法,则此时对内存中才有关于user的堆内存。这个内存的大小是由系统的虚拟内存的大小所决定的。

    展开全文
  • ——顺序

    万次阅读 2019-10-10 09:24:59
    ——顺序栈栈的定义的表示和实现顺序的定义顺序的模块说明基本操作部分算法描述 的定义 :是限定仅在表尾进行插入和删除操作的线性表,又称为后进先出的线性表(简称LIFO结构)。 栈顶:线性表的表尾...

    栈的定义

    栈:是限定仅在表尾进行插入和删除操作的线性表,又称为后进先出的线性表(简称LIFO结构)。
    栈顶:线性表的表尾。
    栈底:线性表的表头。
    空栈:不含元素的栈。

    栈的表示和实现

    和线性表类似,栈也有两种存储表示方法:顺序栈和链栈。

    顺序栈:栈的顺序存储结构是利用一组地址连续的存储单元依次存放自栈底到栈顶的数据元素,通常附设指针top指示栈顶元素在顺序栈中的位置。

    顺序栈的定义

    typedef struct{
    	SElemType *base;	//栈底指针
    	SElemType *top;		//栈顶指针
    	int stacksize;		//栈的最大容量
    }SqStack;
    

    顺序栈的模块说明

    #define STACK_INIT_SIZE 100
    #define STACKINCREMENT 10
    
    typedef struct{
        int *base;
        int *top;
        int stacksize;
    }SqStack;
    
    Status InitStack(SqStack &S);				//构造一个空栈S
    Status DestroyStack(SqStack &S);			//销毁栈S
    Status ClearStack(SqStack &S);				//清除栈S
    Status StackEmpty(SqStack S);				//若栈S为空栈,则返回TRUE,否则返回FALSE
    int StackLength(SqStack S);					//返回栈S的长度
    Status GetTop(SqStack S, SElemType &e);		//若栈S不为空,则用e返回S的栈顶元素,并返回OK,否则返回ERROR
    Status Push(SqStack &S, SElemType e);		//插入元素e为新的栈顶元素
    Status Pop(SqStack &S, SElemType &e);		//若栈S不为空,弹出栈顶元素,用e返回,并返回OK,否则返回ERROR
    Status StackTraverse(SqStack S, Status (*visit)());		//从栈底到栈顶依次对栈中每一个元素调用visit()。一旦visit()失败,则操作失败
    

    栈基本操作部分算法描述

    Status InitStack(SqStack &S){
    //构造一个空栈S
        S.base = (SElemType *)malloc(STACK_INIT_SIZE * sizeof(SElemType));
        if(!S.base)
            exit(OVERFLOW);
        S.top = S.base;
        S.stacksize = STACK_INIT_SIZE;
        return OK;
    }
    
    Status GetTop(SqStack S, SElemType e){
    //若栈S不为空,则用e返回S的栈顶元素,并返回OK,否则返回ERROR
    	if(S.top == S.base)
    		return ERROR;
    	e = *(S.top - 1);
    	return OK;
    }
    
    Status Push(SqStack &S, SElemType e){
    //插入元素e为新的栈顶元素
        if(S.top - S.base >= S.stacksize){
            S.base = (SElemType *)realloc(S.base, (S.stacksize + STACKINCREMENT) * sizeof(SElemType));
            if(!S.base)
                exit(OVERFLOW);
                
            S.top = S.base + S.stacksize;
            S.stacksize += STACKINCREMENT;
        }
        *S.top++ = e;
        return OK;
    }
    
    Status Pop(SqStack &S, SElemType &e){
    //若栈S不为空,弹出栈顶元素,用e返回,并返回OK,否则返回ERROR
        if(S.top == S.base)
            return ERROR;
        e = * --S.top;
        return OK;
    }
    
    Status StackEmpty(SqStack S){
    //若栈S为空栈,则返回TRUE,否则返回FALSE
    	if(S.top == S.base)
    		return TRUE;
    	return FALSE;
    }
    
    展开全文
  • ——数组描述
  • 如何构造描述

    千次阅读 2016-03-23 22:09:09
    如何构造描述符本文要讨论的是:对于x86保护模式(32位),已知空间的起始地址和结束地址,如何定义描述符?ESP的初始为多少?为了简化问题,设定约束条件如下: 1. 段向下扩展 2. B=1 3. G=1 4. ...
  • Linux 中的各种:进程 线程 内核 中断

    万次阅读 多人点赞 2016-09-01 21:52:02
    是什么?有什么作用?首先, (stack) 是一种串列形式的 数据结构。这种数据结构的特点是 后入先出 (LIFO, Last In First Out),数据只能在串列的一端 (称为:栈顶 top) 进行 推入 (push) 和 弹出 (pop) 操作...
  • 本文描述LinuxNPTL的线程简要实现以及线程本地存储的原理,实验环境中Linux内核版本为2.6.32,glibc版本是2.12.1,Linux发行版为ubuntu,硬件平台为x86的32位系统。b.对于LinuxNPTL线程,有很多话题。本文挑选了...
  • 问题描述:用一个二维数组模拟迷宫,其中1为墙,0为通路,用方法判断迷宫是否有出口,下图为简单模拟的迷宫: 思想: 1.首先给出入口点,如上图入口点坐标为{2,0}; 2.从入口点出发,在其上下左右四个方向试探,...
  • C++描述详解

    2014-10-06 13:44:34
    C++的的应用文档。有代码和详细注释。主要取自王红梅的C++数据结构。加上自己的整理。
  • ——进栈、出栈、打印(链表描述)。
  • lua和C\C++之间的交互问题,使用lua的脚本特性来组织C\C++代码是很方便的,这就涉及到lua脚本和C\C++代码的交互问题,使用,此文关于栈使用的一些小问题的描述
  • (JAVA描述)

    2017-03-29 20:53:15
    是一种特殊的线性表,中的数据元素以及数据元素间的逻辑关系与线性表相同,两者区别在于:线性表的插入和删除操作可以在表的任意位置进行,而的插入和删除操作只允许在表的尾端进行。其中,允许进行插入删除...
  • 堆和的精华大总结

    万次阅读 多人点赞 2019-11-18 18:37:41
    :存放基本类型的数据和对象的引用,但对象本身不存放在中,而是存放在堆中 ◆堆:存放用new产生的数据 ◆静态域:存放在对象中用static定义的静态成员 ◆常量池:存放常量 ◆非RAM存储:硬盘...
  • Python描述数据结构之顺序

    千次阅读 2020-08-07 20:32:33
    本篇章主要介绍里的及顺序,并用Python实现顺序的基本操作。
  • c语言:用实现迷宫求解 用实现迷宫求解c语言描述 很好的东西
  • 用数据结构中的思想解决了迷宫问题,C语言描述,注释详细,VC环境下编译通过,运行正确。
  • C++数据结构——

    万次阅读 多人点赞 2018-06-25 21:54:49
    C++数据结构—— 最近计划再复习一遍数据结构,看到一篇博客:https://www.cnblogs.com/QG-whz/p/5170418.html#_label0。 1、(Stack)是一种线性存储结构,它具有如下特点: ...
  • JAVA程序员技术、业务、工具

    千次阅读 2017-11-19 13:50:57
    1、技术 2、业务 3、工具
  • 数据结构:(C语言描述

    千次阅读 2021-07-08 10:13:45
    主要内容:动态的创建初始化、数据入栈、数据出栈、获取栈顶元素、清空内元素、获取内元素个数、检测是否为空、扩容和断言、的几个应用。 我认为这种数据结构要说的不是很多,主要就是先进后出这种...
  • 关于线程与线程地址空间

    千次阅读 2018-04-11 09:30:23
    线程与地址空间Linux系统把所有线程都当做进程来实现,线程作为轻量级进程(LWP)。线程仅仅被视为一个与其他进程共享某些资源的进程,而是否共享地址空间几乎是进程和 Linux 中所谓线程的唯一区别。线程创建的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 329,882
精华内容 131,952
关键字:

关于栈的描述