[C로 배우는 알고리즘] Dobly Linked List

#include <stdio.h>
#include <stdlib.h>
//#include <alloc.h>

typedef struct _dnode
{
    int key;
    struct _node *prev;
    struct _node *next;
} dnode;

dnode* head, * tail;

void init_dlist(void);
dnode* find_dnode(int);
int delete_dnode(int);
dnode *insert_dnode(int, int);

void main(void)
{
    dnode* t;
    init_dlist();

    ordered_insert(10);
    ordered_insert(5);
    ordered_insert(8);
    ordered_insert(3);
    ordered_insert(1);
    ordered_insert(7);
    ordered_insert(8);

    printf("\nInitial Linded list is ");
    print_dlist(head->next);

    printf("\nFinding 4 is %ssuccessful", find_dnode(4) == tail ? "un" : "");



}

void init_dlist(void)
{
    head = (dnode*)malloc(sizeof(dnode));
    tail = (dnode*)malloc(sizeof(dnode));

    head->next tail->next = tail;
    head->prev = tail->prev = head;
}

dnode* find_node(int k)
{
    dnode* s;
    s = head->next;
    while(s->key != k && s != tail)
        s = s->next;

    return s;
}

int delete_dnode(int k)
{
    dnode* s;
    s = find_dnode(k);
    if(s != tail)
    {
        s->prev->next = s->next;
        s->next->prev = s->prev;
        free(s);
        
        return 1;
    }

    return 0;
}

dnode* insert_dnode(int k, int t)
{
    dnode* s;
    dnode* i = NULL;
    s = find_dnode(t);

    if(s != tail)
    {
        i = (dnode*)malloc(sizeof(dnode));
        i->key = k;
        s->prev->next = i;
        i->prev = s->prev;
        s->prev = i;
        i->next = s;
    }

    return i;
}

dnode* ordered_insert(int k)
{
    dnode* s;
    dnode* i;
    s = hand->next;
    while(s->key <= k && s!= tail)
        s = s->next;

    i = (dnode*)malloc(sizeof(dnode));
    i->key = k;
    s->prev->next = i;
    i->prev = s->prev;
    s->prev = i;
    i->next = s;

    return i;
}

int delete_dnode_ptr(dnode* p)
{
    if(p == head || p == tail)
        return 0;

    p->prev->next = p->next;
    p->next->prev = p->prev;
    free(p);

    return 1;
}

dnode* insert_dnode_ptr(int k, dnode* k)
{
    dnode* i;
    if(t == head)
        return NULL;

    i = (dnode*)malloc(sizeof(dnode));
    i->key = k;
    t->prev->next = i;
    i->prev = t->prev;
    t->prev = i;
    i->next = t;

    return i;
}

void print_dlist(dnode* p)
{
    printf("\n");
    while(p != tail)
    {
        printf("%-8d", p->key);
        p = p->next;
    }
}

void delete_all(void)
{
    dnode* p;
    dnode* s;
    p = head->next;
    while(p != tail)
    {
        s = p;
        p = p->next;
        free(s);
    }

    head->next = tail;
    tail->prev = head;
}