পাইথন লিঙ্কযুক্ত তালিকা


178

পাইথনে লিঙ্কযুক্ত তালিকাটি ব্যবহারের সবচেয়ে সহজ উপায় কী? স্কিমে, একটি লিঙ্কযুক্ত তালিকা কেবলমাত্র দ্বারা সংজ্ঞায়িত করা হয় '(1 2 3 4 5)। পাইথনের তালিকাগুলি [1, 2, 3, 4, 5]এবং টিপলস, (1, 2, 3, 4, 5)আসলে লিঙ্কযুক্ত তালিকাগুলি এবং লিঙ্কযুক্ত তালিকাগুলিতে কিছু দুর্দান্ত বৈশিষ্ট্য যেমন ধ্রুবক-সময় কনকনেটেশন এবং সেগুলির পৃথক অংশগুলি উল্লেখ করতে সক্ষম। এগুলি অপরিবর্তনীয় করে দিন এবং এগুলি নিয়ে কাজ করা সত্যই সহজ!


11
এটি আপনাকে এটি কল্পনা করতে সহায়তা করতে পারে .. pythontutor.com/…

উত্তর:


69

মার্টিন বনাম লুইসের উপস্থাপনার উপর ভিত্তি করে এখানে কিছু তালিকা ফাংশন রয়েছে :

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")

কোথায় w = sys.stdout.write

যদিও দ্বিগুণ সংযুক্ত তালিকাগুলি বিখ্যাতভাবে রেমন্ড হেট্টিংজারের আদেশকৃত রেসিপিটিতে ব্যবহৃত হয় , তবে এককভাবে সংযুক্ত তালিকার পাইথনের কোনও ব্যবহারিক মূল্য নেই।

শিক্ষা ব্যতীত অন্য কোন সমস্যার জন্য আমি পাইথনে এককভাবে সংযুক্ত তালিকাটি কখনও ব্যবহার করি নি

টমাস ওয়াটনেডাল একটি ভাল শিক্ষামূলক সংস্থার পরামর্শ দিয়েছিলেন যে কীভাবে কম্পিউটার বিজ্ঞানীর মতো চিন্তা করতে হবে, অধ্যায় 17: লিঙ্কযুক্ত তালিকাগুলি :

একটি লিঙ্কযুক্ত তালিকা হয়:

  • খালি তালিকা, কোনটি দ্বারা প্রতিনিধিত্ব করা, বা
  • একটি নোড যা একটি কার্গো অবজেক্ট এবং একটি লিঙ্কযুক্ত তালিকার একটি রেফারেন্স ধারণ করে।

    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")

30
আপনি বলেছেন: আপনি পাইথনে এককভাবে লিঙ্কযুক্ত তালিকাটি শিক্ষাগত ব্যতীত অন্য কোনও সমস্যার জন্য ব্যবহার করেন নি। এটি আপনার জন্য ভাল :-) তবে আমি আপনাকে আশ্বস্ত করতে পারি: বাস্তব বিশ্বে এমন সমস্যা রয়েছে যেখানে একটি লিঙ্কযুক্ত তালিকা একটি আদর্শ সমাধান সরবরাহ করবে :-) এই কারণেই আমি লিঙ্কযুক্ত তালিকার জন্য স্ট্যাকওভারফ্লোটিকে প্রথম স্থানে স্ক্যান করেছি :-)
রেজিস মে

8
@ রিগিসমায়: আপনি একটি নির্দিষ্ট ব্যবহারিক কোড উদাহরণের একটি লিঙ্ক সরবরাহ করতে আপত্তি করবেন? (দ্রষ্টব্য: এটি "পাইথনের এককভাবে সংযুক্ত তালিকা হওয়া উচিত" "সত্যিকারের বিশ্বে": উদাহরণস্বরূপ, পাঠযোগ্যতা, পারফরম্যান্স বা আপনার নির্বাচনের অন্যান্য "ব্যবহারিক মান") এর উপকারিতা বর্ণনা করুন)। আমি অতীতেও অনুরূপ অনুরোধ করেছি: 8 বছরে, রেমন্ড হেট্টিংারের আদেশকৃত সেট রেসিপিটিতে ব্যবহৃত দ্বিগুণ সংযুক্ত তালিকাগুলি ব্যতীত শূন্য লিঙ্কগুলি - সম্ভবত, এটি ব্যাখ্যা করা যেতে পারে যে পাইথনে নতুন প্রোগ্রামাররা এই প্রশ্নটি পড়ে - আপনার ইনপুট মূল্যবান এবং অত্যন্ত প্রশংসা করা হবে।
jfs

3
ওহ দুঃখিত. আমি নেটিভ ইংরেজী স্পিকার নই এবং "একটি একক সংযুক্ত তালিকার সাথে" "একটি একক সংযুক্ত তালিকাকে" বিভ্রান্ত করছি। তবুও আমার একটি (ডাবল) লিঙ্কযুক্ত তালিকা প্রয়োজন - যা পাইথনের মধ্যে নেই। সমস্ত উপাদানগুলির পুনরাবৃত্তি না করে আমার প্রতিটি একক উপাদানের সরাসরি অ্যাক্সেসের প্রয়োজন হিসাবে একটি ডিউক সাহায্য করে না। আমার লক্ষ্য: আমি একটি ক্যাশে বাস্তবায়ন করতে চাই। তবুও: যদি ইংরেজি ভাষায় আমার অপূর্ণতা আমার মন্তব্যগুলি স্থানের বাইরে করে দেয় তবে দয়া করে এই মন্তব্যগুলি মুছুন। কোন অসুবিধার জন্য দুঃখিত.
রেগিস মে

5
দ্বিগুণ সংযুক্ত তালিকাগুলি বা অ্যারেগুলির (যা পাইথন অভ্যন্তরীণভাবে তালিকার জন্য ব্যবহার করে) এককভাবে সংযুক্ত তালিকার একটি ব্যবহারিক সুবিধা হ'ল দুটি লিঙ্কযুক্ত তালিকাগুলি একটি লেজ ভাগ করতে পারে। এটি গতিশীল অ্যালগরিদমের জন্য খুব দরকারী যেখানে পূর্ববর্তী পুনরাবৃত্তির থেকে সংরক্ষণের মানগুলির প্রয়োজন হয় যেখানে ভাগ করে নেওয়ার তালিকাগুলি মেমরির জটিলতাটিকে চতুর্ভুজ থেকে লিনিয়ারে হ্রাস করতে পারে এবং অনুলিপির কারণে টাইম ওভারহেড নির্মূল করতে পারে।
সালোফ

