number - Lista de enlaces de Python

string ascii_lowercase python 3

Question

¿Cuál es la forma más fácil de usar una lista vinculada en Python? En el esquema, una lista vinculada se define simplemente por ''(1 2 3 4 5) . Las listas de Python, [1, 2, 3, 4, 5] , y las tuplas, (1, 2, 3, 4, 5) , no son, de hecho, listas vinculadas, y las listas enlazadas tienen algunas propiedades agradables, como constante- concatenación de tiempo, y ser capaz de hacer referencia a partes separadas de ellos. ¡Hazlos inmutables y realmente fáciles de trabajar!

Answer 1

lista - Tipos de datos de lista enlazada para Python

El módulo llist implementa estructuras de datos de listas enlazadas. Es compatible con una lista doblemente vinculada, es decir, dllist y una lista de estructura de datos vinculada de forma individual.

dllist objetos

Este objeto representa una estructura de datos de lista doblemente enlazada.

first

Primer objeto dllistnode en la lista. None si la lista está vacía.

last

Último objeto dllistnode en la lista. Ninguna si la lista está vacía.

Los objetos dllist también admiten los siguientes métodos:

append(x)

Agregue x al lado derecho de la lista y devuelva dllistnode insertado.

appendleft(x)

Agregue x al lado izquierdo de la lista y devuelva dllistnode insertado.

appendright(x)

Agregue x al lado derecho de la lista y devuelva dllistnode insertado.

clear()

Eliminar todos los nodos de la lista.

extend(iterable)

Agregue elementos de iterable al lado derecho de la lista.

extendleft(iterable)

Anexar elementos de iterable al lado izquierdo de la lista.

extendright(iterable)

Agregue elementos de iterable al lado derecho de la lista.

insert(x[, before])

Agregue x al lado derecho de la lista si no se especificó before , o inserte x en el lado izquierdo de dllistnode before . Devuelve dllistnode insertado.

nodeat(index)

Nodo de retorno (de tipo dllistnode ) en el index .

pop()

Elimine y devuelva el valor de un elemento del lado derecho de la lista.

popleft()

Elimine y devuelva el valor de un elemento del lado izquierdo de la lista.

popright()

Eliminar y devolver el valor de un elemento del lado derecho de la lista

remove(node)

Elimina el node de la lista y devuelve el elemento que estaba almacenado en él.

objetos dllistnode

clase llist.dllistnode([value])

Devuelve un nuevo nodo de lista doblemente vinculado, inicializado (opcionalmente) con value .

dllistnode objetos dllistnode proporcionan los siguientes atributos:

next

Siguiente nodo en la lista. Este atributo es de solo lectura.

prev

Nodo anterior en la lista. Este atributo es de solo lectura.

value

Valor almacenado en este nodo. Compilado de esta referencia

sllist

class llist.sllist([iterable]) Devuelve una nueva lista enlazada individualmente inicializada con elementos de iterable . Si no se especifica iterable, el nuevo sllist está vacío.

Se define un conjunto similar de atributos y operaciones para este objeto sllist . Vea esta referencia para más información.

Answer 2

Al usar listas vinculadas inmutables, considere usar la tupla de Python directamente.

ls = (1, 2, 3, 4, 5)
def first(ls): return ls[0]
def rest(ls): return ls[1:]

Es realmente así de fácil, y puedes mantener los funcitons adicionales como len (ls), x en ls, etc.

Answer 3

Antes que nada, supongo que quieres listas vinculadas. En la práctica, puede usar collections.deque , cuya implementación actual de CPython es una lista de bloques doblemente enlazada (cada bloque contiene una matriz de 62 objetos de carga). Incluye la funcionalidad de la lista vinculada. También puede buscar una extensión C llamada llist en pypi. Si desea una implementación pura de Python y fácil de seguir de la lista vinculada ADT, puede echar un vistazo a mi siguiente implementación mínima.

