C#으로 이중 연결 리스트 구현하기

이 글에서는 C# 언어를 사용하여 이중 연결 리스트를 구현하는 간단한 예제를 살펴보겠습니다. 이중 연결 리스트는 각 요소에 시퀀스의 이전 요소와 다음 요소에 대한 참조를 포함하는 요소들의 나열로 구성된 데이터 구조입니다. 이를 통해 정방향과 역방향 모두에서 효율적인 순회가 가능하며, 단일 연결 리스트의 제한을 해결할 수 있습니다.

소스 코드: DoublyLinkedList.cs

using System;

namespace DoublyLinkedList
{
    public class Node
    {
        public Node PrevNode;   // 역방향 포인터
        public string Name;      // 이름
        public string Phone;     // 전화번호
        public Node NextNode;    // 정방향 포인터
    }

    class Program
    {
        static Node GetNode()
        {
            return new Node();
        }

        static void Main(string[] args)
        {
            Node head, tail, current;

            // 역방향 리스트 생성
            tail = null;

            current = GetNode();
            current.Name = "aa";
            current.Phone = "11";

            current.PrevNode = tail;
            tail = current;

            current = GetNode();
            current.Name = "bb";
            current.Phone = "22";

            current.PrevNode = tail;
            tail = current;

            current = GetNode();
            current.Name = "cc";
            current.Phone = "33";

            current.PrevNode = tail;
            tail = current;

            // 정방향 리스트 생성
            current = tail;
            head = null;

            current.NextNode = head;
            head = current;
            current = current.PrevNode;

            current.NextNode = head;
            head = current;
            current = current.PrevNode;

            current.NextNode = head;
            head = current;
            current = current.PrevNode;

            // 정방향 리스트 출력
            current = head;

            Console.WriteLine($"{current.Name} {current.Phone}");
            current = current.NextNode;

            Console.WriteLine($"{current.Name} {current.Phone}");
            current = current.NextNode;

            Console.WriteLine($"{current.Name} {current.Phone}");
            current = current.NextNode;

            // 역방향 리스트 출력
            current = tail;

            Console.WriteLine($"{current.Name} {current.Phone}");
            current = current.PrevNode;

            Console.WriteLine($"{current.Name} {current.Phone}");
            current = current.PrevNode;

            Console.WriteLine($"{current.Name} {current.Phone}");
            current = current.PrevNode;
        }
    }
}

aa 11
bb 22
cc 33
cc 33
bb 22
aa 11

이 예제에서는 간단한 이중 연결 리스트를 생성하고 출력하는 과정을 구현하였습니다. 먼저, 이중 연결 리스트를 위한 클래스 Node를 정의하였고, 이후 객체를 생성하는 GetNode() 함수를 작성하였습니다.

Main() 함수에서는 이중 연결 리스트를 생성하고 출력하는 작업을 수행하며, 역방향 리스트와 정방향 리스트를 생성한 다음, 각 리스트를 출력하였습니다. 이 예제를 통해 이중 연결 리스트의 기본적인 개념과 구현 방법을 이해할 수 있습니다. 이중 연결 리스트는 다양한 애플리케이션에서 유용하게 사용될 수 있으며, 필요에 따라 더 복잡한 데이터 구조로 확장될 수 있습니다.

C# 언어를 사용하여 구현한 이중 연결 리스트 예제는 C 언어로 구현한 예제와 비슷하게 작동하며, 주요 차이점은 C#에서는 메모리 관리를 가비지 컬렉터가 자동으로 수행하기 때문에 동적 메모리 할당 및 해제를 수동으로 처리할 필요가 없다는 점입니다. 이러한 차이점을 고려하면서 예제를 따라하면서 이중 연결 리스트에 대한 이해를 높일 수 있습니다.

C 언어로 이중 연결 리스트 구현하기

이 글에서는 C 언어를 사용하여 이중 연결 리스트를 구현하는 간단한 예제를 살펴보겠습니다. 이중 연결 리스트는 각 요소에 시퀀스의 이전 요소와 다음 요소에 대한 참조를 포함하는 요소들의 나열로 구성된 데이터 구조입니다. 이를 통해 정방향과 역방향 모두에서 효율적인 순회가 가능하며, 단일 연결 리스트의 제한을 해결할 수 있습니다.

소스 코드: doubly_linked_list.c

