C#으로 구현한 링크드리스트

 

using System;
 
namespace algorithm_001
{
    public class Node
    {
        public int data;
        public Node next;
    }
 
    class MainClass
    {
        public static void Main(string[] args)
        {
            Console.WriteLine("Hello World!");
 
            //링크드 리스트
            //리스트 내의 각 요소는 노드 라고 부른다.
            //노드들을 연결해서 만드는 리스트라고 해서 붙여진 이름이다.
            //노드는 스택, 큐, 트리등에서 계속 사용될 예정이다.
 
            //리스트는 헤드와 테일을 갖고있다.
            //헤드: 리스트의 첫 노드
            //테일: 리스트의 마지막 노드
 
            //데이터 집합의 크기를 미리 알지못해도 걱정할 필요가 없다.
            //데이터가 늘어날때마다 노드를 만들어 테일에 붙이면 된다.
            //이렇게 붙인 노드는 새로운 테일이 되고 이전 테일이였던 노드는 평범한 노드가 된다.
 
            //리스트 사이에 새로운 노드를 끼워 넣거나 제거 하는것도 아주 쉽다.
            //해당 노드를 가르키는 변수를 교환 해주기만 하면 된다.
 
            //*** 링크드 리스트의 주요 기능 ***
            //노드 생성/소멸
            //노드 추가
            //노드 탐색
            //노드 삭제
            //노드 삽입
 
            var p = new MainClass();
 
            int i = 0;
            int count = 0;
 
            Node list = null;
            Node current = null;
            Node newNode = null;
 
            for (i = 0; i < 5; i++) {
                newNode = p.CreateNode(i);
                p.AppendNode(ref list, newNode);
            }
 
            newNode = p.CreateNode(-1);
            p.InsertNewHead(ref list, newNode);
 
            newNode = p.CreateNode(-2);
            p.InsertNewHead(ref list, newNode);
 
 
            count = p.GetNodeCount(list);
            for (i = 0; i < count; i++) {
                current = p.GetNodeAt(ref list, i);
                Console.WriteLine("list[{0}]: {1}", i, current.data);
            }
 
 
 
        }
 
        public Node CreateNode(int data)
        {
            var node = new Node();
            node.data = data;
            node.next = null;
            return node;
        }
 
        public void AppendNode(ref Node head, Node newNode)
        {
            if (head == null)
            {
                head = newNode;
                Console.WriteLine("head: {0}", head);
            }
            else
            {
                Node tail = head;
                while (tail.next != null) {
                    tail = tail.next;
                }
                tail.next = newNode;
            }
        }
 
        public Node GetNodeAt(ref Node head, int location)
        {
            Node current = head;
 
            while (current != null && --location >= 0)
            {
                current = current.next;
            }
 
            return current;
        }
 
        public void RemoveNode(ref Node head, Node remove) {
            if (head == remove)
            {
                head = remove.next;
            }
            else
            {
                Node current = head;
                while (current != null && current.next != remove) {
                    current = current.next;
                }
 
                if (current != null) {
                    current.next = remove.next;
                }
            }
        }
 
        public void InsertAfter(Node current, Node newNode) {
            newNode.next = current.next;
            current.next = newNode;
        }
 
        public void InsertNewHead(ref Node head, Node newHead) {
            if (head == null)
            {
                head = newHead;
            }
            else {
                newHead.next = head;
                head = newHead;
            }
        }
 
        public int GetNodeCount(Node head) {
            int cnt = 0;
            Node current = head;
            while (current != null) {
                current = current.next;
                cnt++;
            }
            return cnt;
        }
    }
}