TIL

🌱 난 오늘 무엇을 공부했을까?

📌 양방향 큐 구현해보기

📍 양방향 큐의 searchNode 구현

func searchNode(index: Int) -> Node<T>? {
        var indexNode = head

        for _ in 0..<index {
            indexNode = indexNode?.next
        }
        return indexNode
    }

🔗 그려보기

📍 양방향 큐의 insert 구현

    func insert(data: T, index: Int) {
        var previousNode: Node<T>?
        var indexNode: Node<T>?
        let newNode = Node<T>(data: data)

        if index > self.index || isEmpty {
            append(data: data)
            return
        } else if index == self.index {
            previousNode = tail?.previous
            indexNode = Node<T>(data: data)
            previousNode?.next = indexNode
            indexNode?.next = tail
        } else if index == 0 {
            head?.previous = newNode
            newNode.next = head
            head = newNode
        } else {
            indexNode = searchNode(index: index)
            previousNode = indexNode?.previous
            previousNode?.next = newNode
            newNode.previous = previousNode
            newNode.next = indexNode
            indexNode?.previous = newNode
        }

        self.index += 1
    }

🔗 그려보기

• index > self.index || isEmpty 리스트가 비어있거나, 원하는 인덱스보다 큰 경우는 append 이용
  
• index == self.index 리스트의 마지막 인덱스에 넣는 경우
  
• index == 0 기존 head를 뒤로 밀어내고 들어가는 경우
  
• 일반적으로 중간에 들어가는 경우
  

📍 양방향 큐의 removeAt 구현

func removeAt(index: Int) -> T? {
        guard !isEmpty else { return nil }
        guard index >= self.index else {
            let indexNode = searchNode(index: index)
            indexNode?.previous?.next = indexNode?.next
            indexNode?.next?.previous = indexNode?.previous
            return indexNode?.data
        }
        guard index != self.index else {
            let data = tail?.data
            tail?.previous?.next = nil
            tail = tail?.previous
            return data
        }
        return nil
    }

🔗 그려보기

• index < self.index
  
• index == self.index
  

📌 의존성

• 한 클래스가 다른 클래스의 기능을 사용할 때 발생한다.

📍 의존성 주입

• 쉽게 말하면 한 클래스가 다른 클래스에게 인스턴스를 주입하는거다.
• 주입 : 내부가 아니라 외부에서 객체를 생성해서 넣어주는 것

🔗 의존성 주입의 장점

• 결합도를 낮춰서 의존성을 줄려 유지보수가 용이해진다.
• 재사용성이 증가한다.
• 리팩토링이 수월하다.

📍 의존성 역전 원리(Dependency Inversion Principle)

• 고수준 모듈은 저수준 모듈의 구현에 의존해서는 안 된다. 저수준 모듈이 고수준 모듈에서 정의한 추상 타입에 의존해야 한다.