/*
	이중 연결 리스트(Doubly Linked List) :
	선형 리스트는 역방향 조회를 할 수 없는 단점이 있다.
	이를 개선한 데이터 구조가 이중 연결 리스트이다.
*/
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// 이중 연결 링크드 리스트용 구조체
struct Node
{
	struct Node* PrevNode;		//역방향 포인터
	char Name[20];			//이름
	char Phone[20];			//전화번호
	struct Node* NextNode;	//정방향 포인터
};

struct Node* GetNode(void);

// 메인 함수
int main(void)
{
	int i = 0;
	struct Node* head, * tail, * current;

	//역방향 리스트 생성
	tail = NULL;

	current = GetNode();
	strcpy(current->Name, "aa");
	strcpy(current->Phone, "11");

	current->PrevNode = tail;
	tail = current;

	current = GetNode();
	strcpy(current->Name, "bb");
	strcpy(current->Phone, "22");

	current->PrevNode = tail;
	tail = current;

	current = GetNode();
	strcpy(current->Name, "cc");
	strcpy(current->Phone, "33");

	current->PrevNode = tail;
	tail = current;

	// 정방향 리스트 생성
	current = tail;
	head = NULL;

	current->NextNode = head;
	head = current;
	current = current->PrevNode;

	current->NextNode = head;
	head = current;
	current = current->PrevNode;

	current->NextNode = head;
	head = current;
	current = current->PrevNode;

	// 정방향 리스트 출력
	current = head;

	printf("%s %s\n", current->Name, current->Phone);
	current = current->NextNode;

	printf("%s %s\n", current->Name, current->Phone);
	current = current->NextNode;

	printf("%s %s\n", current->Name, current->Phone);
	current = current->NextNode;

	// 역방향 리스트 출력
	current = tail;

	printf("%s %s\n", current->Name, current->Phone);
	current = current->PrevNode;

	printf("%s %s\n", current->Name, current->Phone);
	current = current->PrevNode;

	printf("%s %s\n", current->Name, current->Phone);
	current = current->PrevNode;

	// 메모리 해제
	while (head != NULL)
	{
		current = head;
		head = head->NextNode;
		free(current);
	}
}

// 구조체 크기만큼 메모리 할당
struct Node* GetNode(void)
{
	return (struct Node*)malloc(sizeof(struct Node));
}

aa 11
bb 22
cc 33
cc 33
bb 22
aa 11

이 예제에서는 간단한 이중 연결 리스트를 생성하고 출력하는 과정을 구현하였습니다. 먼저, 이중 연결 리스트를 위한 구조체 Node를 정의하였고, 이후 메모리를 동적으로 할당하여 노드를 생성하는 GetNode() 함수를 작성하였습니다.

main() 함수에서는 이중 연결 리스트를 생성하고 출력하는 작업을 수행하며, 역방향 리스트와 정방향 리스트를 생성한 다음, 각 리스트를 출력하였습니다. 마지막으로, 동적으로 할당된 메모리를 해제하는 작업을 수행하여 메모리 누수를 방지하였습니다.

이 예제를 통해 이중 연결 리스트의 기본적인 개념과 구현 방법을 이해할 수 있습니다. 이중 연결 리스트는 다양한 애플리케이션에서 유용하게 사용될 수 있으며, 필요에 따라 더 복잡한 데이터 구조로 확장될 수 있습니다.

Java로 이중 연결 리스트 구현하기

이 글에서는 Java 언어를 사용하여 이중 연결 리스트를 구현하는 간단한 예제를 살펴보겠습니다. 이중 연결 리스트는 각 요소에 시퀀스의 이전 요소와 다음 요소에 대한 참조를 포함하는 요소들의 나열로 구성된 데이터 구조입니다. 이를 통해 정방향과 역방향 모두에서 효율적인 순회가 가능하며, 단일 연결 리스트의 제한을 해결할 수 있습니다.

소스 코드: DoublyLinkedList.java

public class DoublyLinkedList {
    static class Node {
        Node prevNode;   // 역방향 포인터
        String name;     // 이름
        String phone;    // 전화번호
        Node nextNode;   // 정방향 포인터
    }

    static Node getNode() {
        return new Node();
    }

