არაწრფივი მონაცემთა სტრუქტურები Swift-ში

Swift-ში არაწრფივი მონაცემთა სტრუქტურები გამოიყენება რთული ურთიერთობების მქონე მონაცემთა მოდელირებისთვის, სადაც ელემენტები პირდაპირი თანმიმდევრობით არ არის დაკავშირებული. მაგალითად, social network-ს ან family tree-ს უფრო რთული სტრუქტურა სჭირდება, ვიდრე უბრალო სია. სწორედ ამიტომ, პროგრამირებაში ფართოდ გამოიყენება არაწრფივი სტრუქტურები, როგორიცაა Trees და Graphs.

Trees

Trees Introduction

Trees არის მონაცემთა სტრუქტურები, რომლებიც გამოიყენება იერარქიული მონაცემების შესანახად. ისინი შედგება Nodes-ისგან, რომლებიც ერთმანეთთან დაკავშირებულია გარკვეული წესებით. Trees ხშირად გამოიყენება ფაილურ სისტემებში, მონაცემთა ბაზებში და სხვა პროგრამულ სისტემებში.

Tree Detail

Tree სტრუქტურაში Nodes ორგანიზებულია Root-ის გარშემო, რომელიც არ არის დამოკიდებული სხვა Nodes-ზე. თითოეული Node შეიძლება იყოს Parent და Child. Nodes-ებს შორის ურთიერთობა განსაზღვრავს მონაცემთა სტრუქტურას და მისი დამუშავების წესებს.

Tree Varietals

Trees შეიძლება იყოს:

• Wide Trees — Parent Nodes ბევრ Child Node-ს შეიცავს.
• Deep Trees — Parent-Child კავშირები მრავალ დონეზეა განაწილებული.
• Balanced Trees — Nodes ისეა განაწილებული, რომ მაქსიმალური სიმაღლე მინიმუმამდე შემცირდეს.

Trees არის მონაცემთა სტრუქტურები, რომლებიც წარმოადგენს იერარქიულ ურთიერთობებს. თითოეულ Node-ს შეუძლია ჰქონდეს Child Nodes, მაგრამ მხოლოდ ერთი Parent.

ძირითადი კომპონენტები:

• Root — ხის მთავარი Node, რომელსაც არ ჰყავს Parent.
• Parent — Node, რომელიც შეიცავს Child Nodes-ს.
• Child — Parent Node-თან დაკავშირებული Node.
• Sibling — საერთო Parent-ის მქონე Nodes.
• Leaf — Node, რომელსაც Child Nodes არ ჰყავს.

Swift-ში Tree-ის იმპლემენტაცია

class TreeNode<T> {
    var value: T
    var children: [TreeNode] = []

    init(value: T) {
        self.value = value
    }

    func addChild(_ child: TreeNode) {
        children.append(child)
    }
}

let root = TreeNode(value: "Root")
let child1 = TreeNode(value: "Child 1")
let child2 = TreeNode(value: "Child 2")
root.addChild(child1)
root.addChild(child2)

Binary Search Tree (BST)

Binary Search Tree არის სპეციალური სტრუქტურა, რომელიც საშუალებას გვაძლევს ეფექტურად მოვძებნოთ მონაცემები.

BST-ის წესები:

• თითოეულ Parent Node-ს შეიძლება ჰყავდეს მაქსიმუმ ორი Child.
• მარცხენა Child ყოველთვის ნაკლებია Parent-ზე.
• მარჯვენა Child ყოველთვის მეტია Parent-ზე.

ეს სტრუქტურა საშუალებას გვაძლევს სწრაფად მოვიძიოთ მონაცემი O(log n) დროში.

ძიების მაგალითი:

ვთქვათ, გვინდა მოვძებნოთ 31:

1. ვიწყებთ Root-დან (39)
2. 31 < 39 → გადავდივართ მარცხენა Child-ზე (23)
3. 31 > 23 → გადავდივართ მარჯვენა Child-ზე (35)
4. 31 < 35 → გადავდივართ მარცხენა Child-ზე (31)
5. ვპოულობთ 31-ს

მხოლოდ სამი შედარებით ვიპოვეთ მონაცემი 15 ელემენტიან მონაცემთა ბაზაში

BST-ის იმპლემენტაცია Swift-ში

class BSTNode<T: Comparable> {
    var value: T
    var left: BSTNode?
    var right: BSTNode?

    init(value: T) {
        self.value = value
    }

    func insert(_ newValue: T) {
        if newValue < value {
            if let left = left {
                left.insert(newValue)
            } else {
                left = BSTNode(value: newValue)
            }
        } else {
            if let right = right {
                right.insert(newValue)
            } else {
                right = BSTNode(value: newValue)
            }
        }
    }
}

let root = BSTNode(value: 39)
root.insert(23)
root.insert(35)
root.insert(31)

Graphs

Graph არის მონაცემთა სტრუქტურა, სადაც Nodes დაკავშირებულია ერთმანეთთან Edges-ის მეშვეობით. Graphs შეიძლება იყოს Directional და Undirected. ისინი ხშირად გამოიყენება რუკებში, social network-ებში და კავშირგაბმულობის მოდელირებაში.

Graph-ის იმპლემენტაცია Swift-ში

class GraphNode<T> {
    var value: T
    var neighbors: [GraphNode] = []

    init(value: T) {
        self.value = value
    }

    func addNeighbor(_ node: GraphNode) {
        neighbors.append(node)
    }
}

let nodeA = GraphNode(value: "A")
let nodeB = GraphNode(value: "B")
let nodeC = GraphNode(value: "C")
nodeA.addNeighbor(nodeB)
nodeB.addNeighbor(nodeC)

შეჯამება

Swift-ში არაწრფივი მონაცემთა სტრუქტურები ეხმარება რთული კავშირების მქონე მონაცემების ორგანიზებას. მათ შორის ყველაზე ხშირად გამოყენებულია:

• Trees — იერარქიული მონაცემებისთვის
• Binary Search Tree (BST) — ეფექტური ძიებისთვის
• Graphs — რთული ურთიერთობების გამოსახატად

ამ სტრუქტურების ცოდნა საშუალებას გაძლევთ შექმნათ უფრო ეფექტური და ოპტიმიზირებული ალგორითმები.

© codecademy , სრული კურსი შეგიძლიათ იხილოთ აქ 👇

[embed]Pass the Technical Interview with Swift | Codecademy *Learn how to use data structures and algorithms in Swift to ace a technical interview. Includes Swift, *Data…www.codecademy.com