रिकर्सन

Question

का उपयोग कर पायथन में एक स्टैक को उलटना मैं कुछ अभ्यास प्रश्न कर रहा हूं। किसी अन्य स्टैक को छोड़कर किसी अन्य डेटा संरचनाओं का उपयोग किये बिना इसे किसी स्टैक को रिवर्स करने की आवश्यकता है।

मुझे पता है कि मुझे एक सहायक कार्य की आवश्यकता होगी जो मूल स्टैक खाली होने के बाद पॉप-एड संख्याओं को जोड़ती है।

क्या कोई मुझे शुरू कर सकता है? मैं यहां फंस गया हूं

def flip_stack(s): 
    if not s.is_empty(): 
     temp = s.pop 
     flip_stack(s) 

धन्यवाद!

स्टैक क्लास में pop, push और is_empty फ़ंक्शंस हैं।

def flip(stack): 
    def helper(old_stack, new_stack): 
     if old_stack: 
      new_stack.append(old_stack.pop()) 
      return helper(old_stack, new_stack) 
     else: 
      return new_stack 
    return helper(stack[:], []) 

stack[:] मूल ढेर संरक्षित करने का कारण बनता है:

Answer 1

यहां एक और संभावना है, एक संचयक और एक सहायक समारोह का उपयोग कर। मैं केवल अपने Stack वर्ग में प्रदान की विधियों, और (जैसे कि अजगर की सूची के रूप में) कोई अन्य डेटा संरचनाओं का उपयोग कर रहा:

def flip_stack(s): 
    return flip_stack_helper(s, Stack()) # Stack is your stack class 

def flip_stack_helper(s, t): 
    if s.is_empty(): 
     return t 
    t.push(s.pop()) 
    return flip_stack_helper(s, t) 

पता है कि मूल ढेर अंत में खाली हो जाएगा, और फ़्लिप ढेर है लौटा हुआ।

Answer 2

def reverse(orig, reversel=None): 
    if not reversel: 
     reversel = [] 
    reversel.append(orig.pop()) 
    if orig: 
     reverse(orig, reversel) 
    return reversel 

stack = [1, 2, 3, 4, 5] 
stack = reverse(stack) 
print stack 
[5, 4, 3, 2, 1] 

Answer 3

निम्नलिखित काम करता है, तो ढेर एक देशी अजगर सूची है।

अपने दिए गए Stack कक्षा को संभालने के लिए इसे संशोधित करना मुश्किल नहीं होना चाहिए।

Answer 4

>>> liste = [1, 2, 3, 4, 5] 
>>> liste[::-1] 
[5, 4, 3, 2, 1] 

Answer 5

कोई डेटा संरचना मान लिया जाये कि यहां तक ​​कि यहाँ अंतिम परिणाम धारण करने के लिए सूची नहीं किया जाना चाहिए एक संभव समाधान

यहां ढेर एक सूची है जो निम्नलिखित समारोह का समर्थन करता है पर विचार किया जाएगा है

append(elem) ---- push(elem) 
pop()   ---- pop() 
if <some stack>---- NotEmpty() 

समाधान 1:

def flip_stack(s): 
    while True: 
     if s: 
      yield s.pop() 
     else: 
      return 

stack = [1,2,3,4,5] 
revStack = [x for x in flip_stack(stack)] 

यहां तक ​​कि आप उपयोग किए बिना कोड भी कर सकते हैं IsEmpty OT NotEmpty कार्यक्षमता

समाधान 2:

def flip_stack(s): 
    while True: 
     try: 
      yield s.pop() 
     except IndexError: 
      return 

नोट * * सशर्त जाँच के लिए अपवाद का उपयोग अजगर में एक स्वीकृत व्यवहार है, क्योंकि यह कोई C++ में

Answer 6

class Stack(object): 
    def __init__(self,items=[]): 
     self.stack = items 

    def is_empty(self): 
     return not self.stack 

    def pop(self): 
     return self.stack.pop() 

    def push(self,val): 
     self.stack.append(val) 

    def __repr__(self): 
     return "Stack {0}".format(self.stack) 

def flip_stack(stack): 
    def flip_stack_recursive(stack,new_stack=Stack()): 
     if not stack.is_empty(): 
      new_stack.push(stack.pop()) 
      flip_stack_recursive(stack,new_stack) 
     return new_stack 
    return flip_stack_recursive(stack) 


s = Stack(range(5)) 
print s 
print flip_stack(s) 

भूमि के ऊपर जोड़ा है

उपज

Stack [0, 1, 2, 3, 4] 
Stack [4, 3, 2, 1, 0] 

आप यहां तक ​​कि इस तथ्य का उपयोग करके थोड़ा फैंसी प्राप्त करें कि रिकर्सिव फ़ंक्शन के दायरे में flip_stack का बंदरगाह stack पैरामीटर रखता है, इसलिए आपको आंतरिक फ़ंक्शन के लिए पैरामीटर होने की आवश्यकता नहीं है। जैसे

def flip_stack(stack): 
    def flip_stack_recursive(new_stack): 
     if not stack.is_empty(): 
      new_stack.push(stack.pop()) 
      flip_stack_recursive(new_stack) 
     return new_stack 
    return flip_stack_recursive(Stack()) 

या, पुनरावर्ती क्रिया पर सभी मापदंडों से छुटकारा पाने के लिए, और अपने धागा ढेर फ्रेम धन्यवाद देगा:

def flip_stack(stack): 
    new_stack = Stack() 
    def flip_stack_recursive(): 
     if not stack.is_empty(): 
      new_stack.push(stack.pop()) 
      flip_stack_recursive() 
    flip_stack_recursive() 
    return new_stack