class Node (object):
""" Node for a linked list. """
def __init__ (self, value, next=None):
self.value = value
self.next = next
class LinkedList (object):
""" Linked list ADT implementation using class.
A linked list is a wrapper of a head pointer
that references either None, or a node that contains
a reference to a linked list.
"""
def __init__ (self, iterable=()):
self.head = None
for x in iterable:
self.head = Node(x, self.head)
def __iter__ (self):
p = self.head
while p is not None:
yield p.value
p = p.next
def prepend (self, x): # ''appendleft''
self.head = Node(x, self.head)
def reverse (self):
""" In-place reversal. """
p = self.head
self.head = None
while p is not None:
p0, p = p, p.next
p0.next = self.head
self.head = p0
if __name__ == ''__main__'':
ll = LinkedList([6,5,4])
ll.prepend(3); ll.prepend(2)
print list(ll)
ll.reverse()
print list(ll)

Answer 4

Aquí está mi implementación simple:

class Node:
def __init__(self):
self.data = None
self.next = None
def __str__(self):
return "Data %s: Next -> %s"%(self.data, self.next)
class LinkedList:
def __init__(self):
self.head = Node()
self.curNode = self.head
def insertNode(self, data):
node = Node()
node.data = data
node.next = None
if self.head.data == None:
self.head = node
self.curNode = node
else:
self.curNode.next = node
self.curNode = node
def printList(self):
print self.head
l = LinkedList()
l.insertNode(1)
l.insertNode(2)
l.insertNode(34)

Salida:

Data 1: Next -> Data 2: Next -> Data 34: Next -> Data 4: Next -> None

Answer 5

Aquí está mi solución:

Implementación

class Node:
def __init__(self, initdata):
self.data = initdata
self.next = None
def get_data(self):
return self.data
def set_data(self, data):
self.data = data
def get_next(self):
return self.next
def set_next(self, node):
self.next = node
# ------------------------ Link List class ------------------------------- #
class LinkList:
def __init__(self):
self.head = None
def is_empty(self):
return self.head == None
def traversal(self, data=None):
node = self.head
index = 0
found = False
while node is not None and not found:
if node.get_data() == data:
found = True
else:
node = node.get_next()
index += 1
return (node, index)
def size(self):
_, count = self.traversal(None)
return count
def search(self, data):
node, _ = self.traversal(data)
return node
def add(self, data):
node = Node(data)
node.set_next(self.head)
self.head = node
def remove(self, data):
previous_node = None
current_node = self.head
found = False
while current_node is not None and not found:
if current_node.get_data() == data:
found = True
if previous_node:
previous_node.set_next(current_node.get_next())
else:
self.head = current_node
else:
previous_node = current_node
current_node = current_node.get_next()
return found

Uso

link_list = LinkList()
link_list.add(10)
link_list.add(20)
link_list.add(30)
link_list.add(40)
link_list.add(50)
link_list.size()
link_list.search(30)
link_list.remove(20)

Idea original de implementación

http://interactivepython.org/runestone/static/pythonds/BasicDS/ImplementinganUnorderedListLinkedLists.html

Answer 6

Aquí hay algunas funciones de lista basadas en la representación de Martin v. Löwis :

cons = lambda el, lst: (el, lst)
mklist = lambda *args: reduce(lambda lst, el: cons(el, lst), reversed(args), None)
car = lambda lst: lst[0] if lst else lst
cdr = lambda lst: lst[1] if lst else lst
nth = lambda n, lst: nth(n-1, cdr(lst)) if n > 0 else car(lst)
length = lambda lst, count=0: length(cdr(lst), count+1) if lst else count
begin = lambda *args: args[-1]
display = lambda lst: begin(w("%s " % car(lst)), display(cdr(lst))) if lst else w("nil/n")

donde w = sys.stdout.write

Aunque las listas doblemente vinculadas son famosas en la receta del conjunto ordenado de Raymond Hettinger, las listas individuales no tienen ningún valor práctico en Python.

Nunca utilicé una lista enlazada por separado en Python para ningún problema excepto educativo.

Thomas Watnedal suggested un buen recurso educativo Cómo pensar como un informático, Capítulo 17: Listas enlazadas :

Una lista enlazada es:

• la lista vacía, representada por Ninguna, o

