delete minmax

#include <stdio.h>
#include <cmath>



class List
{
public:
    struct queue {
        queue(int x) : value(x) {}
        int value;
        queue *next = 0, *prev = 0, *large = 0, *small = 0;
    } *beg = 0, *end = 0, *max = 0, *min = 0;

    void push(int x) {
        queue *p = new queue(x);

        if (end) end->next = p;
        if (!beg) beg = p;

        p->prev = end;
        end = p;

        if (!max || !min) {
            max = min = p;
            return;
        }

        queue *s = min;
        while(s) {
            if (x < s->value) {
                p->large = s;

                if (s->small) {
                    p->small = s->small;
                    s->small->large = p;
                } else {
                    min = p;
                }

                s->small = p;

                return;
            }
            s = s->large;
        }
        p->small = max;
        max->large = p;
        max = p;
    }
    void delete_el() {
        if (last_hit()) return;

        link_max_large(beg);

        queue *p = beg->next;
        delete beg;
        beg = p;
        beg->prev = 0;
    }
    void delete_min() {
        if (last_hit()) return;

        link_prev_next(min);

        queue *p = min->large;
        delete min;
        min = p;
        min->small = 0;
    }
    void delete_max() {
        if (last_hit()) return;

        link_prev_next(max);

        queue *p = max->small;
        delete max;
        max = p;
        max->large = 0;
    }

    bool last_hit() {
        if (beg == end) {
            delete beg;
            beg = end = min = max = 0;
            return true;
        }
        return false;
    }

private:
    void link_prev_next(queue *p) {

        if (p->prev && p->next) {
            p->prev->next = p->next;
            p->next->prev = p->prev;
        }
        if (!p->prev) {
            beg = p->next;
            beg->prev = 0;
        }

        if (!p->next) {
            end = p->prev;
            end->next = 0;
        }
    }
    void link_max_large(queue *p) {
        if (p->small && p->large) {
            p->small->large = p->large;
            p->large->small = p->small;
        }
        else if (!p->large) {
            max = p->small;
            max->large = 0;
        }
        else if (!p->small) {
            min = p->large;
            min->small = 0;
        }
    }

};

int main(int argc, char const *argv[])
{
    List list;

    list.push(1);
    list.push(12);
    list.push(6);
    list.push(24);

    list.delete_min();
    // list.delete_max();
    // list.delete_max();
    // list.delete_max();






    for (List::queue *el = list.min; el; el = el->large)
    // for (List::queue *el = list.max; el; el = el->small)
    // for (List::queue *el = list.beg; el; el = el->next)
    // for (List::queue *el = list.end; el; el = el->prev)
    {
        printf("%i\n", el->value);
    }



}