3
যে rosettacode লিংক ছিল একটি বাস্তব জগতে উদাহরণ, যা একটি প্রকৃত যুক্ত তালিকা স্থানে একটি কৃত্রিম যুক্ত তালিকা ব্যবহার করে। এটি একবার দেখুন, উন্নত স্পষ্টতা এবং পঠনযোগ্যতার জন্য প্রকৃত সংযুক্ত তালিকাটি ব্যবহার করতে এটি পুনরায় লিখুন, এবং বিদ্যমান কোডটি উন্নত করার জন্য কোনও লিঙ্কযুক্ত তালিকার ব্যবহারের সত্যিকারের বিশ্ব উদাহরণ রয়েছে। এবং দ্বিতীয়ত, দীর্ঘতম ক্রমবর্ধমান ধারাবাহিক অ্যালগরিদম বাস্তব বিশ্বে, পরিসংখ্যানগুলিতে ব্যবহৃত হয়, সুতরাং আপনার এটি রয়েছে। কিউইডি :)। এর বাইরে, আসুন আমরা একমত হতে সম্মত হই। :)
জিনো

158

কিছু প্রয়োজনের জন্য, একটি deque এছাড়াও দরকারী হতে পারে। আপনি ও (1) মূল্যে কোনও ডীকের উভয় প্রান্তে আইটেমগুলি যুক্ত করতে এবং সরাতে পারেন।

from collections import deque
d = deque([1,2,3,4])

print d
for x in d:
    print x
print d.pop(), d

16
যদিও dequeএটি একটি দরকারী ডেটা ধরণের, এটি কোনও লিঙ্কযুক্ত তালিকা নয় (যদিও এটি সি স্তরে দ্বিগুণ লিঙ্কযুক্ত তালিকা ব্যবহার করে প্রয়োগ করা হয়)। সুতরাং এটি প্রশ্নের উত্তর দেয় " পাইথনের লিঙ্কযুক্ত তালিকার পরিবর্তে আপনি কী ব্যবহার করবেন ?" এবং সেক্ষেত্রে প্রথম উত্তরটি (কিছু প্রয়োজনের জন্য) একটি সাধারণ পাইথন তালিকা হওয়া উচিত (এটি কোনও লিঙ্কযুক্ত তালিকাও নয়)।
jfs

3
@ জেফাসেবাস্টিয়ান: আমি আপনার সাথে প্রায় একমত হয়েছি :) আমি মনে করি এই প্রশ্নের উত্তরটির চেয়ে বরং এই প্রশ্নটি হয়েছে: "অন্যান্য ভাষায় লিঙ্কযুক্ত তালিকা ব্যবহার করে এমন সমস্যা সমাধানের অজগর উপায় কী" " এটি লিঙ্কযুক্ত তালিকাগুলি কার্যকর নয়, এটি কেবল এমন সমস্যা যেখানে কোনও ডীক কাজ করেন না খুব বিরল।
এমিল স্টেনস্ট্রোম

9
"পাইথোনিক" এর সাথে এর কোনও যোগসূত্র নেই: একটি লিঙ্কযুক্ত তালিকাগুলি একটি ডেকারের চেয়ে আলাদা ডেটা কাঠামো এবং বিভিন্ন ক্রিয়াকলাপ জুড়ে দুটি সমর্থন করে, তাদের চলমান সময় আলাদা have
থানাটোস