• un nodo que contiene un objeto de carga y una referencia a una lista vinculada.

  class Node:
  def __init__(self, cargo=None, next=None):
  self.car = cargo
  self.cdr = next
  def __str__(self):
  return str(self.car)
  def display(lst):
  if lst:
  w("%s " % lst)
  display(lst.cdr)
  else:
  w("nil/n")

Answer 7

Aquí hay una versión un poco más compleja de una clase de lista enlazada, con una interfaz similar a los tipos de secuencia de python (es decir, admite indización, división, concatenación con secuencias arbitrarias, etc.). Debería tener O (1) anteponer, no copia los datos a menos que sea necesario y pueda usarse de forma bastante intercambiable con las tuplas.

No será tan eficiente en espacio y tiempo como las celdas de ceceo, ya que las clases de pitón obviamente son un poco más pesadas (podrías mejorar un poco con " __slots__ = ''_head'',''_tail'' " para reducir el uso de memoria). Sin embargo, tendrá las características deseadas de alto rendimiento O.

Ejemplo de uso:

>>> l = LinkedList([1,2,3,4])
>>> l
LinkedList([1, 2, 3, 4])
>>> l.head, l.tail
(1, LinkedList([2, 3, 4]))
# Prepending is O(1) and can be done with:
LinkedList.cons(0, l)
LinkedList([0, 1, 2, 3, 4])
# Or prepending arbitrary sequences (Still no copy of l performed):
[-1,0] + l
LinkedList([-1, 0, 1, 2, 3, 4])
# Normal list indexing and slice operations can be performed.
# Again, no copy is made unless needed.
>>> l[1], l[-1], l[2:]
(2, 4, LinkedList([3, 4]))
>>> assert l[2:] is l.next.next
# For cases where the slice stops before the end, or uses a
# non-contiguous range, we do need to create a copy. However
# this should be transparent to the user.
>>> LinkedList(range(100))[-10::2]
LinkedList([90, 92, 94, 96, 98])

Implementación:

import itertools
class LinkedList(object):
"""Immutable linked list class."""
def __new__(cls, l=[]):
if isinstance(l, LinkedList): return l # Immutable, so no copy needed.
i = iter(l)
try:
head = i.next()
except StopIteration:
return cls.EmptyList # Return empty list singleton.
tail = LinkedList(i)
obj = super(LinkedList, cls).__new__(cls)
obj._head = head
obj._tail = tail
return obj
@classmethod
def cons(cls, head, tail):
ll = cls([head])
if not isinstance(tail, cls):
tail = cls(tail)
ll._tail = tail
return ll
# head and tail are not modifiable
@property
def head(self): return self._head
@property
def tail(self): return self._tail
def __nonzero__(self): return True
def __len__(self):
return sum(1 for _ in self)
def __add__(self, other):
other = LinkedList(other)
if not self: return other # () + l = l
start=l = LinkedList(iter(self)) # Create copy, as we''ll mutate
while l:
if not l._tail: # Last element?
l._tail = other
break
l = l._tail
return start
def __radd__(self, other):
return LinkedList(other) + self
def __iter__(self):
x=self
while x:
yield x.head
x=x.tail
def __getitem__(self, idx):
"""Get item at specified index"""
if isinstance(idx, slice):
# Special case: Avoid constructing a new list, or performing O(n) length
# calculation for slices like l[3:]. Since we''re immutable, just return
# the appropriate node. This becomes O(start) rather than O(n).
# We can''t do this for more complicated slices however (eg [l:4]
start = idx.start or 0
if (start >= 0) and (idx.stop is None) and (idx.step is None or idx.step == 1):
no_copy_needed=True
else:
length = len(self) # Need to calc length.
start, stop, step = idx.indices(length)
no_copy_needed = (stop == length) and (step == 1)
if no_copy_needed:
l = self
for i in range(start):
if not l: break # End of list.
l=l.tail
return l
else:
# We need to construct a new list.
if step < 1: # Need to instantiate list to deal with -ve step
return LinkedList(list(self)[start:stop:step])
else:
return LinkedList(itertools.islice(iter(self), start, stop, step))
else:
# Non-slice index.
if idx < 0: idx = len(self)+idx
if not self: raise IndexError("list index out of range")
if idx == 0: return self.head
return self.tail[idx-1]
def __mul__(self, n):
if n <= 0: return Nil
l=self
for i in range(n-1): l += self
return l
def __rmul__(self, n): return self * n
# Ideally we should compute the has ourselves rather than construct
# a temporary tuple as below. I haven''t impemented this here
def __hash__(self): return hash(tuple(self))
def __eq__(self, other): return self._cmp(other) == 0
def __ne__(self, other): return not self == other
def __lt__(self, other): return self._cmp(other) < 0
def __gt__(self, other): return self._cmp(other) > 0
def __le__(self, other): return self._cmp(other) <= 0
def __ge__(self, other): return self._cmp(other) >= 0
def _cmp(self, other):
"""Acts as cmp(): -1 for self<other, 0 for equal, 1 for greater"""
if not isinstance(other, LinkedList):
return cmp(LinkedList,type(other)) # Arbitrary ordering.
A, B = iter(self), iter(other)
for a,b in itertools.izip(A,B):
if a<b: return -1
elif a > b: return 1
try:
A.next()
return 1 # a has more items.
except StopIteration: pass
try:
B.next()
return -1 # b has more items.
except StopIteration: pass
return 0 # Lists are equal
def __repr__(self):
return "LinkedList([%s])" % '', ''.join(map(repr,self))
class EmptyList(LinkedList):
"""A singleton representing an empty list."""
def __new__(cls):
return object.__new__(cls)
def __iter__(self): return iter([])
def __nonzero__(self): return False
@property
def head(self): raise IndexError("End of list")
@property
def tail(self): raise IndexError("End of list")
# Create EmptyList singleton
LinkedList.EmptyList = EmptyList()
del EmptyList

