Using C language to realize bidirectional linked list

Use c Language implementation of two-way linked list

Studying recently C Language , In the study , Have a new understanding of a lot of knowledge .

I am from java Start learning programming , Now I've learned it again C in the future , It strengthened my recognition of my own learning route . C It's a programming language you have to learn , But it is by no means the first door .

There are several reasons why I firmly believe in this idea ：

1. c The language is too low , If you start with C Start learning the main language , Study 、 Understanding the cost is relatively large , In this way, the efficiency will not be so high .
2. C The dominant domain of language is very different from other programming languages . such as java Good at web,c++ Good at client , and C Suitable system . The job threshold of system development is high , It requires a high level of language understanding and development ability . And I find it hard to reach .
3. c The language is too low , Process oriented , Manual memory , Grammar is simple . The development process seems to be implemented bit by bit . Really adapted C Then turn to other languages , You will feel limited everywhere . This is how the discrimination chain between languages comes into being .

I'm glad I have learned twoorthree advanced languages , Go back to study C. Maybe I won't be engaged in direct C Development work , but C It must have a great impact on my programming thoughts .

I've heard many people say before , Write C It's from 0 Start , In addition to simple function libraries , There's nothing left . The data structure needs to be implemented by itself . I'm learning java when , I have read most data structure Source code , And put it into practice . Two years later , use c Once again , Should have different feelings .

• The header file ：

#ifndef LINKED_LIST_H
#define LINKED_LIST_H

#include <stddef.h>

typedef int ll_data_t;
struct list;

// constructs a new (empty) list
struct list *list_create(void);

// counts the items on a list
size_t list_count(const struct list *list);

// inserts item at back of a list
void list_push(struct list *list, ll_data_t item_data);

// removes item from back of a list
ll_data_t list_pop(struct list *list);

// inserts item at front of a list
void list_unshift(struct list *list, ll_data_t item_data);

// removes item from front of a list
ll_data_t list_shift(struct list *list);

// deletes a node that holds the matching data
void list_delete(struct list *list, ll_data_t data);

// destroys an entire list
// list will be a dangling pointer after calling this method on it
void list_destroy(struct list *list);

#endif

• Source file

#include "linked_list.h"
#include <stdlib.h>

struct list_node
{
    
   struct list_node *prev, *next;
   ll_data_t data;
};

struct list
{
    
   struct list_node *first, *last;
};

// constructs a new (empty) list
struct list *list_create(void)
{
    
   struct list *res = malloc(sizeof(struct list));
   res->first = NULL;
   res->last = NULL;
   return res;
}

// counts the items on a list
size_t list_count(const struct list *list)
{
    
   if (!list)
      return 0;
   struct list_node *list_node = list->first;
   size_t res = 0;
   while (list_node)
   {
    
      res++;
      list_node = list_node->next;
   }
   return res;
}

// inserts item at back of a list
void list_push(struct list *list, ll_data_t item_data)
{
    
   if (!list)
   {
    
      return;
   }
   struct list_node *node = malloc(sizeof(struct list_node));
   node->next = NULL;
   node->data = item_data;
   node->prev = list->last;
   if (!(list->first))
   {
    
      list->first = node;
   }
   else
   {
    
      list->last->next = node;
   }
   list->last = node;
}

// removes item from back of a list
ll_data_t list_pop(struct list *list)
{
    
   struct list_node *prev = list->last->prev;
   ll_data_t res = list->last->data;

   if (!prev)
   {
    
      list->first = NULL;
   }
   else
   {
    
      prev->next = NULL;
   }
   free(list->last);
   list->last = prev;
   return res;
}

// inserts item at front of a list
void list_unshift(struct list *list, ll_data_t item_data)
{
    
   if(!list)
    {
     return;}
    struct list_node *new_node = malloc(sizeof(struct list_node));
    new_node->data = item_data;
    new_node->prev = NULL;
    new_node->next = (list->first) ? list->first : NULL;
    
    list->first = new_node;
}

// removes item from front of a list
ll_data_t list_shift(struct list *list)
{
    
   if(!list || !list->first) 
    {
     return 0;}
    struct list_node *first = list->first;
    ll_data_t val = first->data;
    
    if(!list->first->next) {
    
        // node was the only item in the list 
        list->first = NULL;
        list->last= NULL;
    } else {
    
        list->first = first->next;
        list->first->prev = NULL;
    }
    free(first);
    return val;
}

// deletes a node that holds the matching data
void list_delete(struct list *list, ll_data_t data)
{
    
   if (!list)
      return;
   struct list_node *next = list->first;
   while (next)
   {
    

      if (next->data == data)
      {
    
         if (!next->prev)
         {
    
            list->first = next->next;
         }
         else
         {
    
            next->prev->next = next->next;
         }
         if (!next->next)
         {
    
            list->last = next->prev;
         }
         else
         {
    
            next->next->prev = next->prev;
         }
         free(next);
         break;
      }
      next = next->next;
   }
}

// destroys an entire list
// list will be a dangling pointer after calling this method on it
void list_destroy(struct list *list)
{
    
   if (!list)
   {
    
      return;
   }
   struct list_node *node = list->first;
   while (node)
   {
    
      struct list_node *tmp = node->next;
      free(node);
      node = tmp;
   }
   free(list);
}