4
@ ডিমো 414: লিঙ্কযুক্ত তালিকাগুলি সাধারণত ইনডেক্সিং (না linked_list[n]) নিষিদ্ধ করে কারণ এটি ও (এন) হবে। ডীকগুলি এটির অনুমতি দেয় এবং ও (1) এ এটি সম্পাদন করে। তবে, লিঙ্কযুক্ত তালিকাগুলি, তালিকায় একটি পুনরাবৃত্তিকে দেওয়া, ও (1) সন্নিবেশ এবং অপসারণের অনুমতি দিতে পারে, যেখানে ডেকস (এটি ও (এন), ভেক্টরের মতো) করতে পারে না। (সামনে এবং শেষ, যেখানে উভয় deques এবং সংযুক্ত তালিকা উভয় হে (1 হয় এ ব্যতীত) (যদিও deque সম্ভবত হে amortized হয় (1) লিঙ্ক তালিকা
Thanatos

3
@ ম্যাডফিসিসিস্ট "নামটি ভিন্ন হলেও, এটি প্রায় প্রতিটি উপায়ে লিঙ্কযুক্ত তালিকার মতো আচরণ করে It" - এটি ভুল বা অর্থহীন: এটি ভুল কারণ সংযুক্ত তালিকাগুলি সময় জটিলতার জন্য বিভিন্ন গ্যারান্টি সরবরাহ করতে পারে উদাহরণস্বরূপ, আপনি ও (1) এর একটি লিঙ্কযুক্ত তালিকা থেকে একটি উপাদান (পরিচিত অবস্থান) সরিয়ে ফেলতে পারবেন যখন ডেক এটি প্রতিশ্রুতি দেয় না (এটি এটি) হয় O(n))। যদি "প্রায় প্রতিটি উপায়েই" বড় ও এর পার্থক্য উপেক্ষা করতে দেয় তবে আপনার বক্তব্য অর্থহীন কারণ আমরা পাইথন বিল্টিন তালিকাটি ডেক হিসাবে ব্যবহার করতে পারতাম যদি এটি পপ (0) না হয় তবে সন্নিবেশ (0, ভি) বড় হে গ্যারান্টি ।
jfs

69

আমি অন্য দিন এটি লিখেছিলাম

#! /usr/bin/env python

class Node(object):
    def __init__(self):
        self.data = None # contains the data
        self.next = None # contains the reference to the next node


class LinkedList:
    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 = LinkedList()
ll.add_node(1)
ll.add_node(2)
ll.add_node(3)

ll.list_print()

আপনি কীভাবে তালিকার মধ্য দিয়ে যেতে পারেন এবং নির্দিষ্ট ডেটা সহ একটি নির্দিষ্ট নোড অনুসন্ধান করতে পারবেন?
লোকোবয়

1
@ লকোবয় কোডটি করা কোডটির সাথে যুক্তির মতোই হবে list_print()
ডেনিস

বিপরীত ক্রমে তালিকাটি প্রদর্শন করে

35

গৃহীত উত্তর বরং জটিল। এখানে আরও মানক ডিজাইন দেওয়া হয়েছে:

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

এটি LinkedListসোজা সি ++ ডিজাইন এবং অধ্যায় 17: লিঙ্কযুক্ত তালিকার উপর ভিত্তি করে একটি সাধারণ শ্রেণি যা থমাস ওয়াটনেডালের প্রস্তাবিত ।

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__()

8
আমি এই উত্তর পছন্দ। এক রাতে, আমি বিশ্বাস করি যে এটির X is Noneচেয়ে বেশি পছন্দ হয়েছে ==stackoverflow.com/a/2988117/1740227
mateor

দ্বিতীয় শাখাটি কি insertতৃতীয়টির কোনও বিশেষ ক্ষেত্রে নয়, যাতে আপনি সম্পূর্ণরূপে elifধারাটি সরিয়ে ফেলতে পারেন ?
জেইমি

17

অপরিবর্তনীয় তালিকাগুলি দ্বি-টিউপলের মাধ্যমে সেরা প্রতিনিধিত্ব করা হয়, যার সাথে এনআইএল প্রতিনিধিত্ব করে না। এই জাতীয় তালিকাগুলির সহজ সূচনার অনুমতি দেওয়ার জন্য আপনি এই ফাংশনটি ব্যবহার করতে পারেন:

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

এই জাতীয় তালিকাগুলি নিয়ে কাজ করার জন্য, আমি পদ্ধতিগুলি প্রবর্তনের পরিবর্তে এলআইএসপি ফাংশনগুলির (যেমন প্রথম, দ্বিতীয়, নবম, ইত্যাদি) পুরো সংগ্রহ সরবরাহ করব।


13

পাইথনের সিকোয়েন্স টাইপের অনুরূপ ইন্টারফেস সহ লিংকযুক্ত তালিকার শ্রেণীর কিছুটা জটিল সংস্করণ এখানে রয়েছে (উদাহরণস্বরূপ, স্বেচ্ছাসেবক, স্লাইসিং, স্বেচ্ছাসেবী ক্রমগুলি সহ উপসংহার ইত্যাদি) supports এটিতে ও (1) প্রিপেন্ড করা উচিত, ডুপুলিগুলির সাথে ডানদিকে অনুলিপি ব্যবহার করার প্রয়োজন না থাকলে এটি অনুলিপি করে না।

এটি লিস্প কনস সেলগুলির মতো স্থান বা সময় দক্ষতার মতো হবে না, কারণ পাইথন ক্লাসগুলি স্পষ্টতই কিছুটা বেশি ভারী ওজনযুক্ত ( __slots__ = '_head','_tail'স্মৃতি ব্যবহার হ্রাস করতে আপনি " " কিছুটা সামান্য উন্নতি করতে পারেন )। এটিতে কাঙ্ক্ষিত বড় হে পারফরম্যান্স বৈশিষ্ট্য থাকবে।

ব্যবহারের উদাহরণ:

>>> 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])

বাস্তবায়ন:

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

আমার ধারণা এটি এত আশ্চর্যজনক নয়, তবে এই 8 বছরের পুরানো (!) উদাহরণটি অজগর 3 এর সাথে কাজ করে না :)
অ্যান্ডি হেডেন

1
জন্য ব্যাখ্যা প্রদান করুন নতুন এবং একটি মাত্র সামগ্রিক ব্যাখ্যা একটি বিট।
অনুকাল

7

তালিকাভুক্ত - পাইথনের জন্য লিঙ্কযুক্ত তালিকার ডেটাটাইপগুলি

তালিকাভুক্ত মডিউল লিঙ্কযুক্ত তালিকার ডেটা স্ট্রাকচার প্রয়োগ করে। এটি দ্বিগুণ লিঙ্কযুক্ত তালিকাকে, dllistএবং এককভাবে সংযুক্ত ডেটা কাঠামো সমর্থন করে sllist

dllist অবজেক্টস

এই অবজেক্টটি দ্বিগুণ লিঙ্কযুক্ত তালিকার ডেটা কাঠামোর প্রতিনিধিত্ব করে।

first

dllistnodeতালিকার প্রথম অবজেক্ট। Noneযদি তালিকাটি খালি থাকে।

last

dllistnodeতালিকার শেষ অবজেক্ট। তালিকা খালি থাকলে কিছুই নয়।

dllist অবজেক্টগুলি নিম্নলিখিত পদ্ধতিগুলি সমর্থন করে:

append(x)

xতালিকার ডানদিকে যুক্ত করুন এবং সন্নিবেশিত ফিরে আসুন dllistnode

appendleft(x)

যোগ xতালিকা এবং বিনিময়ে ঢোকানো বাম পাশ থেকে dllistnode

appendright(x)

xতালিকার ডানদিকে যুক্ত করুন এবং সন্নিবেশিত ফিরে আসুন dllistnode

clear()

তালিকা থেকে সমস্ত নোড সরান।

extend(iterable)

iterableতালিকার ডান দিক থেকে উপাদান যুক্ত করুন ।

extendleft(iterable)

iterableতালিকার বাম দিক থেকে উপাদান যুক্ত করুন ।

extendright(iterable)

iterableতালিকার ডান দিক থেকে উপাদান যুক্ত করুন ।

insert(x[, before])

যোগ xযদি তালিকার ডানদিকে beforeনির্দিষ্ট করা না থাকে, অথবা সন্নিবেশ xবাম পাশ থেকে dllistnode before। ফিরে sertedোকানো dllistnode

nodeat(index)

নোড (টাইপের dllistnode) এ ফিরে আসুন index

pop()

তালিকার ডান দিক থেকে কোনও উপাদানের মান সরিয়ে ফেরা এবং ফিরিয়ে দিন।

popleft()

তালিকার বাম দিক থেকে একটি উপাদানের মান সরিয়ে ফিরুন।

popright()

তালিকার ডান দিক থেকে কোনও উপাদানের মান সরিয়ে ফেরা এবং ফিরিয়ে দিন