Answer 8

Creo que la implementación a continuación completa el proyecto de ley con bastante gracia.

''''''singly linked lists, by Yingjie Lan, December 1st, 2011''''''
class linkst:
''''''Singly linked list, with pythonic features.
The list has pointers to both the first and the last node.''''''
__slots__ = [''data'', ''next''] #memory efficient
def __init__(self, iterable=(), data=None, next=None):
''''''Provide an iterable to make a singly linked list.
Set iterable to None to make a data node for internal use.''''''
if iterable is not None:
self.data, self.next = self, None
self.extend(iterable)
else: #a common node
self.data, self.next = data, next
def empty(self):
''''''test if the list is empty''''''
return self.next is None
def append(self, data):
''''''append to the end of list.''''''
last = self.data
self.data = last.next = linkst(None, data)
#self.data = last.next
def insert(self, data, index=0):
''''''insert data before index.
Raise IndexError if index is out of range''''''
curr, cat = self, 0
while cat < index and curr:
curr, cat = curr.next, cat+1
if index<0 or not curr:
raise IndexError(index)
new = linkst(None, data, curr.next)
if curr.next is None: self.data = new
curr.next = new
def reverse(self):
''''''reverse the order of list in place''''''
current, prev = self.next, None
while current: #what if list is empty?
next = current.next
current.next = prev
prev, current = current, next
if self.next: self.data = self.next
self.next = prev
def delete(self, index=0):
''''''remvoe the item at index from the list''''''
curr, cat = self, 0
while cat < index and curr.next:
curr, cat = curr.next, cat+1
if index<0 or not curr.next:
raise IndexError(index)
curr.next = curr.next.next
if curr.next is None: #tail
self.data = curr #current == self?
def remove(self, data):
''''''remove first occurrence of data.
Raises ValueError if the data is not present.''''''
current = self
while current.next: #node to be examined
if data == current.next.data: break
current = current.next #move on
else: raise ValueError(data)
current.next = current.next.next
if current.next is None: #tail
self.data = current #current == self?
def __contains__(self, data):
''''''membership test using keyword ''in''.''''''
current = self.next
while current:
if data == current.data:
return True
current = current.next
return False
def __iter__(self):
''''''iterate through list by for-statements.
return an iterator that must define the __next__ method.''''''
itr = linkst()
itr.next = self.next
return itr #invariance: itr.data == itr
def __next__(self):
''''''the for-statement depends on this method
to provide items one by one in the list.
return the next data, and move on.''''''
#the invariance is checked so that a linked list
#will not be mistakenly iterated over
if self.data is not self or self.next is None:
raise StopIteration()
next = self.next
self.next = next.next
return next.data
def __repr__(self):
''''''string representation of the list''''''
return ''linkst(%r)''%list(self)
def __str__(self):
''''''converting the list to a string''''''
return ''->''.join(str(i) for i in self)
#note: this is NOT the class lab! see file linked.py.
def extend(self, iterable):
''''''takes an iterable, and append all items in the iterable
to the end of the list self.''''''
last = self.data
for i in iterable:
last.next = linkst(None, i)
last = last.next
self.data = last
def index(self, data):
''''''TODO: return first index of data in the list self.
Raises ValueError if the value is not present.''''''
#must not convert self to a tuple or any other containers
current, idx = self.next, 0
while current:
if current.data == data: return idx
current, idx = current.next, idx+1
raise ValueError(data)