    public static void main(String[] args) {
        Node head, tail, current;

        // 역방향 리스트 생성
        tail = null;

        current = getNode();
        current.name = "aa";
        current.phone = "11";

        current.prevNode = tail;
        tail = current;

        current = getNode();
        current.name = "bb";
        current.phone = "22";

        current.prevNode = tail;
        tail = current;

        current = getNode();
        current.name = "cc";
        current.phone = "33";

        current.prevNode = tail;
        tail = current;

        // 정방향 리스트 생성
        current = tail;
        head = null;

        current.nextNode = head;
        head = current;
        current = current.prevNode;

        current.nextNode = head;
        head = current;
        current = current.prevNode;

        current.nextNode = head;
        head = current;
        current = current.prevNode;

        // 정방향 리스트 출력
        current = head;

        System.out.println(current.name + " " + current.phone);
        current = current.nextNode;

        System.out.println(current.name + " " + current.phone);
        current = current.nextNode;

        System.out.println(current.name + " " + current.phone);
        current = current.nextNode;

        // 역방향 리스트 출력
        current = tail;

        System.out.println(current.name + " " + current.phone);
        current = current.prevNode;

        System.out.println(current.name + " " + current.phone);
        current = current.prevNode;

        System.out.println(current.name + " " + current.phone);
        current = current.prevNode;
    }
}

이 예제에서는 간단한 이중 연결 리스트를 생성하고 출력하는 과정을 구현하였습니다. 먼저, 이중 연결 리스트를 위한 클래스 Node를 정의하였고, 이후 객체를 생성하는 getNode() 함수를 작성하였습니다.

main() 함수에서는 이중 연결 리스트를 생성하고 출력하는 작업을 수행하며, 역방향 리스트와 정방향 리스트를 생성한 다음, 각 리스트를 출력하였습니다.

Python으로 이중 연결 리스트 구현하기

이 글에서는 Python 언어를 사용하여 이중 연결 리스트를 구현하는 간단한 예제를 살펴보겠습니다. 이중 연결 리스트는 각 요소에 시퀀스의 이전 요소와 다음 요소에 대한 참조를 포함하는 요소들의 나열로 구성된 데이터 구조입니다. 이를 통해 정방향과 역방향 모두에서 효율적인 순회가 가능하며, 단일 연결 리스트의 제한을 해결할 수 있습니다.

소스 코드: doubly_linked_list.py

class Node:
    def __init__(self, name=None, phone=None):
        self.prev_node = None
        self.name = name
        self.phone = phone
        self.next_node = None


def main():
    head, tail, current = None, None, None

    # 역방향 리스트 생성
    current = Node("aa", "11")
    tail = current

    current = Node("bb", "22")
    current.prev_node = tail
    tail = current

    current = Node("cc", "33")
    current.prev_node = tail
    tail = current

    # 정방향 리스트 생성
    current = tail
    head = None

    current.next_node = head
    head = current
    current = current.prev_node

    current.next_node = head
    head = current
    current = current.prev_node

    current.next_node = head
    head = current

    # 정방향 리스트 출력
    current = head

    print(f'{current.name} {current.phone}')
    current = current.next_node

    print(f'{current.name} {current.phone}')
    current = current.next_node

    print(f'{current.name} {current.phone}')
    current = current.next_node

    # 역방향 리스트 출력
    current = tail

    print(f'{current.name} {current.phone}')
    current = current.prev_node

    print(f'{current.name} {current.phone}')
    current = current.prev_node

    print(f'{current.name} {current.phone}')


if __name__ == '__main__':
    main()

이 예제에서는 간단한 이중 연결 리스트를 생성하고 출력하는 과정을 구현하였습니다. 먼저, 이중 연결 리스트를 위한 클래스 Node를 정의하였습니다.

main() 함수에서는 이중 연결 리스트를 생성하고 출력하는 작업을 수행하며, 역방향 리스트와 정방향 리스트를 생성한 다음, 각 리스트를 출력하였습니다. 이 예제를 통해 이중 연결 리스트의 기본적인 개념과 구현 방법을 이해할 수 있습니다. 이중 연결 리스트는 다양한 애플리케이션에서 유용하게 사용될 수 있으며, 필요에 따라 더 복잡한 데이터 구조로 확장될 수 있습니다.

JavaScript로 이중 연결 리스트 구현하기

이 글에서는 JavaScript 언어를 사용하여 이중 연결 리스트를 구현하는 간단한 예제를 살펴보겠습니다. 이중 연결 리스트는 각 요소에 시퀀스의 이전 요소와 다음 요소에 대한 참조를 포함하는 요소들의 나열로 구성된 데이터 구조입니다. 이를 통해 정방향과 역방향 모두에서 효율적인 순회가 가능하며, 단일 연결 리스트의 제한을 해결할 수 있습니다.

소스 코드: doubly_linked_list.js

class Node {
    constructor(name = null, phone = null) {
        this.prevNode = null;
        this.name = name;
        this.phone = phone;
        this.nextNode = null;
    }
}

