精华内容
下载资源
问答
  • 两个实现一个队列:所有元素要么顺序存在stack1(便于push),要么逆序存在stack2(便于pop),因此每次push和pop之前都要保证元素都存在对应的中了 class Solution { public: //两个实现一个队列: //所有...

    题目描述

    用两个栈来实现一个队列,完成队列的Push和Pop操作。 队列中的元素为int类型。

    解法

    栈 A是顺序存储,用来加入队尾,栈 B 用来逆序存储,用来删除队首。具体步骤如下:

    • 加入队尾push()函数: 将数字 val 加入栈 A 即可。(之前有一个不太对的想法,觉得此时如果栈 B 不为空,就要先把栈 B 的元素都转移到栈 A,再往栈 A加新元素,其实不用)
    • 删除队首pop()函数: 有以下三种情况。
    1. 当栈 B 不为空: B中仍有已完成倒序的元素,因此直接返回 B 的栈顶元素。
    2. 否则,当 A 为空: 即两个栈都为空,无元素,因此返回 −1 。
    3. 否则: 将栈 A 元素全部转移至栈 B 中,实现元素倒序,并返回栈 B 的栈顶元素。
    class CQueue {
    public:
        CQueue() {
            
        }
        
        void appendTail(int value) {
            //直接存到st1
            st1.push(value);
        }
        
        int deleteHead() {
            //如果st2不为空,就从st2取
            if( !st2.empty() ){
                int value = st2.top();
                st2.pop();
                return value;
            }
            //否则就将st1的元素都转移到st2然后取。注意判断是否为空
            while( !st1.empty() ){
                st2.push( st1.top() );
                st1.pop();
            }
            if( st2.empty() ) {
                return -1;
            }else{
                int value = st2.top();
                st2.pop();
                return value;
            } 
        }
    private:
        stack<int> st1; //顺序存放,用来加入队尾
        stack<int> st2; //逆序存放,用来取出队首
    };
    
    /**
     * Your CQueue object will be instantiated and called as such:
     * CQueue* obj = new CQueue();
     * obj->appendTail(value);
     * int param_2 = obj->deleteHead();
     */
    
    展开全文
  • 如果一个对象包含基本类型,那个基本类型是存栈还是堆? 我知道对象是在堆里的,那它的包含所有都是堆里吗?
  • oc 变量存栈 对象存堆

    2014-03-10 10:21:29
    Objective-C的对象在内存中是以堆的方式分配空间的 你可以看到很多对象的初始化...由编译器管理自动释放的,在方法中(函数体)定义的变量通常是在内,因此如果你的变量要跨函数的话就需要将其定义为成员变量。...
    Objective-C的对象在内存中是以堆的方式分配空间的 你可以看到很多对象的初始化是 [NSObject alloc]init],alloc是NSObject分配内存的一个方法(你的oc对象基类基本都是NSObject),并且堆内存是由你释放的,即release
    栈由编译器管理自动释放的,在方法中(函数体)定义的变量通常是在栈内,因此如果你的变量要跨函数的话就需要将其定义为成员变量。
    展开全文
  • 把两条数组中,把中相同的元素从底弹出,弹到元素不同为止。 不同则返回当前元素值,一直相同则返回None. 上代码。 # Definition for singly-linked list. # class ListNode: # def __init__(self, x): # ...

    Leetcode 160题 Intersection of Two Linked Lists
    Write a program to find the node at which the intersection of two singly linked lists begins.

    For example, the following two linked lists:
    在这里插入图片描述

    begin to intersect at node c1.


    题目大意: 两条相交数组,返回相交点。

    思路一:
    两条数组若相交,从相交点往后必定相等。把两条数组存到栈中,把栈中相同的元素从栈底弹出,弹到元素不同为止。 不同则返回当前元素值,一直相同则返回None.
    上代码。

    # Definition for singly-linked list.
    # class ListNode:
    #     def __init__(self, x):
    #         self.val = x
    #         self.next = None
    
    class Solution:
        def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> ListNode:
            stack1 = []
            stack2 = []
            while headA:     #数组存入栈的操作
                stack1.append(headA)
                headA = headA.next
            while headB:
                stack2.append(headB)
                headB = headB.next
            result = None
            while stack1 and stack2: #当两个栈存在时
                node1 = stack1.pop() #从栈底弹出元素。
                node2 = stack2.pop()
                if node1 != node2:   #若弹出的元素不同
                    return result  #返回None
                else: 
                    result = node1  #若相同,返回元素节点。
            return result
    

    本来考虑反转列表之后,用指针从第一个开始遍历,遍历到第一个不同的地方,返回这个地方的上一个值。 可是发现不能改变列表结构,那就算了。

    2020/03/24
    疫情中的英国。
    加油!

    展开全文
  • 当 Android 想要退出应用时,我们总是希望完全退出。但是 Android 并没有提供一个完全退出 App 的函数。 Google 上搜索了一下,方法有很多,但是基本都是只退出了当前的 Activity...利用 Activity 的方式来 fini...

    当 Android 想要退出应用时,我们总是希望完全退出。但是 Android 并没有提供一个完全退出 App 的函数。

    Google 上搜索了一下,方法有很多,但是基本都是只退出了当前的 Activity, 并没有完全 finish 所有的 Activity。

    利用存 Activity 栈的方式来 finish 所有这个方法目前来看是对我直接有效的,但是实际运行过程中, leakcanary 会报内存泄漏的异常,原因是我的 List 会对每一个 Activity 启动时进行添加,而当我 finish 某个 activity 时,List 里对应的 Activity 无法被 GC,这样导致我的内存开销增加了。如果我对每一次 Activity 的 finish 之后再清除对应的 List 里的 Activity, 这样我觉得会很麻烦,一点都不优雅。下面介绍一下 SoftReference 对象。

    SoftReference,即“软引用”,由垃圾收集器根据内存需求自行清除。假设垃圾收集器在某个时间点确定对象是可以轻松访问的。那时候,它可能会选择原子地清除对该对象的所有软引用,以及对任何其他可轻松访问的对象的所有软引用,通过一个强引用链可以从该对象到达该对象。在同一时间或稍后的时间,它将排入在引用队列中注册的新清除的软引用。在虚拟机抛出OutOfMemoryError之前,所有对软到达对象的软引用都保证被清除。否则,在清除软引用的时间或者对一组对不同对象的引用将被清除的顺序没有约束。但是,鼓励虚拟机实现偏离清除最近创建或最近使用的软引用。

    softreference 可以在 Activity 完成生命周期并且没有其他被引用的情况下被 GC 释放。所以 List 存 SoftReference 可以解决问题。

    继承一个 Application 类

    public class MyApp extends Application {
        private List<SoftReference<Activity>> activityList = new LinkedList<>();
        private static MyApp instance;
        public static Context context;
    
        @Override
        public void onCreate(){
            super.onCreate();
            context = getApplicationContext();
            LeakCanary.install(this);
        }
    
        public static MyApp getInstance() {
            if(null == instance) {
                instance = new MyApp();
            }
            return instance;
        }
        //添加 Activity 的软引用到容器中
        public void addActivity(SoftReference<Activity> softReference)  {
            activityList.add(softReference);
        }
        //遍历所有Activity并finish
        public void exit(){
            for(int i=0;i<activityList.size();i++){
                Activity activity = activityList.get(i).get();
                if(activity != null){
                    activity.finish();
                }
            }
            System.exit(0);
        }
    }
    

    添加 Activity 的软引用

    在 BaseActivity 的 onCreate() 方法对继承的 Activity 添加软引用到 MyApp 的 List 里。

    MyApp.getInstance().addActivity(new SoftReference<>(this));
    

    调用 exit() 方法

    当需要退出 App 时,只需调用 MyApp 的 exit() 方法即可。

    MyApp.getInstance().exit();
    

    原文地址:Android 使用 SoftReference 解决 Activity 存栈的内存泄漏问题
    我的博客:时空路由器

    展开全文
  • 堆中什么?什么?

    千次阅读 2018-03-08 14:31:06
    的是基本数据类型和堆中对象的引用。一个对象的大小是不可估计的,或者说是可以动态变化的,但是在中,一个对象只对应了一个4btye的引用(堆栈分离的好处:))。为什么不把基本类型放堆中呢?因为其占用的...
  • 溢出、內溢出、Java內泄露

    千次阅读 2013-12-24 20:06:43
    Java溢出、Java內溢出、Java內泄露
  • 排序

    2017-02-20 15:55:20
    昨天刚好碰到这道题,于是写了代码实现之,聊以慰藉过节的无聊和空虚。 #include #include using namespace std;...//s为原栈,ss为输出栈,sss为暂存栈 int num; while(cin>>num) { s.push(num); }
  • 2021-03-03 14:13:46
    顺序输2.1 顺序的定义2.2 进栈操作3.链式存储 1.基本概念 1.1 定义及基本操作 数据结构三要素:逻辑结构、数据的运算、存储结构 (Stack)是只允许在一端进行插入或删除操作的线性表 逻辑结构:与普通线性表...
  • 用数组两个

    2017-01-12 10:26:30
     cout 请输入S1的长度:" ;  cin >> length1;  for (i = 1; i ; i++)  {  cin >> n;  Push(S1, n);  }  cout 请输入S2的长度:" ;  cin >> length2;  for (i = 1; i ; i++)  { ...
  • 满就说明数组空间满了,头指针挨着尾指针了。 太简单了,主要是给女朋友讲的 源代码 #include <stdio.h> #include <stdlib.h> #define max 100 typedef struct { char date[max]; int top1...
  • 使用数据解决寄存器冲突 assume cs:code data segment db 'word',0 db 'unix',0 db 'wind',0 db 'good',0 data ends code segment start: mov ax,data mov ds,ax mov si,0 mov cx,4 s: call ...
  • C语言实现,

    2018-01-18 21:59:03
    //用于临时存栈 /****初始化栈***/ InitStack(sqstack); printf( "初始化时,堆的大小为:%d\n" ,sqstack.stackSize); /**根据输入来填充栈**/ printf( "请入你想要输入几个数据进栈:" ); scanf( "%d...
  • 什么? 堆中的是 对象 。的是 基本数据类型 和 堆中对象的引用 。一个对象的大小是不可估计的,或者说是可 以动态变化的,但是在中,一个对象只对应了一个4btye的引用(堆栈分离的好处:))。 为...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 5,239
精华内容 2,095
关键字:

存栈