Answer 9

Escribí esto el otro día

#! /usr/bin/env python
class node:
def __init__(self):
self.data = None # contains the data
self.next = None # contains the reference to the next node
class linked_list:
def __init__(self):
self.cur_node = None
def add_node(self, data):
new_node = node() # create a new node
new_node.data = data
new_node.next = self.cur_node # link the new node to the ''previous'' node.
self.cur_node = new_node # set the current node to the new one.
def list_print(self):
node = self.cur_node # cant point to ll!
while node:
print node.data
node = node.next
ll = linked_list()
ll.add_node(1)
ll.add_node(2)
ll.add_node(3)
ll.list_print()

Answer 10

La respuesta aceptada es bastante complicada. Aquí hay un diseño más estándar:

L = LinkedList()
L.insert(1)
L.insert(1)
L.insert(2)
L.insert(4)
print L
L.clear()
print L

Es una clase LinkedList simple basada en el diseño sencillo de C ++ y el Capítulo 17: Listas enlazadas , según lo recomendado por Thomas Watnedal .

class Node:
def __init__(self, value = None, next = None):
self.value = value
self.next = next
def __str__(self):
return ''Node [''+str(self.value)+'']''
class LinkedList:
def __init__(self):
self.first = None
self.last = None
def insert(self, x):
if self.first == None:
self.first = Node(x, None)
self.last = self.first
elif self.last == self.first:
self.last = Node(x, None)
self.first.next = self.last
else:
current = Node(x, None)
self.last.next = current
self.last = current
def __str__(self):
if self.first != None:
current = self.first
out = ''LinkedList [/n'' +str(current.value) +''/n''
while current.next != None:
current = current.next
out += str(current.value) + ''/n''
return out + '']''
return ''LinkedList []''
def clear(self):
self.__init__()

Answer 11

Las listas inmutables se representan mejor a través de dos tuplas, con None representando NIL. Para permitir la formulación simple de tales listas, puede usar esta función:

def mklist(*args):
result = None
for element in reversed(args):
result = (element, result)
return result

Para trabajar con tales listas, prefiero proporcionar toda la colección de funciones LISP (es decir, primero, segundo, enésimo, etc.), que introducir métodos.

Answer 12

Lo hice como un juguete divertido. Debe ser inmutable siempre que no toque los métodos con guiones bajos, y que implemente una gran cantidad de magia de Python como indización y len .

Answer 13

Lo siguiente es lo que se me ocurrió. Es similar a Riccardo C. , en este hilo, excepto que imprime los números en orden en lugar de hacerlo a la inversa. También hice del objeto LinkedList un Python Iterator para imprimir la lista como lo haría con una lista normal de Python.

