कार्यात्मक प्रोग्रामिंग में डेटा संरचनाएं

Question

मैं वर्तमान में LISP (विशेष रूप से स्कीम और क्लोजर) के साथ खेल रहा हूं और मैं सोच रहा हूं कि कार्यात्मक प्रोग्रामिंग भाषाओं में कैसे विशिष्ट डेटा संरचनाओं से निपटा जाता है।

उदाहरण के लिए, मान लें कि मैं एक ग्राफ पाथफाइंडिंग एल्गोरिथ्म का उपयोग करके किसी समस्या को हल करना चाहूंगा। आमतौर पर एक कार्यात्मक प्रोग्रामिंग भाषा में उस ग्राफ का प्रतिनिधित्व करने के बारे में कैसे जाना जाएगा (मुख्य रूप से शुद्ध कार्यात्मक शैली में दिलचस्पी है जिसे LISP पर लागू किया जा सकता है)? क्या मैं सिर्फ रेखांकन के बारे में पूरी तरह से भूल जाऊंगा और समस्या को किसी और तरह से हल कर दूंगा?

Answer 1

LISP में काम करने के बाद मुझे कुछ समय हो गया है, लेकिन जैसा कि मुझे याद है, बुनियादी गैर-परमाणु संरचना एक सूची है। बाकी सब उसी पर आधारित है। तो आपके पास परमाणुओं की एक सूची हो सकती है जहां प्रत्येक परमाणु एक नोड है जिसके बाद किनारों की एक सूची है जो नोड को अन्य नोड्स से जोड़ती है। मुझे यकीन है कि ऐसा करने के अन्य तरीके भी हैं।

शायद कुछ इस तरह:

(
  (a (b c)),
  (b (a c)),
  (c (a b d)),
  (d (c))
)

इस तरह एक ग्राफ दे सकता है:

एक <-> ख <-> ग <-> घ
^ ^
| |
+ --------- +

यदि आप फैंसी प्राप्त करना चाहते हैं, तो आप इसमें वजन भी जोड़ सकते हैं:

(
  (a (b 1.0 c 2.0)),
  (b (a 1.0 c 1.0)),
  (c (a 1.3 b 7.2 d 10.5)),
  (d (c -10.5))
)

आपको इसमें रुचि भी हो सकती है: सीएल-ग्राफ (गूगल द्वारा खोजा गया वाक्यांश "लिस्प ग्राफ संरचना"

Comments

यह थोड़ा देर से है, लेकिन मुझे लगता है कि मुझे चेतावनी देनी चाहिए कि "बाकी सब कुछ [सूची] पर आधारित है" भ्रामक है। सामान्य लिस्प, स्कीम और क्लोजर में सभी वैक्टर, नक्शे, तार, साथ ही संरचनाएं / कक्षाएं हैं, जो सूचियों के शीर्ष पर निर्मित नहीं हैं; कोड हम उन्हें आम तौर पर बनाने के लिए लिखना एक सूची है, जैसे (मेक-सरणी '(2 2): प्रारंभिक तत्व 0) है, लेकिन डेटा संरचना सूचियों का उपयोग कर लागू नहीं किया जाता है।

— coredump

Answer 2

कार्यात्मक भाषाएं डेटा संरचनाओं के साथ उसी तरह व्यवहार करती हैं जैसे गैर-कार्यात्मक भाषाएं करती हैं: इंटरफ़ेस को कार्यान्वयन से अलग करके, सार डेटा प्रकार बनाकर।

आप लिस्प में सार डेटा प्रकार बना सकते हैं। उदाहरण के लिए, ग्राफ़ के लिए, आपको कुछ कार्यों की आवश्यकता हो सकती है:

(define (get-vertices graph) ;; gets all the vertices from a graph
  ...)

(define (get-edges graph) ;; gets all the edges from a graph
  ...)

(define (get-weight vertex-from vertex-to) ;; get the weight of a specific vertex
  ...)

एक बार जब आप उस इंटरफ़ेस को ग्राफ़ में बना लेते हैं, तो आप वास्तविक डेटा संरचनाओं को कई अलग-अलग तरीकों से लागू कर सकते हैं, संभवतः प्रोग्रामर दक्षता, लचीलापन और कम्प्यूटेशनल दक्षता जैसे कारकों का अनुकूलन कर सकते हैं।

कुंजी यह सुनिश्चित करना है कि ग्राफ़ का उपयोग करने वाला कोड केवल ग्राफ़ इंटरफ़ेस का उपयोग करता है, और अंतर्निहित कार्यान्वयन तक पहुंच नहीं करता है। यह वास्तविक कार्यान्वयन से ग्राहक कोड को सरल बनाये रखेगा।

Answer 3

वैसे यह इस बात पर निर्भर करेगा कि आपका ग्राफ निर्देशित है / अप्रत्यक्ष, भारित / भार रहित लेकिन एक निर्देशित, भारित ग्राफ (जो कि सबसे सामान्य होगा) का प्रतिनिधित्व करने का एक तरीका नक्शों के नक्शे (क्लोजर में) के साथ है

{
 :a {:b 3 :c 4} 
 :b {:a 1} 
 :c {}
}

नोड्स के साथ एक मानचित्र का प्रतिनिधित्व करेगा: a: b और: c। : एक अंक: 3 के वजन के साथ बी और 4 के वजन के साथ: सी: बी अंक: 1. के वजन के साथ: सी कुछ भी इंगित नहीं करता है।

Answer 4

आम लिस्प में, अगर मुझे एक पेड़ का प्रतिनिधित्व करने की आवश्यकता है, तो मैं या तो एक सूची का उपयोग करूंगा (यदि यह सिर्फ एक त्वरित हैक के लिए था) या एक पेड़ वर्ग (या संरचना को परिभाषित करता है, लेकिन कक्षाएं सामान्य कार्यों के साथ अच्छी तरह से बातचीत करती हैं, तो क्यों नहीं) ।

(defclass tree ()
  ((node :accessor node :initarg :node)
   (children :accessor children :initarg :children)))

अगर मुझे कोड में शाब्दिक वृक्षों की आवश्यकता है, तो मैं संभवतः एक make-treeफ़ंक्शन को परिभाषित करूँगा जो मुझे चाहिए पेड़ की एक सूची का प्रतिनिधित्व करता है और इसे पेड़-वस्तुओं के पेड़ में बदल देता है।

Answer 5

हास्केल में सूची बुनियादी डेटा संरचना है और यदि आप एक अधिक उन्नत डेटा स्ट्रुकेबुलर्स चाहते हैं तो आप अक्सर पुनरावर्ती स्ट्रीक का उपयोग करते हैं जैसे कि पेड़ या तो एक नल या एक नोड और दो पेड़ हैं।

data Tree a = Null | Node Tree a Tree