function main() {
    let head, tail, current;
    head = tail = current = null;

    // 역방향 리스트 생성
    current = new Node("aa", "11");
    tail = current;

    current = new Node("bb", "22");
    current.prevNode = tail;
    tail = current;

    current = new Node("cc", "33");
    current.prevNode = tail;
    tail = current;

    // 정방향 리스트 생성
    current = tail;
    head = null;

    current.nextNode = head;
    head = current;
    current = current.prevNode;

    current.nextNode = head;
    head = current;
    current = current.prevNode;

    current.nextNode = head;
    head = current;

    // 정방향 리스트 출력
    current = head;

    console.log(`${current.name} ${current.phone}`);
    current = current.nextNode;

    console.log(`${current.name} ${current.phone}`);
    current = current.nextNode;

    console.log(`${current.name} ${current.phone}`);
    current = current.nextNode;

    // 역방향 리스트 출력
    current = tail;

    console.log(`${current.name} ${current.phone}`);
    current = current.prevNode;

    console.log(`${current.name} ${current.phone}`);
    current = current.prevNode;

    console.log(`${current.name} ${current.phone}`);
}

main();

이 예제에서는 간단한 이중 연결 리스트를 생성하고 출력하는 과정을 구현하였습니다. 먼저, 이중 연결 리스트를 위한 클래스 Node를 정의하였습니다.

main() 함수에서는 이중 연결 리스트를 생성하고 출력하는 작업을 수행하며, 역방향 리스트와 정방향 리스트를 생성한 다음, 각 리스트를 출력하였습니다. 이 예제를 통해 이중 연결 리스트의 기본적인 개념과 구현 방법을 이해할 수 있습니다. 이중 연결 리스트는 다양한 애플리케이션에서 유용하게 사용될 수 있으며, 필요에 따라 더 복잡한 데이터 구조로 확장될 수 있습니다.

C++로 이중 연결 리스트 구현하기

이 글에서는 C++ 언어를 사용하여 이중 연결 리스트를 구현하는 간단한 예제를 살펴보겠습니다. 이중 연결 리스트는 각 요소에 시퀀스의 이전 요소와 다음 요소에 대한 참조를 포함하는 요소들의 나열로 구성된 데이터 구조입니다. 이를 통해 정방향과 역방향 모두에서 효율적인 순회가 가능하며, 단일 연결 리스트의 제한을 해결할 수 있습니다.

소스 코드: doubly_linked_list.cpp

#include <iostream>
#include <string>

class Node {
public:
    Node(std::string name = "", std::string phone = "")
        : prevNode(nullptr), name(name), phone(phone), nextNode(nullptr) {}

    Node* prevNode;
    std::string name;
    std::string phone;
    Node* nextNode;
};

int main() {
    Node* head, *tail, *current;
    head = tail = current = nullptr;

    // 역방향 리스트 생성
    current = new Node("aa", "11");
    tail = current;

    current = new Node("bb", "22");
    current->prevNode = tail;
    tail = current;

    current = new Node("cc", "33");
    current->prevNode = tail;
    tail = current;

    // 정방향 리스트 생성
    current = tail;
    head = nullptr;

    current->nextNode = head;
    head = current;
    current = current->prevNode;

    current->nextNode = head;
    head = current;
    current = current->prevNode;

    current->nextNode = head;
    head = current;

    // 정방향 리스트 출력
    current = head;

    std::cout << current->name << " " << current->phone << std::endl;
    current = current->nextNode;

    std::cout << current->name << " " << current->phone << std::endl;
    current = current->nextNode;

    std::cout << current->name << " " << current->phone << std::endl;
    current = current->nextNode;

    // 역방향 리스트 출력
    current = tail;

    std::cout << current->name << " " << current->phone << std::endl;
    current = current->prevNode;

    std::cout << current->name << " " << current->phone << std::endl;
    current = current->prevNode;

    std::cout << current->name << " " << current->phone << std::endl;

    // 메모리 해제
    while (head != nullptr) {
        current = head;
        head = head->nextNode;
        delete current;
    }

    return 0;
}

이 예제에서는 간단한 이중 연결 리스트를 생성하고 출력하는 과정을 구현하였습니다. 먼저, 이중 연결 리스트를 위한 클래스 Node를 정의하였습니다.

Go로 이중 연결 리스트 구현하기