class Node:
def __init__(self, data=None):
self.data = data
self.next = None
def __str__(self):
return str(self.data)
class LinkedList:
def __init__(self):
self.head = None
self.curr = None
self.tail = None
def __iter__(self):
return self
def next(self):
if self.head and not self.curr:
self.curr = self.head
return self.curr
elif self.curr.next:
self.curr = self.curr.next
return self.curr
else:
raise StopIteration
def append(self, data):
n = Node(data)
if not self.head:
self.head = n
self.tail = n
else:
self.tail.next = n
self.tail = self.tail.next
# Add 5 nodes
ll = LinkedList()
for i in range(1, 6):
ll.append(i)
# print out the list
for n in ll:
print n
"""
Example output:
$ python linked_list.py
1
2
3
4
5
"""

Answer 14

Para algunas necesidades, una deque también puede ser útil. Puede agregar y eliminar elementos en ambos extremos de un deque con un costo O (1).

from collections import deque
d = deque([1,2,3,4])
print d
for x in d:
print x
print d.pop(), d

Answer 15

Puse una clase de lista de enlaces individuales de Python 2.xy 3.x en https://pypi.python.org/pypi/linked_list_mod/

Se prueba con CPython 2.7, CPython 3.4, Pypy 2.3.1, Pypy3 2.3.1 y Jython 2.7b2, y viene con un buen conjunto de pruebas automatizadas.

También incluye clases LIFO y FIFO.

Aunque no son inmutables.

Answer 16

esta función adicional en

def add_node_at_end(self, data):
new_node = Node()
node = self.curr_node
while node:
if node.next == None:
node.next = new_node
new_node.next = None
new_node.data = data
node = node.next

El método que tiene agrega el nuevo nodo al principio, mientras que he visto muchas implementaciones que generalmente agregan un nuevo nodo al final, pero sea lo que sea, es divertido de hacer.

Answer 17

Clase de lista enlazada

class LinkedStack:
# Nested Node Class
class Node:
def __init__(self, element, next):
self.__element = element
self.__next = next
def get_next(self):
return self.__next
def get_element(self):
return self.__element
def __init__(self):
self.head = None
self.size = 0
self.data = []
def __len__(self):
return self.size
def __str__(self):
return str(self.data)
def is_empty(self):
return self.size == 0
def push(self, e):
newest = self.Node(e, self.head)
self.head = newest
self.size += 1
self.data.append(newest)
def top(self):
if self.is_empty():
raise Empty(''Stack is empty'')
return self.head.__element
def pop(self):
if self.is_empty():
raise Empty(''Stack is empty'')
answer = self.head.element
self.head = self.head.next
self.size -= 1
return answer

Uso

from LinkedStack import LinkedStack
x = LinkedStack()
x.push(10)
x.push(25)
x.push(55)
for i in range(x.size - 1, -1, -1):
print ''|'', x.data[i].get_element(), ''|'' ,
#next object
if x.data[i].get_next() == None:
print ''--> None''
else:
print x.data[i].get_next().get_element(), ''-|----> '',

Salida

| 55 | 25 -|----> | 25 | 10 -|----> | 10 | --> None

Answer 18

Sample of a doubly linked list (save as linkedlist.py):

class node:
def __init__(self, before=None, cargo=None, next=None):
self._previous = before
self._cargo = cargo
self._next = next
def __str__(self):
return str(self._cargo) or None
class linkedList:
def __init__(self):
self._head = None
self._length = 0
def add(self, cargo):
n = node(None, cargo, self._head)
if self._head:
self._head._previous = n
self._head = n
self._length += 1
def search(self,cargo):
node = self._head
while (node and node._cargo != cargo):
node = node._next
return node
def delete(self,cargo):
node = self.search(cargo)
if node:
prev = node._previous
nx = node._next
if prev:
prev._next = node._next
else:
self._head = nx
nx._previous = None
if nx:
nx._previous = prev
else:
prev._next = None
self._length -= 1
def __str__(self):
print ''Size of linked list: '',self._length
node = self._head
while node:
print node
node = node._next

Testing (save as test.py):