remove(node)

nodeতালিকা থেকে সরান এবং এতে থাকা উপাদানটি ফিরিয়ে দিন।

dllistnode বস্তু

শ্রেণী llist.dllistnode([value])

নতুন দ্বিগুণভাবে সংযুক্ত তালিকার নোডটি ফিরিয়ে আনুন, এর সাথে ইনিশিয়ালড (allyচ্ছিকভাবে) value

dllistnode অবজেক্টগুলি নিম্নলিখিত বৈশিষ্ট্যগুলি সরবরাহ করে:

next

তালিকার পরবর্তী নোড এই বৈশিষ্ট্যটি কেবল পঠনযোগ্য।

prev

তালিকার আগের নোড। এই বৈশিষ্ট্যটি কেবল পঠনযোগ্য।

value

এই নোডে মান সঞ্চিত। এই রেফারেন্স থেকে সংকলিত

sllist

শ্রেণি llist.sllist([iterable]) থেকে উপাদানগুলির সাথে আরম্ভ করা একটি নতুন একক সংযুক্ত তালিকাটি ফেরত দিন iterable। যদি পুনরাবৃত্তিযোগ্য নির্দিষ্ট না করা থাকে তবে নতুনটি sllistখালি।

অনুরূপ বৈশিষ্ট্য এবং ক্রিয়াকলাপগুলির এই সেটটির জন্য সংজ্ঞায়িত করা হয় sllistআরও তথ্যের জন্য এই রেফারেন্স দেখুন।


এটির জন্য কি কোনও উত্স আছে? এটি অজগর 3 জন্য কাজ করে?
iggy12345

4
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())

2

আমি এই অতিরিক্ত ফাংশনটি নিক স্টিনিমেটসের উপর ভিত্তি করে তৈরি করেছি

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

শুরুতে তিনি যে পদ্ধতিটি নতুন নোড যুক্ত করেছেন আমি প্রচুর বাস্তবায়ন দেখেছি যা সাধারণত শেষে একটি নতুন নোড যুক্ত করে তবে যাই হোক না কেন এটি মজাদার।


2

নিম্নলিখিতটি আমি নিয়ে এসেছি। এটি এই থ্রেডে রিকার্ডো সি'র সিমিলার , এটি বিপরীত পরিবর্তে পরিবর্তিতভাবে সংখ্যাগুলি মুদ্রণ করে। আপনি লিংকডলিস্টকে একটি পাইথন আইট্রেটর তৈরি করেছিলাম যাতে আপনি সাধারণ পাইথন তালিকার মতো তালিকাটি মুদ্রণ করতে পারেন।

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
"""

দেখে মনে হচ্ছে স্টপআইটারেশন বাড়ানোর আগে একটি বাগ রয়েছে। আপনি যদি বর্তমান নোডটিকে কোনও রাজ্যের অভ্যন্তরীণ অংশ হিসাবে সংরক্ষণ করতে চলেছেন তবে পুনরাবৃত্তি বন্ধ করার আগে আপনাকে এটি পুনরায় সেট করতে হবে যাতে পরের বার সংযুক্ত তালিকাটি লুপ হয়ে যায়, এটি আপনার প্রথম ধারাটিতে প্রবেশ করবে।
টিম ওয়াইল্ডার

2

আমি ঠিক করেছিলাম এই একটি মজার খেলনা হিসাবে। এটি যতক্ষণ না আপনি আন্ডারস্কোর-উপসর্গযুক্ত পদ্ধতিগুলি স্পর্শ না করেন ততক্ষণ তা অপরিবর্তনীয় হওয়া উচিত এবং এটি সূচক এবং এর মতো একগুচ্ছ পাইথন ম্যাজিক প্রয়োগ করে len


1

অপরিবর্তনীয় লিঙ্কযুক্ত তালিকাগুলি ব্যবহার করার সময় পাইথনের টিপলটি সরাসরি ব্যবহার করার বিষয়টি বিবেচনা করুন।

ls = (1, 2, 3, 4, 5)

def first(ls): return ls[0]
def rest(ls): return ls[1:]

এটি সত্যই স্বাচ্ছন্দ্যযুক্ত এবং আপনি অতিরিক্ত ফানসিটনগুলি লেন (এলএস), এক্স-এ l, ইত্যাদি রাখতে পারবেন


টিপলসের যে পারফরম্যান্স বৈশিষ্ট্য তিনি চেয়েছিলেন তা নেই। আপনার বিশ্রাম () হ'ল একটি লিঙ্কযুক্ত তালিকার জন্য ও (1) এর বিপরীতে ও (এন) is
ব্রায়ান

ঠিক। আমার বক্তব্যটি হল: আপনার অ্যালগরিদম বাস্তবায়নের জন্য লিঙ্কযুক্ত তালিকাগুলি জিজ্ঞাসা করবেন না, বরং পাইথন বৈশিষ্ট্যগুলি এটি কার্যকরভাবে প্রয়োগ করতে ব্যবহার করুন। উদাহরণস্বরূপ, লিঙ্কযুক্ত তালিকার উপরে পুনরাবৃত্তি হ'ল ও (এন), যেমনটি পাইথন টুপলের উপর দিয়ে "এক্স টু এক্স:" ব্যবহার করে পুনরাবৃত্তি করছে
বার

আমি মনে করি লিঙ্কযুক্ত তালিকাগুলি কার্যকর করার জন্য টিপলগুলি ব্যবহার করার সঠিক উপায়টি এখানে গ্রহণযোগ্য উত্তর। আপনার পথটি অপরিবর্তনযোগ্য অ্যারে-মতো-অবজেক্টগুলি ব্যবহার করে
ক্লাদিউ

1
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)

1

আমি একটি পাইথন ২.x এবং ৩.x একক-লিঙ্কযুক্ত তালিকা ক্লাসটি https://pypi.python.org/pypi/linked_list_mod/ এ রেখেছি

এটি সিপিথন ২.7, সিপিথন ৩.৪, পাইপি ২.৩.১, পাইপাই ৩.৩.১, এবং জাইথন ​​২.7 বি 2 দিয়ে পরীক্ষা করা হয়েছে এবং একটি দুর্দান্ত স্বয়ংক্রিয় পরীক্ষার স্যুট নিয়ে আসে।

এটিতে LIFO এবং FIFO ক্লাসও অন্তর্ভুক্ত রয়েছে।

তারা যদিও পরিবর্তনযোগ্য নয়।


1
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

1

লিঙ্কযুক্ত তালিকার ক্লাস

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

ব্যবহার

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(), '-|---->  ',

আউটপুট

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

1

এখানে আমার সহজ বাস্তবায়ন:

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)

আউটপুট:

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

1

এখানে আমার সমাধান:

বাস্তবায়ন

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

ব্যবহার

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)

আসল বাস্তবায়ন আইডিয়া

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


0

আমি মনে করি নীচের বাস্তবায়নটি বিলটি পুরোপুরিভাবে পূর্ণ করে।

'''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)

0
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)

0

প্রথমত, আমি ধরে নিই যে আপনি লিঙ্কযুক্ত তালিকাগুলি চান। অনুশীলনে, আপনি ব্যবহার করতে পারেন collections.deque, যার বর্তমান সিপিথন বাস্তবায়নটি ব্লকের একটি দ্বিগুণ লিঙ্কযুক্ত তালিকা (প্রতিটি ব্লকে 62 টি কার্গো অবজেক্টের অ্যারে রয়েছে)। এটি লিঙ্কযুক্ত তালিকার কার্যকারিতা গ্রহণ করে। আপনি llistপাইপিতে ফোন করা কোনও সি এক্সটেনশান অনুসন্ধান করতে পারেন । আপনি যদি সংযুক্ত তালিকার এডিটি খাঁটি-পাইথন এবং সহজে অনুসরণ করতে চান তবে আমার নিম্নলিখিত ন্যূনতম বাস্তবায়নটি একবার দেখে নিতে পারেন।

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)

0

দ্বিগুণ সংযুক্ত তালিকার নমুনা (লিঙ্কলিস্ট.পি হিসাবে সংরক্ষণ করুন):

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

পরীক্ষা (টেস্ট.পি হিসাবে সংরক্ষণ করুন):

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()

আউটপুট :

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

0

আমি কয়েকটি টিউটোরিয়ালের উপর ভিত্তি করে একটি একক লিঙ্কযুক্ত তালিকাও লিখেছিলাম, যার বেসিক দুটি নোড এবং লিঙ্কযুক্ত তালিকার ক্লাস রয়েছে এবং সন্নিবেশ, মুছুন, বিপরীত করা, বাছাই করা এবং এই জাতীয় কিছু অতিরিক্ত পদ্ধতি রয়েছে।

এটি সর্বোত্তম বা সহজ নয়, যদিও ঠিক আছে।

"""
🍎🍏🍎🍏🍎🍏🍎🍏🍎🍏🍎🍏🍎🍏🍎🍏