이 글에서는 Go 언어를 사용하여 이중 연결 리스트를 구현하는 간단한 예제를 살펴보겠습니다. 이중 연결 리스트는 각 요소에 시퀀스의 이전 요소와 다음 요소에 대한 참조를 포함하는 요소들의 나열로 구성된 데이터 구조입니다. 이를 통해 정방향과 역방향 모두에서 효율적인 순회가 가능하며, 단일 연결 리스트의 제한을 해결할 수 있습니다.

소스 코드: doubly_linked_list.go

package main

import (
	"fmt"
)

type Node struct {
	PrevNode *Node
	Name     string
	Phone    string
	NextNode *Node
}

func main() {
	var head, tail, current *Node

	// 역방향 리스트 생성
	current = &Node{Name: "aa", Phone: "11"}
	tail = current

	current = &Node{Name: "bb", Phone: "22", PrevNode: tail}
	tail = current

	current = &Node{Name: "cc", Phone: "33", PrevNode: tail}
	tail = current

	// 정방향 리스트 생성
	current = tail
	head = nil

	current.NextNode = head
	head = current
	current = current.PrevNode

	current.NextNode = head
	head = current
	current = current.PrevNode

	current.NextNode = head
	head = current

	// 정방향 리스트 출력
	current = head

	fmt.Println(current.Name, current.Phone)
	current = current.NextNode

	fmt.Println(current.Name, current.Phone)
	current = current.NextNode

	fmt.Println(current.Name, current.Phone)
	current = current.NextNode

	// 역방향 리스트 출력
	current = tail

	fmt.Println(current.Name, current.Phone)
	current = current.PrevNode

	fmt.Println(current.Name, current.Phone)
	current = current.PrevNode

	fmt.Println(current.Name, current.Phone)
}

이 예제에서는 간단한 이중 연결 리스트를 생성하고 출력하는 과정을 구현하였습니다. 먼저, 이중 연결 리스트를 위한 구조체 Node를 정의하였습니다.

main() 함수에서는 이중 연결 리스트를 생성하고 출력하는 작업을 수행하며, 역방향 리스트와 정방향 리스트를 생성한 다음, 각 리스트를 출력하였습니다. 이 예제를 통해 이중 연결 리스트의 기본적인 개념과 구현 방법을 이해할 수 있습니다. 이중 연결 리스트는 다양한 애플리케이션에서 유용하게 사용될 수 있으며, 필요에 따라 더 복잡한 데이터 구조로 확장될 수 있습니다.

Rust로 이중 연결 리스트 구현하기

이 글에서는 Rust 언어를 사용하여 이중 연결 리스트를 구현하는 간단한 예제를 살펴보겠습니다. 이중 연결 리스트는 각 요소에 시퀀스의 이전 요소와 다음 요소에 대한 참조를 포함하는 요소들의 나열로 구성된 데이터 구조입니다. 이를 통해 정방향과 역방향 모두에서 효율적인 순회가 가능하며, 단일 연결 리스트의 제한을 해결할 수 있습니다.

소스 코드: doubly_linked_list.rs

use std::cell::RefCell;
use std::rc::Rc;

type Link = Option<Rc<RefCell<Node>>>;

struct Node {
    prev: Link,
    name: String,
    phone: String,
    next: Link,
}

impl Node {
    fn new(name: &str, phone: &str) -> Rc<RefCell<Self>> {
        Rc::new(RefCell::new(Node {
            prev: None,
            name: name.to_string(),
            phone: phone.to_string(),
            next: None,
        }))
    }
}

fn main() {
    let mut head: Link;
    let mut tail: Link;
    let mut current: Link;

    // 역방향 리스트 생성
    current = Some(Node::new("aa", "11"));
    tail = current.clone();

    current = Some(Node::new("bb", "22"));
    current.as_ref().unwrap().borrow_mut().prev = tail.clone();
    tail = current.clone();

    current = Some(Node::new("cc", "33"));
    current.as_ref().unwrap().borrow_mut().prev = tail.clone();
    tail = current.clone();

    // 정방향 리스트 생성
    current = tail.clone();
    head = None;

    current.as_ref().unwrap().borrow_mut().next = head.clone();
    head = current.clone();
    current = current.as_ref().unwrap().borrow().prev.clone();

    current.as_ref().unwrap().borrow_mut().next = head.clone();
    head = current.clone();
    current = current.as_ref().unwrap().borrow().prev.clone();

    current.as_ref().unwrap().borrow_mut().next = head.clone();
    head = current.clone();

    // 정방향 리스트 출력
    current = head.clone();

    println!(
        "{} {}",
        current.as_ref().unwrap().borrow().name,
        current.as_ref().unwrap().borrow().phone
    );
    current = current.as_ref().unwrap().borrow().next.clone();

    println!(
        "{} {}",
        current.as_ref().unwrap().borrow().name,
        current.as_ref().unwrap().borrow().phone
    );
    current = current.as_ref().unwrap().borrow().next.clone();

    println!(
        "{} {}",
        current.as_ref().unwrap().borrow().name,
        current.as_ref().unwrap().borrow().phone
    );

    // 역방향 리스트 출력
    current = tail.clone();

    println!(
        "{} {}",
        current.as_ref().unwrap().borrow().name,
        current.as_ref().unwrap().borrow().phone
    );
    current = current.as_ref().unwrap().borrow().prev.clone();

    println!(
        "{} {}",
        current.as_ref().unwrap().borrow().name,
        current.as_ref().unwrap().borrow().phone
    );
    current = current.as_ref().unwrap().borrow().prev.clone();

    println!(
        "{} {}",
        current.as_ref().unwrap().borrow().name,
        current.as_ref().unwrap().borrow().phone
    );
}