from linkedlist import node, linkedList
def test():
print ''Testing Linked List''
l = linkedList()
l.add(10)
l.add(20)
l.add(30)
l.add(40)
l.add(50)
l.add(60)
print ''Linked List after insert nodes:''
l.__str__()
print ''Search some value, 30:''
node = l.search(30)
print node
print ''Delete some value, 30:''
node = l.delete(30)
l.__str__()
print ''Delete first element, 60:''
node = l.delete(60)
l.__str__()
print ''Delete last element, 10:''
node = l.delete(10)
l.__str__()
if __name__ == "__main__":
test()

Output :

Testing Linked List
Linked List after insert nodes:
Size of linked list: 6
60
50
40
30
20
10
Search some value, 30:
30
Delete some value, 30:
Size of linked list: 5
60
50
40
20
10
Delete first element, 60:
Size of linked list: 4
50
40
20
10
Delete last element, 10:
Size of linked list: 3
50
40
20

Answer 19

If you want to just create a simple liked list then refer this code

l=[1,[2,[3,[4,[5,[6,[7,[8,[9,[10]]]]]]]]]]

para visualizar la ejecución de este bacalao Visita http://www.pythontutor.com/visualize.html#mode=edit

Answer 20

My 2 cents

class Node:
def __init__(self, value=None, next=None):
self.value = value
self.next = next
def __str__(self):
return str(self.value)
class LinkedList:
def __init__(self):
self.first = None
self.last = None
def add(self, x):
current = Node(x, None)
try:
self.last.next = current
except AttributeError:
self.first = current
self.last = current
else:
self.last = current
def print_list(self):
node = self.first
while node:
print node.value
node = node.next
ll = LinkedList()
ll.add("1st")
ll.add("2nd")
ll.add("3rd")
ll.add("4th")
ll.add("5th")
ll.print_list()
# Result:
# 1st
# 2nd
# 3rd
# 4th
# 5th

Answer 21

my double Linked List might be understandable to noobies.. If ur familiar with DS in C, this is quite readable.

# LinkedList..
class node:
def __init__(self): //Cluster of Nodes'' properties
self.data=None
self.next=None
self.prev=None
class linkedList():
def __init__(self):
self.t = node() // for future use
self.cur_node = node() // current node
self.start=node()
def add(self,data): // appending the LL
self.new_node = node()
self.new_node.data=data
if self.cur_node.data is None:
self.start=self.new_node //For the 1st node only
self.cur_node.next=self.new_node
self.new_node.prev=self.cur_node
self.cur_node=self.new_node
def backward_display(self): //Displays LL backwards
self.t=self.cur_node
while self.t.data is not None:
print(self.t.data)
self.t=self.t.prev
def forward_display(self): //Displays LL Forward
self.t=self.start
while self.t.data is not None:
print(self.t.data)
self.t=self.t.next
if self.t.next is None:
print(self.t.data)
break
def main(self): //This is kind of the main
function in C
ch=0
while ch is not 4: //Switch-case in C
ch=int(input("Enter your choice:"))
if ch is 1:
data=int(input("Enter data to be added:"))
ll.add(data)
ll.main()
elif ch is 2:
ll.forward_display()
ll.main()
elif ch is 3:
ll.backward_display()
ll.main()
else:
print("Program ends!!")
return
ll=linkedList()
ll.main()

Though many more simplifications can be added to this code, I thought a raw implementation would me more grabbable.

Answer 22

class LL(object):
def __init__(self,val):
self.val = val
self.next = None
def pushNodeEnd(self,top,val):
if top is None:
top.val=val
top.next=None
else:
tmp=top
while (tmp.next != None):
tmp=tmp.next
newNode=LL(val)
newNode.next=None
tmp.next=newNode
def pushNodeFront(self,top,val):
if top is None:
top.val=val
top.next=None
else:
newNode=LL(val)
newNode.next=top
top=newNode
def popNodeFront(self,top):
if top is None:
return
else:
sav=top
top=top.next
return sav
def popNodeEnd(self,top):
if top is None:
return
else:
tmp=top
while (tmp.next != None):
prev=tmp
tmp=tmp.next
prev.next=None
return tmp
top=LL(10)
top.pushNodeEnd(top, 20)
top.pushNodeEnd(top, 30)
pop=top.popNodeEnd(top)
print (pop.val)

Answer 23