Single Linked List (SLL):
A simple object-oriented implementation of Single Linked List (SLL) 
with some associated methods, such as create list, count nodes, delete nodes, and such. 

🍎🍏🍎🍏🍎🍏🍎🍏🍎🍏🍎🍏🍎🍏🍎🍏
"""

class Node:
    """
    Instantiates a node
    """
    def __init__(self, value):
        """
        Node class constructor which sets the value and link of the node

        """
        self.info = value
        self.link = None

class SingleLinkedList:
    """
    Instantiates the SLL class
    """
    def __init__(self):
        """
        SLL class constructor which sets the value and link of the node

        """
        self.start = None

    def create_single_linked_list(self):
        """
        Reads values from stdin and appends them to this list and creates a SLL with integer nodes

        """
        try:
            number_of_nodes = int(input("👉   Enter a positive integer between 1-50 for the number of nodes you wish to have in the list: "))
            if number_of_nodes <= 0 or number_of_nodes > 51:
                print("💛 The number of nodes though must be an integer between 1 to 50!")
                self.create_single_linked_list()

        except Exception as e:
            print("💛 Error: ", e)
            self.create_single_linked_list()


        try:
            for _ in range(number_of_nodes):
                try:
                    data = int(input("👉   Enter an integer for the node to be inserted: "))
                    self.insert_node_at_end(data)
                except Exception as e:
                    print("💛 Error: ", e)
        except Exception as e:
            print("💛 Error: ", e)

    def count_sll_nodes(self):
        """
        Counts the nodes of the linked list

        """
        try:
            p = self.start
            n = 0
            while p is not None:
                n += 1
                p = p.link

            if n >= 1:
                print(f"💚 The number of nodes in the linked list is {n}")
            else:
                print(f"💛 The SLL does not have a node!")
        except Exception as e: 
            print("💛 Error: ", e)

    def search_sll_nodes(self, x):
        """
        Searches the x integer in the linked list
        """
        try:
            position =  1
            p = self.start
            while p is not None:
                if p.info == x:
                    print(f"💚 YAAAY! We found {x} at position {position}")
                    return True

                #Increment the position
                position += 1 
                #Assign the next node to the current node
                p = p.link
            else:
                print(f"💔 Sorry! We couldn't find {x} at any position. Maybe, you might want to use option 9 and try again later!")
                return False
        except Exception as e:
            print("💛 Error: ", e)

    def display_sll(self):
        """
        Displays the list
        """
        try:
            if self.start is None:
                print("💛 Single linked list is empty!")
                return

            display_sll = "💚 Single linked list nodes are: "
            p = self.start
            while p is not None:
                display_sll += str(p.info) + "\t"
                p = p.link

            print(display_sll)

        except Exception as e:
            print("💛 Error: ", e) 

    def insert_node_in_beginning(self, data):
        """
        Inserts an integer in the beginning of the linked list

        """
        try:
            temp = Node(data)
            temp.link = self.start
            self.start = temp
        except Exception as e:
            print("💛 Error: ", e)

    def insert_node_at_end(self, data):
        """
        Inserts an integer at the end of the linked list

        """
        try:            
            temp = Node(data)
            if self.start is None:
                self.start = temp
                return

            p = self.start  
            while p.link is not None:
                p = p.link
            p.link = temp
        except Exception as e:
            print("💛 Error: ", e)


    def insert_node_after_another(self, data, x):
        """
        Inserts an integer after the x node

        """
        try:
            p = self.start

            while p is not None:
                if p.info == x:
                    break
                p = p.link

            if p is None:
                print(f"💔 Sorry! {x} is not in the list.")
            else:
                temp = Node(data)
                temp.link = p.link
                p.link = temp
        except Exception as e: 
            print("💛 Error: ", e)


    def insert_node_before_another(self, data, x):
        """
        Inserts an integer before the x node

        """

        try:

            # If list is empty
            if self.start is None:
                print("💔 Sorry! The list is empty.")
                return 
            # If x is the first node, and new node should be inserted before the first node
            if x == self.start.info:
                temp = Node(data)
                temp.link = p.link
                p.link = temp

            # Finding the reference to the prior node containing x
            p = self.start
            while p.link is not None:
                if p.link.info == x:
                    break
                p = p.link

            if p.link is not None:
                print(f"💔 Sorry! {x} is not in the list.")
            else:
                temp = Node(data)
                temp.link = p.link
                p.link = temp           

        except Exception as e:
            print("💛 Error: ", e)

    def insert_node_at_position(self, data, k):
        """
        Inserts an integer in k position of the linked list

        """
        try:
            # if we wish to insert at the first node
            if k == 1:
                temp = Node(data)
                temp.link = self.start
                self.start = temp
                return

            p = self.start
            i = 1

            while i < k-1 and p is not None:
                p = p.link
                i += 1

            if p is None:
                print(f"💛 The max position is {i}") 
            else:    
                temp = Node(data)
                temp.link = self.start
                self.start = temp

        except Exception as e:
            print("💛 Error: ", e)

    def delete_a_node(self, x):
        """
        Deletes a node of a linked list

        """
        try:
            # If list is empty
            if self.start is None:
                print("💔 Sorry! The list is empty.")
                return

            # If there is only one node
            if self.start.info == x:
                self.start = self.start.link

            # If more than one node exists
            p = self.start
            while p.link is not None:
                if p.link.info == x:
                    break   
                p = p.link

            if p.link is None:
                print(f"💔 Sorry! {x} is not in the list.")
            else:
                p.link = p.link.link

        except Exception as e:
            print("💛 Error: ", e)

    def delete_sll_first_node(self):
        """
        Deletes the first node of a linked list

        """
        try:
            if self.start is None:
                return
            self.start = self.start.link

        except Exception as e:
            print("💛 Error: ", e)


    def delete_sll_last_node(self):
        """
        Deletes the last node of a linked list

        """
        try:

            # If the list is empty
            if self.start is None:
                return

            # If there is only one node
            if self.start.link is None:
                self.start = None
                return

            # If there is more than one node    
            p = self.start

            # Increment until we find the node prior to the last node 
            while p.link.link is not None:
                p = p.link

            p.link = None   

        except Exception as e:
            print("💛 Error: ", e)


    def reverse_sll(self):
        """
        Reverses the linked list

        """

        try:

            prev = None
            p = self.start
            while p is not None:
                next = p.link
                p.link = prev
                prev = p
                p = next
            self.start = prev

        except Exception as e:
            print("💛 Error: ", e)


    def bubble_sort_sll_nodes_data(self):
        """
        Bubble sorts the linked list on integer values

        """

        try:

            # If the list is empty or there is only one node
            if self.start is None or self.start.link is None:
                print("💛 The list has no or only one node and sorting is not required.")
            end = None

            while end != self.start.link:
                p = self.start
                while p.link != end:
                    q = p.link
                    if p.info > q.info:
                        p.info, q.info = q.info, p.info
                    p = p.link
                end = p

        except Exception as e:
            print("💛 Error: ", e)


    def bubble_sort_sll(self):
        """
        Bubble sorts the linked list

        """

        try:

            # If the list is empty or there is only one node
            if self.start is None or self.start.link is None:
                print("💛 The list has no or only one node and sorting is not required.")
            end = None

            while end != self.start.link:
                r = p = self.start
                while p.link != end:
                    q = p.link
                    if p.info > q.info:
                        p.link = q.link
                        q.link = p
                    if  p != self.start:
                        r.link = q.link
                    else:
                        self.start = q
                    p, q = q, p
                    r = p
                    p = p.link
                end = p

        except Exception as e:
            print("💛 Error: ", e)


    def sll_has_cycle(self):
        """
        Tests the list for cycles using Tortoise and Hare Algorithm (Floyd's cycle detection algorithm)
        """

        try:

            if self.find_sll_cycle() is None:
                return False
            else:
                return True


        except Exception as e:
            print("💛 Error: ", e)


    def find_sll_cycle(self):
        """
        Finds cycles in the list, if any
        """

        try:

            # If there is one node or none, there is no cycle
            if self.start is None or self.start.link is None:
                return None

            # Otherwise, 
            slowR = self.start
            fastR = self.start

            while slowR is not None and fastR is not None:
                slowR = slowR.link
                fastR = fastR.link.link
                if slowR == fastR: 
                    return slowR

            return None

        except Exception as e:
            print("💛 Error: ", e)


    def remove_cycle_from_sll(self):
        """
        Removes the cycles
        """

        try:

            c = self.find_sll_cycle()

            # If there is no cycle
            if c is None:
                return

            print(f"💛 There is a cycle at node: ", c.info)

            p = c
            q = c
            len_cycles = 0
            while True:
                len_cycles += 1
                q = q.link

                if p == q:
                    break

            print(f"💛 The cycle length is {len_cycles}")

            len_rem_list = 0
            p = self.start

            while p != q:
                len_rem_list += 1
                p = p.link
                q = q.link

            print(f"💛 The number of nodes not included in the cycle is {len_rem_list}")

            length_list = len_rem_list + len_cycles

            print(f"💛 The SLL length is {length_list}")

            # This for loop goes to the end of the SLL, and set the last node to None and the cycle is removed. 
            p = self.start
            for _ in range(length_list-1):
                p = p.link
            p.link = None


        except Exception as e:
            print("💛 Error: ", e)


    def insert_cycle_in_sll(self, x):
        """
        Inserts a cycle at a node that contains x

        """

        try:

            if self.start is None:
                return False

            p = self.start
            px = None
            prev = None


            while p is not None:
                if p.info == x:
                    px = p
                prev = p
                p = p.link

            if px is not None:
                prev.link = px
            else:
                print(f"💔 Sorry! {x} is not in the list.")


        except Exception as e:
            print("💛 Error: ", e)


    def merge_using_new_list(self, list2):
        """
        Merges two already sorted SLLs by creating new lists
        """
        merge_list = SingleLinkedList()
        merge_list.start = self._merge_using_new_list(self.start, list2.start)
        return merge_list

    def _merge_using_new_list(self, p1, p2):
        """
        Private method of merge_using_new_list
        """
        if p1.info <= p2.info:
            Start_merge = Node(p1.info)
            p1 = p1.link
        else:
            Start_merge = Node(p2.info)
            p2 = p2.link            
        pM = Start_merge

        while p1 is not None and p2 is not None:
            if p1.info <= p2.info:
                pM.link = Node(p1.info)
                p1 = p1.link
            else:
                pM.link = Node(p2.info)
                p2 = p2.link
            pM = pM.link

        #If the second list is finished, yet the first list has some nodes
        while p1 is not None:
            pM.link = Node(p1.info)
            p1 = p1.link
            pM = pM.link

        #If the second list is finished, yet the first list has some nodes
        while p2 is not None:
            pM.link = Node(p2.info)
            p2 = p2.link
            pM = pM.link

        return Start_merge

    def merge_inplace(self, list2):
        """
        Merges two already sorted SLLs in place in O(1) of space
        """
        merge_list = SingleLinkedList()
        merge_list.start = self._merge_inplace(self.start, list2.start)
        return merge_list

    def _merge_inplace(self, p1, p2):
        """
        Merges two already sorted SLLs in place in O(1) of space
        """
        if p1.info <= p2.info:
            Start_merge = p1
            p1 = p1.link
        else:
            Start_merge = p2
            p2 = p2.link
        pM = Start_merge

        while p1 is not None and p2 is not None:
            if p1.info <= p2.info:
                pM.link = p1
                pM = pM.link
                p1 = p1.link
            else:
                pM.link = p2
                pM = pM.link
                p2 = p2.link

        if p1 is None:
            pM.link = p2
        else:
            pM.link = p1

        return Start_merge

    def merge_sort_sll(self):
        """
        Sorts the linked list using merge sort algorithm
        """
        self.start = self._merge_sort_recursive(self.start)


    def _merge_sort_recursive(self, list_start):
        """
        Recursively calls the merge sort algorithm for two divided lists
        """

        # If the list is empty or has only one node
        if list_start is None or list_start.link is None:
            return list_start

        # If the list has two nodes or more
        start_one = list_start
        start_two = self._divide_list(self_start)
        start_one = self._merge_sort_recursive(start_one)
        start_two = self._merge_sort_recursive(start_two)
        start_merge = self._merge_inplace(start_one, start_two)

        return start_merge

    def _divide_list(self, p):
        """
        Divides the linked list into two almost equally sized lists
        """

        # Refers to the third nodes of the list
        q = p.link.link

        while q is not None and p is not None:
            # Increments p one node at the time
            p = p.link
            # Increments q two nodes at the time
            q = q.link.link

        start_two = p.link
        p.link = None

        return start_two

    def concat_second_list_to_sll(self, list2):
        """
        Concatenates another SLL to an existing SLL
        """

        # If the second SLL has no node
        if list2.start is None:
            return

        # If the original SLL has no node
        if self.start is None:
            self.start = list2.start
            return

        # Otherwise traverse the original SLL
        p = self.start
        while p.link is not None:
            p = p.link

        # Link the last node to the first node of the second SLL
        p.link = list2.start



    def test_merge_using_new_list_and_inplace(self):
        """

        """

        LIST_ONE = SingleLinkedList()
        LIST_TWO = SingleLinkedList()

        LIST_ONE.create_single_linked_list()
        LIST_TWO.create_single_linked_list()

        print("1️⃣  The unsorted first list is: ")
        LIST_ONE.display_sll()

        print("2️⃣  The unsorted second list is: ")
        LIST_TWO.display_sll()


        LIST_ONE.bubble_sort_sll_nodes_data()
        LIST_TWO.bubble_sort_sll_nodes_data()

        print("1️⃣  The sorted first list is: ")
        LIST_ONE.display_sll()

        print("2️⃣  The sorted second list is: ")
        LIST_TWO.display_sll()

        LIST_THREE = LIST_ONE.merge_using_new_list(LIST_TWO)

        print("The merged list by creating a new list is: ")
        LIST_THREE.display_sll()


        LIST_FOUR = LIST_ONE.merge_inplace(LIST_TWO)

        print("The in-place merged list is: ")
        LIST_FOUR.display_sll()     


    def test_all_methods(self):
        """
        Tests all methods of the SLL class
        """

        OPTIONS_HELP = """
📗📗📗📗📗📗📗📗📗📗📗📗📗📗📗📗📗📗📗📗📗📗📗📗📗📗📗📗📗📗📗📗📗📗📗📗📗📗📗📗📗
    Select a method from 1-19:                                                          
🍒🍒🍒🍒🍒🍒🍒🍒🍒🍒🍒🍒🍒🍒🍒🍒🍒🍒🍒🍒🍒🍒🍒🍒🍒🍒🍒🍒🍒🍒🍒🍒🍒🍒🍒🍒🍒🍒🍒🍒🍒
        ℹ️   (1)    👉  Create a single liked list (SLL).
        ℹ️   (2)    👉  Display the SLL.                            
        ℹ️   (3)    👉  Count the nodes of SLL. 
        ℹ️   (4)    👉  Search the SLL.
        ℹ️   (5)    👉  Insert a node at the beginning of the SLL.
        ℹ️   (6)    👉  Insert a node at the end of the SLL.
        ℹ️   (7)    👉  Insert a node after a specified node of the SLL.
        ℹ️   (8)    👉  Insert a node before a specified node of the SLL.
        ℹ️   (9)    👉  Delete the first node of SLL.
        ℹ️   (10)   👉  Delete the last node of the SLL.
        ℹ️   (11)   👉  Delete a node you wish to remove.                           
        ℹ️   (12)   👉  Reverse the SLL.
        ℹ️   (13)   👉  Bubble sort the SLL by only exchanging the integer values.  
        ℹ️   (14)   👉  Bubble sort the SLL by exchanging links.                    
        ℹ️   (15)   👉  Merge sort the SLL.
        ℹ️   (16)   👉  Insert a cycle in the SLL.
        ℹ️   (17)   👉  Detect if the SLL has a cycle.
        ℹ️   (18)   👉  Remove cycle in the SLL.
        ℹ️   (19)   👉  Test merging two bubble-sorted SLLs.
        ℹ️   (20)   👉  Concatenate a second list to the SLL. 
        ℹ️   (21)   👉  Exit.
📗📗📗📗📗📗📗📗📗📗📗📗📗📗📗📗📗📗📗📗📗📗📗📗📗📗📗📗📗📗📗📗📗📗📗📗📗📗📗📗📗
        """


        self.create_single_linked_list()

        while True:

            print(OPTIONS_HELP)

            UI_OPTION = int(input("👉   Enter an integer for the method you wish to run using the above help: "))

            if UI_OPTION == 1:
                data = int(input("👉   Enter an integer to be inserted at the end of the list: "))
                x = int(input("👉   Enter an integer to be inserted after that: "))
                self.insert_node_after_another(data, x)
            elif UI_OPTION == 2:
                self.display_sll()
            elif UI_OPTION == 3:
                self.count_sll_nodes()
            elif UI_OPTION == 4:
                data = int(input("👉   Enter an integer to be searched: "))
                self.search_sll_nodes(data)
            elif UI_OPTION == 5:
                data = int(input("👉   Enter an integer to be inserted at the beginning: "))
                self.insert_node_in_beginning(data)
            elif UI_OPTION == 6:
                data = int(input("👉   Enter an integer to be inserted at the end: "))
                self.insert_node_at_end(data)
            elif UI_OPTION == 7:
                data = int(input("👉   Enter an integer to be inserted: "))
                x = int(input("👉   Enter an integer to be inserted before that: "))
                self.insert_node_before_another(data, x)
            elif UI_OPTION == 8:
                data = int(input("👉   Enter an integer for the node to be inserted: "))
                k = int(input("👉   Enter an integer for the position at which you wish to insert the node: "))
                self.insert_node_before_another(data, k)
            elif UI_OPTION == 9:
                self.delete_sll_first_node()
            elif UI_OPTION == 10:
                self.delete_sll_last_node()
            elif UI_OPTION == 11:
                data = int(input("👉   Enter an integer for the node you wish to remove: "))
                self.delete_a_node(data)
            elif UI_OPTION == 12:
                self.reverse_sll()
            elif UI_OPTION == 13:
                self.bubble_sort_sll_nodes_data()
            elif UI_OPTION == 14:
                self.bubble_sort_sll()
            elif UI_OPTION == 15:
                self.merge_sort_sll()
            elif UI_OPTION == 16:
                data = int(input("👉   Enter an integer at which a cycle has to be formed: "))
                self.insert_cycle_in_sll(data)
            elif UI_OPTION == 17:
                if self.sll_has_cycle():
                    print("💛 The linked list has a cycle. ")
                else:
                    print("💚 YAAAY! The linked list does not have a cycle. ")
            elif UI_OPTION == 18:
                self.remove_cycle_from_sll()
            elif UI_OPTION == 19:
                self.test_merge_using_new_list_and_inplace()
            elif UI_OPTION == 20:
                list2 = self.create_single_linked_list()
                self.concat_second_list_to_sll(list2)
            elif UI_OPTION == 21:
                break
            else:
                print("💛 Option must be an integer, between 1 to 21.")

            print()     



if __name__ == '__main__':
    # Instantiates a new SLL object
    SLL_OBJECT = SingleLinkedList()
    SLL_OBJECT.test_all_methods()

0

সম্প্রসারিত নিক Stinemates এর উত্তর

class Node(object):
    def __init__(self):
        self.data = None
        self.next = None

class LinkedList:
    def __init__(self):
        self.head = None

    def prepend_node(self, data):
        new_node = Node()
        new_node.data = data
        new_node.next = self.head
        self.head = new_node

    def append_node(self, data):
        new_node = Node()
        new_node.data = data
        current = self.head
        while current.next:
            current = current.next
        current.next = new_node

    def reverse(self):
        """ In-place reversal, modifies exiting list"""
        previous = None
        current_node = self.head

        while current_node:
            temp =  current_node.next
            current_node.next = previous
            previous = current_node
            current_node = temp
        self.head = previous

    def search(self, data):
        current_node = self.head
        try:
            while current_node.data != data:
                current_node = current_node.next
            return True
        except:
            return False

    def display(self):
        if self.head is None:
            print("Linked list is empty")
        else:
            current_node = self.head
            while current_node:
                print(current_node.data)
                current_node = current_node.next

    def list_length(self):
        list_length = 0
        current_node = self.head
        while current_node:
            list_length += 1
            current_node = current_node.next
        return list_length


def main():
    linked_list = LinkedList()

    linked_list.prepend_node(1)
    linked_list.prepend_node(2)
    linked_list.prepend_node(3)
    linked_list.append_node(24)
    linked_list.append_node(25)
    linked_list.display()
    linked_list.reverse()
    linked_list.display()
    print(linked_list.search(1))
    linked_list.reverse()
    linked_list.display()
    print("Lenght of singly linked list is: " + str(linked_list.list_length()))


if __name__ == "__main__":
    main()

-1

আমার 2 সেন্ট

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

-1
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()

আপনি একটি পুরানো প্রশ্নের উত্তর দিন যা ইতিমধ্যে বেশ কয়েকটি ভাল উত্তর পেয়েছে এবং আপনি কোনও ব্যাখ্যা দেন না। আপনার সংস্করণ পোস্ট করার কারণ কী? ইতিমধ্যে উপস্থাপিত সমাধানগুলির কি এতে কোনও উপকার আছে? বা অন্য কোনও যুক্ত মূল্য? আপনার উত্তরটি সম্পাদনা করুন এবং আপনার উত্তর আরও সম্পূর্ণ করতে কিছু ব্যাখ্যা যুক্ত করুন।
হনক

-1

আমার ডাবল লিঙ্কড লিস্টটি নুবিদের কাছে বোধগম্য হতে পারে। আপনি যদি ডি সি এর সাথে পরিচিত হন তবে এটি বেশ পঠনযোগ্য।

# 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()

যদিও এই কোডটিতে আরও অনেক সরলীকরণ যুক্ত করা যেতে পারে, আমি ভেবেছিলাম একটি কাঁচা বাস্তবায়ন আমাকে আরও দখল করতে পারে।


আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.