C语言--线性表--双链表

1. main.c

//
//  main.c
//  5_DLL Double link list
//
//  Created by LS on 2022/5/18.
//  Copyright © 2022 LSC001. All rights reserved.
//


#include "DLList.h"

int main() {
    List mylist;
    InitList(&mylist);
    List newlist;
    InitList(&newlist);
    
    int select=1;
    Elemtype value=0;
    while(select)
    {
        printf("*******************************************\n");
        printf("* [1]  push_back         [2]  push_front  *\n");
        printf("* [3]  show_list         [4]  pop_back    *\n");
        printf("* [5]  pop_front         [6]  insert_val  *\n");
        printf("* [7]  find              [8]  length      *\n");
        printf("* [9]  delete_val        [10] sort        *\n");
        printf("* [11] reverse           [12] clear       *\n");
        printf("* [13] destroy           [14] quit_system *\n");
        printf("*******************************************\n");
        printf("请选择：> ");
        scanf("%d",&select);
        if(0 == select)
            break;
        
        switch (select)
        {
            case 1:
                printf("Please input a number(-1 end): ");
                while(scanf("%d",&value),value!= -1)
                {
                    push_back(&mylist,value);
                }
                show_list(mylist);
                break;
            case 2:
                printf("Please input a number(-1 end) : ");
                while(scanf("%d",&value),value!= -1)
                {
                    push_front(&mylist,value);
                }
                show_list(mylist);
                break;
            case 3:
                show_list(mylist);
                break;
            case 4:
                pop_back(&mylist,&value);
                show_list(mylist);
                break;
            case 5:
                pop_front(&mylist);
                show_list(mylist);
                break;
            case 6:
                printf("Please input pos,value : ");
                int pos;
                scanf("%d,%d,",&pos,&value);
                insert_val(&mylist,pos,value);
                show_list(mylist);
                break;
            case 7:
                printf("Please input value : ");
                scanf("%d",&value);
                PLnode p = find(mylist,value);
                if(!p)printf("No value in List.\n");
                break;
            case 8:
                printf("length: %d\n",length(mylist));
                break;
            case 9:
                printf("Please input value : ");
                scanf("%d",&value);
                delete_val(&mylist,value);
                show_list(mylist);
                break;
            case 10:
                sort(&mylist);
                show_list(mylist);
                break;
            case 11:
                reverse(&mylist,&value,&newlist);
                printf("\n");
                show_list(newlist);
                break;
            case 12:
                clear0(&mylist);
                break;
            case 13:
                destroy(&mylist);
                break;
            default:
                break;
        }
    }
    destroy(&mylist);
    destroy(&newlist);
    printf("Hello, World!\n");
    return 0;
}

2. DLList.h

//
//  DLList.h
//  5_DLL    Double link list
//
//  Created by LS on 2022/5/18.
//  Copyright © 2022 LSC001. All rights reserved.
//

#ifndef DLList_h
#define DLList_h

#include <stdio.h>
#include <assert.h>
#include <stdlib.h>

// 1 定义宏
#define Elemtype int

// 2 定义节点、单链表
typedef struct Lnode
{
    Elemtype data;
    struct Lnode *prior;
    struct Lnode *next;
}Lnode,*PLnode;

typedef struct List
{
    PLnode head;
    PLnode tail;
    int size;
}List;

// 3 函数声明
void InitList(List *List);
void push_back(List *List,Elemtype num);
void push_front(List *List,Elemtype num);
void show_list(List list);
void pop_back(List *List,Elemtype *num);
void pop_front(List *List);
void insert_val(List *List,int pos,Elemtype num);
PLnode find(List list,Elemtype num);
int length(List list);
void delete_val(List *List,Elemtype value);
void sort(List *List);
void reverse(List *List,Elemtype *num,struct List *newlist);
void clear0(List *List);
void destroy(List *List);
#endif /* DLList_h */

3. DLList.c

//
//  DLList.c
//  5_DLL Double link list
//
//  Created by LS on 2022/5/18.
//  Copyright © 2022 LSC001. All rights reserved.
//

#include "DLList.h"

PLnode new_(Elemtype num)
{
    PLnode p = (PLnode)malloc(sizeof(Lnode));
    p->data = num;
    p->next = NULL;
    return p;
}

