标签: lifo

我了解队列和堆栈之间的区别。但是，如果我生成多个进程并在它们之间发送消息放入multiprocessing.Queue如何访问放入队列中的最新元素？

我是python的初学者,我遇到了这个程序的问题:

以下程序是后进先出(LIFO).我想制作先进先出(FIFO)程序.

from NodeList import Node

class QueueLL:

    def __init__(self):
        self.head = None


    def enqueueQLL(self,item):
        temp = Node(str(item))
        temp.setNext(self.head) 
        self.head = temp
        length = max(len(node.data) for node in self.allNodes()) if self.head else 0
        print('\u2510{}\u250c'.format(' '*length))
        for node in self.allNodes():
            print('\u2502{:<{}}\u2502'.format(node.data, length))
        print('\u2514{}\u2518'.format('\u2500'*length))

这是NodeList:

class Node:

    def __init__(self,initdata):
        self.data = initdata
        self.next = None

    def getData(self):
        return self.data

    def getNext(self):
        return self.next

    def setData(self,newdata):
        self.data = newdata

    def setNext(self,newnext):
        self.next = newnext

注意:"Rainbow"应位于"Arc"的底部或FIFO中(下图为LIFO)

我想在NodeList中添加一个类似setPrevious的新def,但我不知道如何.(说实话,我对这些self.head = none东西真的很新.我曾经写过self.items = [])

任何帮助和提示将不胜感激!谢谢!

我正在学习F#agents(MailboxProcessor).

我正在处理一个非常传统的问题.

• 我有一个代理(dataSource),它是流数据的来源.数据必须由一系列代理(dataProcessor)处理.我们可以将其dataProcessor视为某种跟踪设备.
• 数据的流动速度可能快于dataProcessor可以处理其输入的速度.
• 有一些延迟是可以的.但是,我必须确保代理人始终处于工作之上,并且不会在过时的观察中被堆积

我正在探索解决这个问题的方法.

第一个想法是实现堆栈(LIFO)dataSource.dataSource当dataProcessor可用于接收和处理数据时,将发送最新的观察结果.该解决方案可能有效,但dataProcessor可能需要被阻止和重新激活,因此可能会变得复杂; 并传达其状态dataSource,导致双向沟通问题.这个问题可以归结为一个blocking queue在消费者-生产者问题,但我不知道..

在第二个想法是有 dataProcessor照顾的消息排序.在这个架构中,dataSource只需在dataProcessor队列中发布更新.dataProcessor将用于Scan获取队列中可用的最新数据.这可能是要走的路.但是,我不确定在当前的设计中MailboxProcessor是否可以清除消息队列,删除旧的过时消息.此外,在这里写道:

不幸的是,当前版本的F#中的TryScan功能有两种方式.首先,重点是指定超时,但实现实际上并不尊重它.具体而言,不相关的消息会重置计时器.其次,与其他扫描功能一样,在锁定下检查消息队列,该锁定防止任何其他线程在扫描期间发布,这可能是任意长的时间.因此,TryScan函数本身往往会锁定并发系统,甚至可能引入死锁,因为调用者的代码是在锁内部进行评估的(例如,当锁定下的代码阻塞时,从函数参数发送到Scan或TryScan会使代理死锁获得已经存在的锁定.

将最新观察结果反弹可能是一个问题.这篇文章的作者@Jon Harrop暗示了这一点

我设法围绕它进行构建,结果架构实际上更好.本质上,我热切地Receive使用我自己的本地队列来消息和过滤所有消息.

这个想法肯定值得探索,但在开始使用代码之前,我会欢迎一些关于如何构建解决方案的输入.

谢谢.

这是我的第一个stackoverflow问题.我在这上面做了很多谷歌搜索.在Hashsets,Treesets,LinkedHashSets,Collections,Stacks(Stack类被弃用？)......我意识到我可以使用SQLite,但我暂时试图避免这种情况.

我正在使用Android Studio中的应用程序.该应用与人打交道,列出并以不同方式与他们联系.应用用户可以维护和控制三种类型的列表:最近联系,阻止和收藏.这些列表在共享首选项中保存为字符串集,因此它们可以在应用程序关闭和重新打开后继续存在.当使用在线数据库填充列表时,各个字符串充当主键.我最关心的是"最近联系的"列表,因为这个列表的顺序很重要.

问题是,据我所知,当我声明一个字符串集时,它如下:

Set<String> faveArray = new LinkedHashSet<String>;

据我所知,我只能在右侧使用HashSet,LinkedHashSet或TreeSet.

因为我使用了LinkedHashset,所以当我重新打开应用程序并从共享偏好中拉出数据时,我会期望从最近添加的(LIFO /堆栈)开始拉出字符串,因此当我填充listview时,他们将与列表顶部的"最近联系"人员展示等等......或者至少我期待有某种可预测的顺序/行为,我可以使用.

所以.......我已经为我的共享首选项I/O类附加了我的代码.

从我的主应用程序,我做了类似的事情:

static SharedPrefUTIL sharedPrefUTIL;

sharedPrefUTIL = new SharedPrefUTIL(this);

sharedPrefUTIL.addRecent("derp");
sharedPrefUTIL.addRecent("nerp");
sharedPrefUTIL.addRecent("gerp");
sharedPrefUTIL.addRecent("herp");

此时,代码

Log.i(TAG, set + " committed to " + key);

在类SharedPrefUTIL日志的commit()方法中:

"[derp,nerp,gerp,herp]致力于最近的阵营"

关闭并重新打开应用程序后,如果我们执行:

sharedPrefUTIL.toastContents("R");

结果似乎是随机顺序.<<<<这是我的问题.

任何帮助非常感谢.

package com.secretsoft.booberbunz;

import android.content.Context;
import android.content.SharedPreferences;
import android.util.Log;
import android.widget.Toast;

import java.util.Arrays;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.Queue;
import java.util.Set;
import java.util.TreeSet;

/**
* Created by Programming on 2/22/2016.
*/
public class SharedPrefUTIL {

protected static final String TAG …

堆栈被称为后进先出 (LIFO) 和先进后出 (FILO) 结构。

是否有任何数据结构是 LIFO 而不是 FILO（或其他方向）？一个反例证明“FILO并不总是意味着LIFO”

我想知道 golang 频道中元素的顺序。运行几个例子后，元素离开通道的顺序似乎是“后进先出”。我对吗？

以下代码段是我使用的示例。运行代码后，输出为 20 10，其中 10 首先发送到通道，20 最后发送到通道。

package main

import "fmt"

func multiply(c chan int, num int) {
    c <- num * 10
}

func main() {
    c := make(chan int)

    go multiply(c, 1)
    go multiply(c, 2)

    v1 := <-c
    v2 := <-c
    fmt.Println(v1, v2)
}

下午好 ！

我正在尝试制作某种圆形堆栈。它应该像一个普通的 LIFO 堆栈，但没有明显的限制。它应该消除或跳过当时引入的第一个元素，而不是达到最大容量！

例如：

假设我们有一个包含 3 个元素的堆栈：stack[3]

我们通过将 3 个元素“推入”内部来填充它：push[a], push[b], push[c]。

但随后我们需要添加第四个和第五个元素：push[d], push[e]。

标准堆栈会说堆栈已达到极限，无法添加更多元素。

但我想要一个循环堆栈，它将消除或跳过aand b，记住c，dande并输出e，dand c；

该项目是在 ESP32 上的 PlatformIO 中完成的，因此我无法访问 C++ STL，即使可以访问，我也认为仅为 1 个堆栈编译这么大的库是没有意义的。即使曾经有一段时间我认为我应该编译一个类似的库来让我访问stackor deque，但那个时候已经过去了，因为现在我感觉自己像一个无法解决数学问题的白痴。这已经困扰我一个多星期了。

我在网上找到的只是以下 FIFO 循环缓冲区：

class circular_buffer {
public:
    explicit circular_buffer(size_t size) :
        buf_(std::unique_ptr<T[]>(new T[size])),
        max_size_(size)
    {

    }

    void put(T item)
    {
        std::lock_guard<std::mutex> lock(mutex_);

        buf_[head_] = item;

        if(full_) {
            tail_ …

我怎样才能把它变成一个 LIFO-> 后进先出队列？有什么简单的方法可以做到吗？这是一个 FIFO-> 先进先出队列。

using namespace std;

int main(){
    queue<string> q;

    cout << "Pushing one two three four\n";
    q.push("one");
    q.push("two");
    q.push("three");
    q.push("four");

    cout << "Now, retrieve those values in FIFO order.\n";
    while(!q.empty()) {
        cout << "Popping ";
        cout << q.front() << "\n";
        q.pop();
    }
    cout << endl;

    return 0;
}