class LinkedList:
def __init__(self, value):
self.value = value
self.next = None
def insert(self, node):
if not self.next:
self.next = node
else:
self.next.insert(node)
def __str__(self):
if self.next:
return ''%s -> %s'' % (self.value, str(self.next))
else:
return '' %s '' % self.value
if __name__ == "__main__":
items = [''a'', ''b'', ''c'', ''d'', ''e'']
ll = None
for item in items:
if ll:
next_ll = LinkedList(item)
ll.insert(next_ll)
else:
ll = LinkedList(item)
print(''[ %s ]'' % ll)

Answer 24

class LinkedStack:
''''''LIFO Stack implementation using a singly linked list for storage.''''''
_ToList = []
#---------- nested _Node class -----------------------------
class _Node:
''''''Lightweight, nonpublic class for storing a singly linked node.''''''
__slots__ = ''_element'', ''_next'' #streamline memory usage
def __init__(self, element, next):
self._element = element
self._next = next
#--------------- stack methods ---------------------------------
def __init__(self):
''''''Create an empty stack.''''''
self._head = None
self._size = 0
def __len__(self):
''''''Return the number of elements in the stack.''''''
return self._size
def IsEmpty(self):
''''''Return True if the stack is empty''''''
return self._size == 0
def Push(self,e):
''''''Add element e to the top of the Stack.''''''
self._head = self._Node(e, self._head) #create and link a new node
self._size +=1
self._ToList.append(e)
def Top(self):
''''''Return (but do not remove) the element at the top of the stack.
Raise exception if the stack is empty
''''''
if self.IsEmpty():
raise Exception(''Stack is empty'')
return self._head._element #top of stack is at head of list
def Pop(self):
''''''Remove and return the element from the top of the stack (i.e. LIFO).
Raise exception if the stack is empty
''''''
if self.IsEmpty():
raise Exception(''Stack is empty'')
answer = self._head._element
self._head = self._head._next #bypass the former top node
self._size -=1
self._ToList.remove(answer)
return answer
def Count(self):
''''''Return how many nodes the stack has''''''
return self.__len__()
def Clear(self):
''''''Delete all nodes''''''
for i in range(self.Count()):
self.Pop()
def ToList(self):
return self._ToList

Answer 25

class Node(object):
def __init__(self, data=None, next=None):
self.data = data
self.next = next
def setData(self, data):
self.data = data
return self.data
def setNext(self, next):
self.next = next
def getNext(self):
return self.next
def hasNext(self):
return self.next != None
class singleLinkList(object):
def __init__(self):
self.head = None
def isEmpty(self):
return self.head == None
def insertAtBeginning(self, data):
newNode = Node()
newNode.setData(data)
if self.listLength() == 0:
self.head = newNode
else:
newNode.setNext(self.head)
self.head = newNode
def insertAtEnd(self, data):
newNode = Node()
newNode.setData(data)
current = self.head
while current.getNext() != None:
current = current.getNext()
current.setNext(newNode)
def listLength(self):
current = self.head
count = 0
while current != None:
count += 1
current = current.getNext()
return count
def print_llist(self):
current = self.head
print("List Start.")
while current != None:
print(current.getData())
current = current.getNext()
print("List End.")
if __name__ == ''__main__'':
ll = singleLinkList()
ll.insertAtBeginning(55)
ll.insertAtEnd(56)
ll.print_llist()
print(ll.listLength())

Answer 26

enter code here
enter code here
class node:
def __init__(self):
self.data = None
self.next = None
class linked_list:
def __init__(self):
self.cur_node = None
self.head = None
def add_node(self,data):
new_node = node()
if self.head == None:
self.head = new_node
self.cur_node = new_node
new_node.data = data
new_node.next = None
self.cur_node.next = new_node
self.cur_node = new_node
def list_print(self):
node = self.head
while node:
print (node.data)
node = node.next
def delete(self):
node = self.head
next_node = node.next
del(node)
self.head = next_node
a = linked_list()
a.add_node(1)
a.add_node(2)
a.add_node(3)
a.add_node(4)
a.delete()
a.list_print()