void InitList(List *List)                       // 0
{
    List->tail = List->head = (PLnode)malloc(sizeof(Lnode));
    List->head->next = NULL;
    assert((List->head) != NULL);
    List->size = 0;
}

void push_back(List *List,Elemtype num)         // 1
{
    PLnode new = new_(num);
    new->data = num;
    
    //printf("\nList->tail:%p\n",List->tail);
    List->tail->next = new;
    new->prior = List->tail;
    List->tail = new;
    //printf("\nnew->prior: %p\n",new->prior);
    List->size++;
}
void push_front(List *List,Elemtype num)       // 2
{
    PLnode new = new_(num);
    if(0==List->size)
    {
        List->tail=new;
    }
    new->next = List->head->next;
    if(List->head->next){List->head->next->prior = new;}
    List->head->next = new;
    new->prior = List->head;
    List->size++;
}
void show_list(List list)                     // 3
{
    if(list.head == NULL)
    {
        printf("List is NULL!\n");
        return;
    }else
    {
        PLnode p = list.head->next;
        while (p)
        {
            printf("%d,",p->data);
            p = p->next;
        }
    }
    printf("\n");
}
void pop_back(List *List,Elemtype *num)                    // 4
{
    PLnode p = List->head;
    if(0==List->size) return;
    while (p->next != List->tail) {
        p = p->next;
    }
    *num = List->tail->data;
    free(List->tail);
    List->tail=p;
    List->tail->next=NULL;    // 尾指针指向p，地址存放n-1的地址，因此要把尾指针重新设为NULL；
    List->size--;
    p=NULL;
}
void pop_front(List *List)                   // 5
{
    PLnode p = List->head->next;
    if(!p) return;
    List->head->next = p->next;
    if(1==List->size)
    {
        List->tail=List->head;
    }else
    {
        p->next->prior = List->head;
    }
    free(p);
    p=NULL;
    
    List->size--;
}
void insert_val(List *List,int pos,Elemtype num)     // 6 只能在某元素前插入
{
    PLnode new = new_(num);
    PLnode p=List->head;
    int i=pos;
    while(p && i>1)
    {
        p=p->next;
        i--;
    }
    if(!p || pos<=0) return;
    
    if(pos==List->size+1)
    {
        List->tail = new;
    }else if (pos<=List->size)
    {
        new->next = p->next;
        p->next->prior = new;
    }
    p->next = new;
    new->prior = p;
    List->size++;
}
PLnode find(List List,Elemtype num)                  // 7
{
    PLnode p=List.head->next;
    while (p && p->data!=num) {
        p = p->next;
    }
    return p;
}
int length(List list)                                // 8
{
    return list.size;
}
void delete_val(List *List,Elemtype value)           // 9
{
    PLnode p = List->head;
    while (p->next && p->next->data != value)
    {
        p=p->next;
    }
    if(!p->next) return;
    
    PLnode q = p->next;
    
    if(p->next == List->tail)
    {
        List->tail=p;
    }
    else{
        q->next->prior = p;
    }
    p->next = p->next->next;
    free(q);
    p=q=NULL;
    List->size--;
}
void sort(List *List)                             // 10
{
    Elemtype tmp;
    PLnode p;
    int n = List->size;
    for(int i=0;i<n-1;++i)
    {
        p = List->head->next;
        for(int j=0;j<n-1-i;++j)
        {
            if(p->data > p->next->data)
            {
                tmp = p->next->data;
                p->next->data = p->data;
                p->data=tmp;
            }
            p = p->next;
        }
    }
    
}
void reverse(List *List,Elemtype *num,struct List *newlist)                            // 11
{
    // 2 从链表中尾部删除数据，并放在新的链表中
    int n= List->size;
    while (n>0) {
        pop_back(List,num);
        push_back(newlist,*num);
        --n;
    }
    
}
void clear0(List *List)                             // 12
{
    PLnode p = List->head->next;
    if(!p) return;
    while (p) {
        List->head->next= p->next;
        free(p);
        p=List->head->next;
        List->size--;
    }
    List->tail = List->head;
    List->size=0;
}
void destroy(List *List)                            // 13
{
    clear0(List);
    free(List->head);
    List->head = NULL;
    List->tail = NULL;
}