이 예제에서는 간단한 이중 연결 리스트를 생성하고 출력하는 과정을 구현하였습니다. 먼저, 이중 연결 리스트를 위한 구조체 Node를 정의하였고, 이후 노드를 생성하는 new 함수를 작성하였습니다.

main() 함수에서는 이중 연결 리스트를 생성하고 출력하는 작업을 수행하며, 역방향 리스트와 정방향 리스트를 생성한 다음, 각 리스트를 출력하였습니다.

이 예제를 통해 이중 연결 리스트의 기본적인 개념과 구현 방법을 이해할 수 있습니다. 이중 연결 리스트는 다양한 애플리케이션에서 유용하게 사용될 수 있으며, 필요에 따라 더 복잡한 데이터 구조로 확장될 수 있습니다.

Regenerat

TypeScript로 이중 연결 리스트 구현하기

이 글에서는 TypeScript를 사용하여 이중 연결 리스트를 구현하는 간단한 예제를 살펴보겠습니다. 이중 연결 리스트는 각 요소에 시퀀스의 이전 요소와 다음 요소에 대한 참조를 포함하는 요소들의 나열로 구성된 데이터 구조입니다. 이를 통해 정방향과 역방향 모두에서 효율적인 순회가 가능하며, 단일 연결 리스트의 제한을 해결할 수 있습니다.

소스 코드: doubly_linked_list.ts

class Node {
  prev: Node | null;
  name: string;
  phone: string;
  next: Node | null;

  constructor(name: string, phone: string) {
    this.prev = null;
    this.name = name;
    this.phone = phone;
    this.next = null;
  }
}

function main() {
  let head: Node | null;
  let tail: Node | null;
  let current: Node | null;

  // 역방향 리스트 생성
  current = new Node("aa", "11");
  tail = current;

  current = new Node("bb", "22");
  current.prev = tail;
  tail = current;

  current = new Node("cc", "33");
  current.prev = tail;
  tail = current;

  // 정방향 리스트 생성
  current = tail;
  head = null;

  current.next = head;
  head = current;
  current = current.prev;

  current.next = head;
  head = current;
  current = current.prev;

  current.next = head;
  head = current;

  // 정방향 리스트 출력
  current = head;

  console.log(`${current.name} ${current.phone}`);
  current = current.next;

  console.log(`${current.name} ${current.phone}`);
  current = current.next;

  console.log(`${current.name} ${current.phone}`);

  // 역방향 리스트 출력
  current = tail;

  console.log(`${current.name} ${current.phone}`);
  current = current.prev;

  console.log(`${current.name} ${current.phone}`);
  current = current.prev;

  console.log(`${current.name} ${current.phone}`);
}

main();

이 예제에서는 간단한 이중 연결 리스트를 생성하고 출력하는 과정을 구현하였습니다. 먼저, 이중 연결 리스트를 위한 클래스 Node를 정의하였습니다.

main 함수에서는 이중 연결 리스트를 생성하고 출력하는 작업을 수행하며, 역방향 리스트와 정방향 리스트를 생성한 다음, 각 리스트를 출력하였습니다.

이 예제를 통해 이중 연결 리스트의 기본적인 개념과 구현 방법을 이해할 수 있습니다. 이중 연결 리스트는 다양한 애플리케이션에서 유용하게 사용될 수 있으며, 필요에 따라 더 복잡한 데이터 구조로 확장될 수 있습니다.