ArrayQueue.dequeue() - Code Metrics - chen0040/pyalgs - Measure and Improve Code Quality continuously with Scrutinizer

ArrayQueue.dequeue() A
last analyzed 2017-05-26 05:56 UTC

↳ Parent: ArrayQueue

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	3
c	1
b	0
f	0
dl	0
loc	9
rs	9.6666

from abc import abstractmethod, ABCMeta


class Queue(object):
    """ Queue interface
    
    """

    __metaclass__ = ABCMeta

    @abstractmethod
    def enqueue(self, item):
        pass

    @abstractmethod
    def dequeue(self):
        pass

    @abstractmethod
    def is_empty(self):
        pass

    @abstractmethod
    def size(self):
        pass

    @staticmethod
    def create():
        return LinkedListQueue()

    @abstractmethod
    def iterate(self):
        pass


class Node(object):

    value = None
    nextNode = None

    def __init__(self, value):
        self.value = value


class LinkedListQueue(Queue):

    first = None
    last = None
    N = 0

    def size(self):
        return self.N

    def iterate(self):
        x = self.first
        while x is not None:
            value = x.value
            x = x.nextNode
            yield value

    def enqueue(self, item):
        old_last = self.last
        self.last = Node(item)
        if old_last is not None:
            old_last.nextNode = self.last
        if self.first is None:
            self.first = self.last
        self.N += 1

    def is_empty(self):
        return self.N == 0

    def dequeue(self):
        if self.is_empty():
            return None
        old_first = self.first
        self.first = old_first.nextNode
        if old_first == self.last:
            self.last = None
        self.N -= 1
        return old_first.value


class ArrayQueue(Queue):

    head = 0
    tail = 0
    s = []

    def __init__(self, capacity=None):
        if capacity is None:
            capacity = 10
        self.s = [0] * capacity

    def iterate(self):
        if self.is_empty():
            return
        for i in range(self.head, self.tail):
            yield self.s[i]

    def enqueue(self, item):
        self.s[self.tail] = item
        self.tail += 1
        if self.tail == len(self.s):
            self.resize(len(self.s) * 2)

    def resize(self, new_size):
        tmp = [0] * new_size
        for i in range(self.head, self.tail):
            tmp[i-self.head] = self.s[i]
        self.s = tmp
        self.tail = self.tail - self.head
        self.head = 0

    def size(self):
        return self.tail - self.head

    def is_empty(self):
        return self.size() == 0

    def dequeue(self):
        if self.is_empty():
            return None

        deleted = self.s[self.head]
        self.head += 1
        if self.size() == len(self.s) // 4:
            self.resize(len(self.s) // 2)
        return deleted


1			from abc import abstractmethod, ABCMeta
2
3
4			class Queue(object):
5			""" Queue interface
6
7			"""
8
9			__metaclass__ = ABCMeta
10
11			@abstractmethod
12			def enqueue(self, item):
13			pass
14
15			@abstractmethod
16			def dequeue(self):
17			pass
18
19			@abstractmethod
20			def is_empty(self):
21			pass
22
23			@abstractmethod
24			def size(self):
25			pass
26
27			@staticmethod
28			def create():
29			return LinkedListQueue()
30
31			@abstractmethod
32			def iterate(self):
33			pass
34
35
36			class Node(object):
37
38			value = None
39			nextNode = None
40
41			def __init__(self, value):
42			self.value = value
43
44
45			class LinkedListQueue(Queue):
46
47			first = None
48			last = None
49			N = 0
50
51			def size(self):
52			return self.N
53
54			def iterate(self):
55			x = self.first
56			while x is not None:
57			value = x.value
58			x = x.nextNode
59			yield value
60
61			def enqueue(self, item):
62			old_last = self.last
63			self.last = Node(item)
64			if old_last is not None:
65			old_last.nextNode = self.last
66			if self.first is None:
67			self.first = self.last
68			self.N += 1
69
70			def is_empty(self):
71			return self.N == 0
72
73			def dequeue(self):
74			if self.is_empty():
75			return None
76			old_first = self.first
77			self.first = old_first.nextNode
78			if old_first == self.last:
79			self.last = None
80			self.N -= 1
81			return old_first.value
82
83
84			class ArrayQueue(Queue):
85
86			head = 0
87			tail = 0
88			s = []
89
90			def __init__(self, capacity=None):
91			if capacity is None:
92			capacity = 10
93			self.s = [0] * capacity
94
95			def iterate(self):
96			if self.is_empty():
97			return
98			for i in range(self.head, self.tail):
99			yield self.s[i]
100
101			def enqueue(self, item):
102			self.s[self.tail] = item
103			self.tail += 1
104			if self.tail == len(self.s):
105			self.resize(len(self.s) * 2)
106
107			def resize(self, new_size):
108			tmp = [0] * new_size
109			for i in range(self.head, self.tail):
110			tmp[i-self.head] = self.s[i]
111			self.s = tmp
112			self.tail = self.tail - self.head
113			self.head = 0
114
115			def size(self):
116			return self.tail - self.head
117
118			def is_empty(self):
119			return self.size() == 0
120
121			def dequeue(self):
122			if self.is_empty():
123			return None
124
125			deleted = self.s[self.head]
126			self.head += 1
127			if self.size() == len(self.s) // 4:
128			self.resize(len(self.s) // 2)
129			return deleted
130

chen0040 / pyalgs

ArrayQueue.dequeue() A last analyzed 2017-05-26 05:56 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

ArrayQueue.dequeue() A
last analyzed 2017-05-26 05:56 UTC