Question

我目前正致力于在Python中实现Fibonacci堆，以用于我自己的个人开发。在为圆形双链表编写对象类时，我遇到了一个我不确定的问题。

对于链表的快速成员资格测试（为了更快地执行'删除'和'合并'等操作），我想在我的链接中添加一个哈希表（一个python'set'对象）列表类。请参阅下面我公认的非常不完美的代码，了解我是如何做到的：

App.controller('MyCtrl2', ['$scope', '$http', 'Upload', '$timeout', function ($scope, $http, Upload, $timeout) {
    $scope.uploadPic = function(file) {
        var filename = file.name;
        var type = file.type;
        var query = {
            filename: filename,
            type: type
        };
        $http.post('/signing', query)
            .success(function(result) {
                Upload.upload({
                    url: result.url, //s3Url
                    transformRequest: function(data, headersGetter) {
                        var headers = headersGetter();
                        delete headers.Authorization;
                        return data;
                    },
                    fields: result.fields, //credentials
                    method: 'POST',
                    file: file
                }).progress(function(evt) {
                    console.log('progress: ' + parseInt(100.0 * evt.loaded / evt.total));
                }).success(function(data, status, headers, config) {
                    // file is uploaded successfully
                    console.log('file ' + config.file.name + 'is uploaded successfully. Response: ' + data);
                }).error(function() {

                });
            })
            .error(function(data, status, headers, config) {
                // called asynchronously if an error occurs
                // or server returns response with an error status.
        });
    };
}]);

我的问题是，哈希表是否占用了刚刚实现没有哈希表的链表的空间量的两倍？当我查看哈希表中的Node对象时，它们似乎与仅仅是独立节点对象时的内存位置完全相同。例如，如果我创建一个节点：

class Node:
    def __init__(self,value):
        self.value = value
        self.degree = 0
        self.p = None
        self.child = None
        self.mark = False
        self.next = self
        self.prev = self

    def __lt__(self,other):
        return self.value < other.value


class Linked_list:
    def __init__(self):
        self.root = None
        self.nNodes = 0
        self.members = set()

    def add_node(self,node):
        if self.root == None:
            self.root = node
        else:
            self.root.next.prev = node
            node.next = self.root.next
            self.root.next = node
            node.prev = self.root
            if node < self.root:
                self.root = node
        self.members.add(node)
        self.nNodes = len(self.members)

    def find_min():
        min = None
        for element in self.members:
            if min == None or element<min:
                min = element
        return min

    def remove_node(self,node):
        if node not in self.members:
            raise ValueError('node not in Linked List')
        node.prev.next, node.next.prev = node.next, node.prev
        self.members.remove(node)
        if self.root not in self.members:
            self.root = self.find_min()
        self.nNodes -=1

    def merge_linked_list(self,LL2):
        for element in self.members&LL2.members:
            self.remove_node(element)
        self.root.prev.next = LL2.root
        LL2.root.prev.next = self.root
        self.root.prev, LL2.root.prev = LL2.root.prev, self.root.prev
        if LL2.root < self.root:
            self.root = LL2.root
        self.members = self.members|LL2.members
        self.nNodes = len(self.members)

    def print_values(self):
        print self.root.value
        j = self.root.next
        while j is not self.root:
            print j.value
            j = j.next

然后将此节点放在一个集合中：

In:  n1 = Node(5)    
In:  print n1
Out: <__main__.Node instance at 0x1041aa320>

这是相同的内存位置。所以看起来这个集合不会复制节点。

我的问题是，大小为n的链表的空间复杂性是什么，其中哈希表跟踪元素。是n还是2n？使用哈希表来跟踪元素是否存在任何基本错误。

我希望这不是重复。我试着找一个回答这个问题的帖子，但没有找到任何令人满意的结果。

Answer 1

检查In-memory size of a Python structure和How do I determine the size of an object in Python?以获取确定对象大小的完整答案

我在64位机器上使用python 3

获得了这个小结果

>>> import sys
>>> sys.getsizeof (1)
28
>>> sys.getsizeof (set())
224
>>> sys.getsizeof (set(range(100)))
8416

结果以字节为单位。这可以给你一个关于大集合的暗示（它们非常大）。

我的问题是，大小为n的链表的空间复杂性是什么，其中哈希表跟踪元素。是n还是2n？使用哈希表来跟踪元素是否存在任何基本错误。

复杂性计算从未在n和2n之间产生差异。优化。并且通常会说“早期优化是所有邪恶的根源”，以警告潜在的优化陷阱。因此，您认为最适合支持的操作。

带有哈希表空间的循环双链表

1 个答案: