list/slist/slist.c

/*
 * @Author: your name
 * @Date: 2021-06-20 17:11:37
 * @LastEditTime: 2021-06-20 19:21:51
 * @LastEditors: Please set LastEditors
 * @Description: In User Settings Edit
 * @FilePath: \slist\slist.c
 */
#include "slist.h"
#include "stdlib.h"
#include "stdio.h"


pkt_node_t pkt_creat_slist(void)
{
    pkt_node_t p;

    p = (pkt_node_t)malloc(sizeof(struct pkt_node));

    p->next = NULL;
    return p;
}

int pkt_get_slist_length(pkt_node_t l)
{
    PKT_ASSERT(l);

    pkt_node_t p = l;
    int i = 0;

    while (p->next)
    {
        p = p->next;
        i++;
        printf("l[%d] = %d\n", i, p->data);
    }

    return i;
}

int pkt_insert_slist_head(pkt_node_t l, data_type data)
{
    PKT_ASSERT(l);
    pkt_node_t p;
    p = (pkt_node_t)malloc(sizeof(struct pkt_node));
    if (p == NULL)
    {
        printf("no mem\n");
        return -1;
    }
    p->next = l->next;
    p->data = data;
    l->next = p;

    return 0;
}

int pkt_insert_slist_by_pos(pkt_node_t l, data_type data, int pos)
{
    PKT_ASSERT(l);
    pkt_node_t p = l;
    int i = 0;

    if (pos < 0)
    {
        printf("error pos is < 0\n");
        return 0;
    }

    while (p && pos > i)
    {
        p = p->next;
        i++;
    }

    if (!p)
    {
        printf("input pos too big!\n");
        return -1;
    }

    pkt_node_t n = (pkt_node_t)malloc(sizeof(struct pkt_node));
    if (n == NULL)
    {
        printf("no mem\n");
        return -1;
    }
    n->data = data;
    n->next = p->next;
    p->next = n;

    return 0;
}

pkt_node_t pkt_find_node_by_pos(pkt_node_t l, int pos)
{
    pkt_node_t p = l->next;
    int i = 0;
    if (pos < 0)
    {
        printf("error pos is < 0\n");
        return NULL;
    }

    while (p->next && pos > i)
    {
        p = p->next;
        i++;
    }

    if (pos == i)
    {
        return p;
    }
    
    printf("input pos is too big\n");
    return NULL;
}

pkt_node_t pkt_find_node_by_data(pkt_node_t l, data_type data)
{
    pkt_node_t p = l->next;

    while (p && p->data != data)
    {
        p = p->next;
    }

    if (p == NULL)
    {
        printf("no find this data node\n");
        return NULL;
    }

    return p;
}

int pkt_del_node_by_pos(pkt_node_t l, int pos)
{
    PKT_ASSERT(l);

    if (pos < 0)
    {
        printf("error pos is < 0\n");
        return -1;
    }

    pkt_node_t p;

    if (pos == 0)
    {
        p = l;
    }
    else
    {
        p = pkt_find_node_by_pos(l, pos - 1);
    }

    if (p == NULL && p->next) /* if [->next == NULL],  is at list tail, did not del tail->next */
    {
        return -1;
    }

    pkt_node_t del = p->next;
    p->next = p->next->next;
    free(del);
    return 0;
}

/* delete node from list */
int pkt_del_node(pkt_node_t l, pkt_node_t n)
{
    pkt_node_t p = l;
    
    while (p && p->next != n)
    {
        p = p->next;
    }

    if (!p->next)
    {
        return -1;
    }

    p->next = p->next->next;
    free(n);
    return 0;
}

/* frist find the node by data, then delete node */
int pkt_del_node_by_data(pkt_node_t l, data_type data)
{
    PKT_ASSERT(l);
    pkt_node_t p;

    if ((p = pkt_find_node_by_data(l, data)) == NULL)
    {
        return -1;
    }

    return pkt_del_node(l, p);
}

int pkt_rever_slist(pkt_node_t l)
{
    PKT_ASSERT(l);

    if (!l->next)
    {
        printf("this is a empty list\n");
        return -1;
    }
#if 0
    pkt_node_t p1 = l->next;
    pkt_node_t p2 = l->next->next;
    p1->next = NULL;

    pkt_node_t tmp;
    while (p2)
    {
        tmp = p2->next;
        p2->next = p1;
        p1 = p2;
        p2 = tmp;
    }

    l->next = p1; /* head next point p1 */
#else
    pkt_node_t p1 = l->next;
    pkt_node_t tmp;
    l->next = NULL; /* empty the list */

    while (p1)
    {
        tmp = p1;  /* unattach a node tmp */
        p1 = p1->next;
        tmp->next = l->next; /* insert tmp node to head */
        l->next = tmp;
    }

#endif
    return 0;
}

int pkt_insert_node_by_data_order(pkt_node_t l, data_type data)
{
    PKT_ASSERT(l);
    pkt_node_t p = l;

    while (p->next && data < p->next->data)
    {
        p = p->next;
    }

    pkt_node_t n = (pkt_node_t)malloc(sizeof(struct pkt_node));
    if (n == NULL)
    {
        return -1;
    }

    n->data = data;
    n->next = p->next;
    p->next = n;

    return 0;
}

int pkt_list_by_data_order(pkt_node_t l)
{
    PKT_ASSERT(l);

    if (!l->next || !l->next->next)
    {
        printf("this list node <= 1\n");
        return -1;
    }

    pkt_node_t p = l->next->next;
    pkt_node_t r = l;
    r->next->next = NULL;
    pkt_node_t q;
    
    while (p->next)
    {
        q = p;
        p = p->next;
        
        r = l;
        while (r->next && q->data > r->next->data) /* ascending order */
        {
            r = r->next;
        }
        q->next = r->next;
        r->next = q;
    }

    return 0;
}

int pkt_list_by_data_order_with_fun(pkt_node_t l, int (*cmp)(pkt_node_t l1, pkt_node_t l2))
{
    PKT_ASSERT(l);

    if (!l->next || !l->next->next)
    {
        printf("this list node <= 1\n");
        return -1;
    }

    pkt_node_t p = l->next->next;
    pkt_node_t r = l;
    r->next->next = NULL;
    pkt_node_t q;

    while (p->next)
    {
        q = p;
        p = p->next;
        
        r = l;
        while (r->next && !cmp(r->next, q))
        {
            r = r->next;
        }
        q->next = r->next;
        r->next = q;
    }

    return 0;
}

int cmp(pkt_node_t l1, pkt_node_t l2)
{
    if (l2->data > l1->data)
    {
        return 0;
    }

    return 1;
}

int main(int argc, char **argv)
{
    pkt_node_t slist;

    slist = pkt_creat_slist();
#if 1
    pkt_insert_slist_head(slist, 22);
    pkt_insert_slist_head(slist, 47);
    pkt_insert_slist_head(slist, 89);
    pkt_insert_slist_head(slist, 44);
    pkt_insert_slist_head(slist, 6568);
    pkt_insert_slist_head(slist, 77);
#else
    pkt_insert_node_by_data_order(slist, 99);
    pkt_insert_node_by_data_order(slist, 1);
    pkt_insert_node_by_data_order(slist, 5);
#endif
    pkt_list_by_data_order(slist);
    pkt_get_slist_length(slist);
  int pos;
  while (1)
  {
  scanf("%d", &pos);
#if 0
    pkt_node_t node = pkt_find_node_by_pos(slist, pos);

    if (node)
    {
        printf("pos%d data: %d\n", pos, node->data);
    }
#elif 0
    pkt_find_node_by_data(slist, pos);
#elif 0
    pkt_insert_slist_by_pos(slist, 100, pos);
    pkt_get_slist_length(slist);
#elif 0
    pkt_del_node_by_pos(slist, pos);
    pkt_get_slist_length(slist);
#elif 0
    pkt_del_node_by_data(slist, pos);
    pkt_get_slist_length(slist);
#elif 0
    printf("==========================================\n");
    pkt_rever_slist(slist);
    pkt_get_slist_length(slist);
#elif 1
    pkt_insert_node_by_data_order(slist, pos);
    pkt_get_slist_length(slist);
  }
#endif
    return 0;
}