单向链表的简单使用

最新推荐文章于 2024-04-25 08:00:00 发布
最新推荐文章于 2024-04-25 08:00:00 发布
阅读量1.5w 收藏 86
点赞数 20
分类专栏： c语言 文章标签： 单向链表 链表的基本操作 链表逆转 链表排序
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/silent123go/article/details/52693735
版权
一、单向链表的概念

    单向链表是链表的一种，其特点是链表的链接方向是单向的，对链表的访问要通过顺序读取从头部开始。链表是使用指针进行构造的列表，并且是由一个个结点组装起来的，因此又称为结点列表。其中每个结点都有指针成员变量指向列表中的下一个结点，head指针指向第一个结点称为表头，而终止于最后一个指向nuLL的指针。

    结点的数据结构

typedef struct _LINK_NODE  
{  
    int data;  
    struct _LINK_NODE* next;  
}LINK_NODE;

    各个结点连接在一起构成一个单向链表（示意图）


二、单向链表的优缺点
    和普通的线性结构（如数组）相比，链表结构有以下特点：
    （1）单个结点创建非常灵活，普通的线性内存通常在创建的时候就需要设定数据的大小
    （2）结点的删除、插入非常方便，不需要像线性结构那样移动剩下的数据

    （3）结点的访问方便，可以通过循环或者递归的方法访问到任意数据，但是平均的访问效率低于线性表


三、单向链表的基本操作

    1、建立一个新的链表

LINK_NODE* create_node(int value)  
{  
    LINK_NODE *pLinkNode = NULL;  
    
    pLinkNode = (LINK_NODE *)malloc(sizeof(LINK_NODE));        
    pLinkNode->data = value;  
    pLinkNode->next = NULL;  
    
    return pLinkNode;  
}

    2、增加一个结点（增加到末尾）

int _add_node(LINK_NODE** pNode, LINK_NODE* pDataNode)  
{  
    if(NULL == *pNode) {  
        *pNode = pDataNode;  
        return TRUE;  
    }  
      
    return _add_node(&(*pNode)->next, pDataNode);  
}  
  
int add_node(const LINK_NODE** pNode, int value)  
{  
    LINK_NODE *pDataNode;  
    
    if(NULL == *pNode) { 
        return FALSE;  
    }
              
    pDataNode = create_node(value);  
    if(pDataNode == NULL) {
        return FALSE;
    }  
    
    return _add_node((LINK_NODE**)pNode, pDataNode);  
}

    3、删除一个结点

int _delete_node(LINK_NODE** pNode, int value)  
{  
    LINK_NODE* pLinkNode; 
     
    if(NULL == (*pNode)->next) {
        return FALSE;  
    }
    pLinkNode = (*pNode)->next;  
    if(value == pLinkNode->data) {  
        (*pNode)->next = pLinkNode->next;  
        free(pLinkNode);  
        return TRUE;  
    } else {  
        return _delete_node(&(*pNode)->next, value);  
    }  
}  
  
int delete_node(LINK_NODE** pNode, int value)  
{  
    LINK_NODE* pLinkNode;  
    
    if(NULL == pNode || NULL == *pNode) { 
        return FALSE;  
    }
    
    if(value == (*pNode)->data) {  
        pLinkNode = *pNode;  
        *pNode = pLinkNode->next;  
        free(pLinkNode);  
        return TRUE;  
    }         
      
    return _delete_node(pNode, value);  
}

    4、查找结点

//查找结点，返回数据内容为value的结点地址，没有找到返回NULL
LINK_NODE* find_node(const LINK_NODE* pLinkNode, int value)  
{  
    if(NULL == pLinkNode)  
        return NULL;  
      
    if(value == pLinkNode->data)  
        return (LINK_NODE*)pLinkNode;  
      
    return find_node(pLinkNode->next, value);  
}

    5、统计结点个数

int count_list(const LINK_NODE *pLinkNode)  
{  
    if(NULL == pLinkNode) {  
        return 0;  
    }
         
    return 1 + count_list(pLinkNode->next);  
}

    6、打印整个链表

void print_list(const LINK_NODE *pLinkNode)  
{  
    if(pLinkNode) {  
        printf("%d\n", pLinkNode->data);  
        print_list(pLinkNode->next);  
    }  
}

    7、删除整个链表

void delete_list(LINK_NODE** pNode)  
{  
    LINK_NODE** pNext;  
    
    if(NULL == pNode || NULL == *pNode) {  
        return ;  
    }    
    pNext = &(*pNode)->next;  
    free(*pNode);  
    delete_list(pNext);   
}

    8、链表逆转

        链表逆转就是把链表的方向反过来，头指针变成尾指针，尾指针变成头指针，实现草图如下


        a、逆转并生成新的链表（非递归方式）

//新建一条链表，新的链表是原来链表的逆转，使用while循环实现。
LINK_NODE *reverse_new_loop(LINK_NODE *head)
{
    LINK_NODE *p1 = NULL, *p2;
    
    while(head != NULL)
    {
        p2 = (LINK_NODE *) malloc(sizeof(LINK_NODE));
        if(p1 == NULL) {
            p2->next = NULL; 
        } else {
            p2->next = p1;
        }
        p1 = p2;
        p2->data = head->data;
        head = head->next;
    }
    
    return p1;
}

        b、逆转并生成新的链表（递归方式）

//新建一条链表，新的链表是原来链表的逆转，使用递归实现。
LINK_NODE *reverse_new_recursive(LINK_NODE *head, LINK_NODE *pre)
{
    LINK_NODE *p = head->next;
    LINK_NODE *new;
    
    new = (LINK_NODE *) malloc(sizeof(LINK_NODE));
    new->next = pre;
    new->data = head->data;
    
    if(p) {
        return reverse_new_recursive(p, new);
    } else {
        return new;
    }
}

        c、原地逆转，不生成新链表（非递归方式）

//原地逆转，使用while循环实现。
LINK_NODE *reverse_local_loop(LINK_NODE *head) 
{
    LINK_NODE *p;
    LINK_NODE *tmp;
    
    if(NULL == head) {
        return head;
    }
    
    p = head->next;
    head->next = NULL;

    while(NULL != p) {
        tmp = p->next;
        p->next = head;
        head = p;
        p = tmp;
    }

    return head;
}

        d、原地逆转，不生成新链表（递归方式）

//原地逆转，使用递归实现。
LINK_NODE *reverse_local_recursive(LINK_NODE *head, LINK_NODE *pre) 
{
    LINK_NODE *p = head->next;

    head->next = pre;
    if(p) {
        return reverse_local_recursive(p, head);
    } else {
        return head;
    }
}

    9、链表排序
        a、选择排序
            选择排序的基本思想就是反复从还未排好序的那些节点中，选出键值最小的节点， 依次重新组合成一个链表。可以通过以下三个步骤实现
            （1）先在原链表中找最小的，找到一个后就把它放到另一个空的链表中
            （2）空链表中存放第一个进来的节点，并且让它在原链表中分离出来

            （3）继续在原链表中找下一个最小的，找到后把它放入有序链表的尾指针的next,然后它变成其尾指针

//选择排序，从小到大。
LINK_NODE *SelectSort(LINK_NODE *head)
{
    LINK_NODE *first;     /*排列后有序链的表头指针*/
    LINK_NODE *tail;      /*排列后有序链的表尾指针*/
    LINK_NODE *premin;    /*保留键值更小的节点的前驱节点的指针*/
    LINK_NODE *min;       /*存储最小节点*/
    LINK_NODE *p;         /*当前比较的节点*/

    first = NULL;
    while (head != NULL) 
    {
        
        //在剩余的原链表中找出最小值
        for (p = head, min = head; p->next != NULL; p = p->next) {  
            if (p->next->data < min->data) {
                premin = p; 
                min = p->next; 
            }
        }

        //将找出来最小值放到新的链表
        if (first == NULL) {
            first = min; 
            tail = min;
        } else {
            tail->next = min; 
            tail = min;
        } 

        //将找出来的最小值从原来的链表中脱离
        if (min == head) {
            head = head->next;
        } else {
            premin->next = min->next;
        } 
    }

    if (first != NULL) {
        tail->next = NULL;
    }
    
    head = first;
    return head;
}

        b、插入排序
            直接插入排序的基本思想就是假设链表的前面n-1个节点是已经按键值排好序的，对于节点n在这个序列中找插入位置，使得n插入后新序列仍然有序。按照这种思想，依次对链表从头到尾执行一遍，就可以使无序链表变为有序链表。可以通过以下两个步骤实现
            （1）先在原链表中以第一个节点为一个有序链表，其余节点为待定节点

            （2）从原链表中依次取结点，插入到有序链表的相应位置，使得有序链表仍然有序，直至原链表的结点全部取完，排序结束。

//插入排序，从小到大。       
LINK_NODE *InsertSort(LINK_NODE *head)
{
    LINK_NODE *first; /*为原链表剩下用于直接插入排序的节点头指针*/
    LINK_NODE *t;     /*临时指针变量：插入节点*/
    LINK_NODE *p;     /*临时指针变量*/
    LINK_NODE *q;     /*临时指针变量*/

    first = head->next; 
    head->next = NULL; 

    while (first != NULL)
    {
        //找到要插入的位置，p是q的前驱。
        for (t = first, q = head; ((q != NULL) && (q->data < t->data)); p = q, q = q->next);

        //无序链表中的节点离开，以便它插入到有序链表中。
        first = first->next;
        
        if (q == head) {
            head = t;  //插在第一个节点之前
        } else {
            p->next = t;  
        }
        t->next = q;
    }
    
    return head;
}

        c、冒泡排序

            冒泡排序的基本思想就是对当前还未排好序的范围内的全部节点，自上而下对相邻的两个节点依次进行比较和调整，让键值较大的节点往下沉，键值较小的往上冒。即：每当两相邻的节点比较后发现它们的排序与排序要求相反时，就将它们互换。

//冒泡排序，从小到大。
LINK_NODE *BubbleSort(LINK_NODE *head)
{
    LINK_NODE *endpt; /*控制循环比较*/
    LINK_NODE *p;     /*临时指针变量*/
    LINK_NODE *p1;
    LINK_NODE *p2;

    p1 = (LINK_NODE *)malloc(sizeof(LINK_NODE));
    p1->next = head;
    head = p1;

    for (endpt = NULL; endpt != head; endpt = p) {
        for (p = p1 = head; p1->next->next != endpt; p1 = p1->next) {
            if (p1->next->data > p1->next->next->data) {
                p2 = p1->next->next; 
                p1->next->next = p2->next; 
                p2->next = p1->next; 
                p1->next = p2; 
                p = p1->next->next; 
            }
        }
    }

    p1 = head; 
    head = head->next;
    free(p1); 
    p1 = NULL; 

    return head;
}

四、单向链表运用示例

    将链表的基本操作统一放在一个文件single_linkedlist.c里面，然后在single_linkedlist.h文件里面声明，这样调用起来比较方便。下面贴出各个文件的代码，方面下次快速使用。

    single_linkedlist.c文件代码

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

#include "single_linkedlist.h"

//创建一个结点
LINK_NODE* create_node(int value)  
{  
    LINK_NODE *pLinkNode = NULL;  
    
    pLinkNode = (LINK_NODE *)malloc(sizeof(LINK_NODE));        
    pLinkNode->data = value;  
    pLinkNode->next = NULL;  
    
    return pLinkNode;  
}  

//使用递归的方法，在链表的末尾加上一个新的结点
int _add_node(LINK_NODE** pNode, LINK_NODE* pDataNode)  
{  
    if(NULL == *pNode) {  
        *pNode = pDataNode;  
        return TRUE;  
    }  
      
    return _add_node(&(*pNode)->next, pDataNode);  
}  
  
int add_node(const LINK_NODE** pNode, int value)  
{  
    LINK_NODE *pDataNode;  
    
    if(NULL == *pNode) { 
        return FALSE;  
    }
              
    pDataNode = create_node(value);  
    if(pDataNode == NULL) {
        return FALSE;
    }  
    
    return _add_node((LINK_NODE**)pNode, pDataNode);  
}  

//使用递归的方法，删除数据内容为value的结点
int _delete_node(LINK_NODE** pNode, int value)  
{  
    LINK_NODE* pLinkNode; 
     
    if(NULL == (*pNode)->next) {
        return FALSE;  
    }
    pLinkNode = (*pNode)->next;  
    if(value == pLinkNode->data) {  
        (*pNode)->next = pLinkNode->next;  
        free(pLinkNode);  
        return TRUE;  
    } else {  
        return _delete_node(&(*pNode)->next, value);  
    }  
}  
  
int delete_node(LINK_NODE** pNode, int value)  
{  
    LINK_NODE* pLinkNode;  
    
    if(NULL == pNode || NULL == *pNode) { 
        return FALSE;  
    }
    
    if(value == (*pNode)->data) {  
        pLinkNode = *pNode;  
        *pNode = pLinkNode->next;  
        free(pLinkNode);  
        return TRUE;  
    }         
      
    return _delete_node(pNode, value);  
}  

//查找结点，返回数据内容为value的结点地址，没有找到返回NULL.
LINK_NODE* find_node(const LINK_NODE* pLinkNode, int value)  
{  
    if(NULL == pLinkNode)  
        return NULL;  
      
    if(value == pLinkNode->data)  
        return (LINK_NODE*)pLinkNode;  
      
    return find_node(pLinkNode->next, value);  
}  

//把从pLinkNode结点开始到链表结束的结点个数统计出来
//一般pLinkNode链表头
int count_list(const LINK_NODE *pLinkNode)  
{  
    if(NULL == pLinkNode) {  
        return 0;  
    }
         
    return 1 + count_list(pLinkNode->next);  
}  
    
//把从pLinkNode结点开始到链表结束的数据全部打印出来
//一般pLinkNode为链表头
void print_list(const LINK_NODE *pLinkNode)  
{  
    if(pLinkNode) {  
        printf("%d\n", pLinkNode->data);  
        print_list(pLinkNode->next);  
    }  
}  

//删除整个链表，pNode为链表头。
void delete_list(LINK_NODE** pNode)  
{  
    LINK_NODE** pNext;  
    
    if(NULL == pNode || NULL == *pNode) {  
        return ;  
    }    
    pNext = &(*pNode)->next;  
    free(*pNode);  
    delete_list(pNext);   
}  

//新建一条链表，新的链表是原来链表的逆转，使用while循环实现。
LINK_NODE *reverse_new_loop(LINK_NODE *head)
{
    LINK_NODE *p1 = NULL, *p2;
    
    while(head != NULL)
    {
        p2 = (LINK_NODE *) malloc(sizeof(LINK_NODE));
        if(p1 == NULL) {
            p2->next = NULL; 
        } else {
            p2->next = p1;
        }
        p1 = p2;
        p2->data = head->data;
        head = head->next;
    }
    
    return p1;
}

//新建一条链表，新的链表是原来链表的逆转，使用递归实现。
LINK_NODE *reverse_new_recursive(LINK_NODE *head, LINK_NODE *pre)
{
    LINK_NODE *p = head->next;
    LINK_NODE *new;
    
    new = (LINK_NODE *) malloc(sizeof(LINK_NODE));
    new->next = pre;
    new->data = head->data;
    
    if(p) {
        return reverse_new_recursive(p, new);
    } else {
        return new;
    }
}

//原地逆转，使用while循环实现。
LINK_NODE *reverse_local_loop(LINK_NODE *head) 
{
    LINK_NODE *p;
    LINK_NODE *tmp;
    
    if(NULL == head) {
        return head;
    }
    
    p = head->next;
    head->next = NULL;

    while(NULL != p) {
        tmp = p->next;
        p->next = head;
        head = p;
        p = tmp;
    }

    return head;
}

//原地逆转，使用递归实现。
LINK_NODE *reverse_local_recursive(LINK_NODE *head, LINK_NODE *pre) 
{
    LINK_NODE *p = head->next;

    head->next = pre;
    if(p) {
        return reverse_local_recursive(p, head);
    } else {
        return head;
    }
}

//选择排序，从小到大。
LINK_NODE *SelectSort(LINK_NODE *head)
{
    LINK_NODE *first;     /*排列后有序链的表头指针*/
    LINK_NODE *tail;      /*排列后有序链的表尾指针*/
    LINK_NODE *premin;    /*保留键值更小的节点的前驱节点的指针*/
    LINK_NODE *min;       /*存储最小节点*/
    LINK_NODE *p;         /*当前比较的节点*/

    first = NULL;
    while (head != NULL) 
    {
        
        //在剩余的原链表中找出最小值
        for (p = head, min = head; p->next != NULL; p = p->next) {  
            if (p->next->data < min->data) {
                premin = p; 
                min = p->next; 
            }
        }

        //将找出来最小值放到新的链表
        if (first == NULL) {
            first = min; 
            tail = min;
        } else {
            tail->next = min; 
            tail = min;
        } 

        //将找出来的最小值从原来的链表中脱离
        if (min == head) {
            head = head->next;
        } else {
            premin->next = min->next;
        } 
    }

    if (first != NULL) {
        tail->next = NULL;
    }
    
    head = first;
    return head;
}

//插入排序，从小到大。       
LINK_NODE *InsertSort(LINK_NODE *head)
{
    LINK_NODE *first; /*为原链表剩下用于直接插入排序的节点头指针*/
    LINK_NODE *t;     /*临时指针变量：插入节点*/
    LINK_NODE *p;     /*临时指针变量*/
    LINK_NODE *q;     /*临时指针变量*/

    first = head->next; 
    head->next = NULL; 

    while (first != NULL)
    {
        //找到要插入的位置，p是q的前驱。
        for (t = first, q = head; ((q != NULL) && (q->data < t->data)); p = q, q = q->next);

        //无序链表中的节点离开，以便它插入到有序链表中。
        first = first->next;
        
        if (q == head) {
            head = t;  //插在第一个节点之前
        } else {
            p->next = t;  
        }
        t->next = q;
    }
    
    return head;
}      

//冒泡排序，从小到大。
LINK_NODE *BubbleSort(LINK_NODE *head)
{
    LINK_NODE *endpt; /*控制循环比较*/
    LINK_NODE *p;     /*临时指针变量*/
    LINK_NODE *p1;
    LINK_NODE *p2;

    p1 = (LINK_NODE *)malloc(sizeof(LINK_NODE));
    p1->next = head;
    head = p1;

    for (endpt = NULL; endpt != head; endpt = p) {
        for (p = p1 = head; p1->next->next != endpt; p1 = p1->next) {
            if (p1->next->data > p1->next->next->data) {
                p2 = p1->next->next; 
                p1->next->next = p2->next; 
                p2->next = p1->next; 
                p1->next = p2; 
                p = p1->next->next; 
            }
        }
    }

    p1 = head; 
    head = head->next;
    free(p1); 
    p1 = NULL; 

    return head;
}

    single_linkedlist.h文件代码 

#ifndef _SINGLE_LINKEDLIST_H_
#define _SINGLE_LINKEDLIST_H_

#define TRUE       1
#define FALSE      0

//定义结点数据结构
typedef struct _LINK_NODE  
{  
    int data;  
    struct _LINK_NODE* next;  
}LINK_NODE; 


//创建一个结点
LINK_NODE* create_node(int value);

//删除整个链表，pNode为链表头。
void delete_list(LINK_NODE** pNode); 

//使用递归的方法，在链表的末尾加上一个新的结点
int add_node(const LINK_NODE** pNode, int value);

//使用递归的方法，删除数据内容为value的结点
int delete_node(LINK_NODE** pNode, int value);

//查找结点，返回数据内容为value的结点地址，没有找到返回NULL
LINK_NODE* find_node(const LINK_NODE* pLinkNode, int value);

//把从pLinkNode结点开始到链表结束的结点个数统计出来
//一般pLinkNode链表头
int count_list(const LINK_NODE *pLinkNode);

//把从pLinkNode结点开始到链表结束的数据全部打印出来
//一般pLinkNode为链表头
void print_list(const LINK_NODE *pLinkNode); 

//新建一条链表，新的链表是原来链表的逆转，使用while循环实现。
LINK_NODE *reverse_new_loop(LINK_NODE *head);

//新建一条链表，新的链表是原来链表的逆转，使用递归实现。
LINK_NODE *reverse_new_recursive(LINK_NODE *head, LINK_NODE *pre);

//原地逆转，使用while循环实现。
LINK_NODE *reverse_local_loop(LINK_NODE *head);

//原地逆转，使用递归实现。
LINK_NODE *reverse_local_recursive(LINK_NODE *head, LINK_NODE *pre);

//选择排序，从小到大。
LINK_NODE *SelectSort(LINK_NODE *head);

//插入排序，从小到大。       
LINK_NODE *InsertSort(LINK_NODE *head);

//冒泡排序，从小到大。
LINK_NODE *BubbleSort(LINK_NODE *head);

#endif

    main.c文件代码 

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

#include "single_linkedlist.h"

int main(int argc, char **argv)
{
    LINK_NODE *head;
    LINK_NODE *reverse1, *reverse2;
    
    head = create_node(1);    
    add_node((const LINK_NODE **)&head, 5);
    add_node((const LINK_NODE **)&head, 2);
    add_node((const LINK_NODE **)&head, 4);
    add_node((const LINK_NODE **)&head, 3);  
    
    printf("=======原始链表head\n");  
    print_list(head);
    
    
    //逆转生成一个新的链表，循环实现
    reverse1 = reverse_new_loop(head);
    printf("=======head逆转成的链表reverse1\n");
    print_list(reverse1);    
    
    //逆转生成一个新的链表，递归实现
    reverse2 = reverse_new_recursive(head, NULL);
    printf("=======head逆转成的链表reverse2\n");
    print_list(reverse2);

    //本地逆转，循环实现        
    reverse1 = reverse_local_loop(reverse1);
    printf("=======reverse1本地逆转成的链表reverse1\n");
    print_list(reverse1);    
    
    //本地逆转，递归实现
    reverse2 = reverse_local_loop(reverse2);
    printf("=======reverse2本地逆转成的链表reverse2\n");
    print_list(reverse2);
    
    //选择排序
    head = SelectSort(head);
    printf("=======head选择排序后的链表\n");
    print_list(head);    
    
    //插入排序
    reverse1 = InsertSort(reverse1);
    printf("=======reverse1插入排序后的链表\n");
    print_list(reverse1);

    //冒泡排序
    reverse2 = BubbleSort(reverse2);  
    printf("=======reverse2冒泡排序后的链表\n");
    print_list(reverse2);

    delete_list(&head);
    delete_list(&reverse1);
    delete_list(&reverse2);
                 
    return 0;
}

    Makefile文件代码 

CC       = gcc
WORKDIR  = 
INCLUDES = 
LIBS     =
LINKS    =
TARGET   = main

src=$(wildcard *.c ./callback/*.c)
C_OBJS=$(patsubst %.c, %.o,$(src))
#C_OBJS=$(dir:%.c=%.o)

compile:$(TARGET)
	
$(C_OBJS):%.o:%.c
	$(CC) $(CFLAGS) $(INCLUDES) -o $*.o -c $*.c
	
$(TARGET):$(C_OBJS)
	$(CC) -o $(TARGET) $^ $(LIBS) $(LINKS) 

	@echo 
	@echo Project has been successfully compiled.
	@echo
	
install: $(TARGET)
	cp $(TARGET) $(INSTALL_PATH)

uninstall:
	rm -f $(INSTALL_PATH)/$(TARGET)

rebuild: clean compile

clean:
	rm -rf *.o  $(TARGET) *.log *~


o倚楼听风雨o
关注
  • 20
    点赞
  • 踩
  • 86
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
数据结构之单链表非常详细介绍(适合小白）
m0_74438843的博客
08-22 5019
数据结构深度学习之单链表非常详解解读~~~一万多字详解
单链表的基本操作
weixin_46086149的博客
09-13 1767
单链表的基本操作
【数据结构】单链表的特点
最新发布
m0_74195174的博客
04-25 966
这篇文章到这里就结束了如果觉得这篇博客对你有用的话，别忘记三连哦。我是豌豆射手^，让我们我们下次再见。
链表的应用
09-10
里面含有链表的例题和源代码及运行截屏，希望对于想提高自己链表能力，更加透彻的理解，灵活运用链表的学习者有帮助
Java数据结构---链表的基本用法（如创建等基本使用方法）
gaoqiandr的博客
01-05 878
本文简单地介绍了如何使用Java实现数据结构中的链表
4单向链表以及单向链表的应用
张金玉的专栏
04-09 302
链表结构 链式存储结构是基于指针实现，我们把一个数据元素和一个指针成为节点 链式存储结构是用指针把相互直接关联的结点（即直接前驱节点或直接后继节点）链接起来。 链式存储结构的线性表成为链表 链表类型 根据链表的构造方式的不同可以分为： 1单向链表 2单向循环链表 3 双向循环链表 单链表结构 1单链表是构成链表的每个结点之哟袷指向直接后继结点的指针。 2表示方法和单链表中每个节点的结构 -...
C++实现简单单向链表
12-17
在本文中，我们将深入探讨如何使用C++实现一个简单的单向链表。单向链表是一种数据结构，其中每个节点包含一个数据元素和一个指向下一个节点的指针。在这个实现中，我们创建了一个名为`Node`的结构体来表示链表中的...
C语言单向链表的表示与实现实例详解
12-31
链表中最简单的一种是单向链表，它包含两个域，一个信息域和一个指针域。这个链接指向列表中的下一个节点，而最后一个节点则指向一个空值。 如下图所示： 一个单向链表包含两个值: 当前节点的值和一个指向下一个...
单向链表类模板_单向链表类模板_fastchq_
10-03
以上是对单向链表类模板的简单概述，实际实现可能更复杂，包括错误处理、优化等。这个模板类可以用于存储任何类型的数据，使得代码更具复用性和灵活性。在使用时，只需要传入所需的数据类型即可，如`LinkedList<int>...
C++单向链表.rar
10-19
这是近期自己参考书上和网上资源使用C++编的单向链表，主要包含了链表的增删改查功能，除此之外还有简单的排序功能，代码实现的效果图已经在项目文件夹中了，可以按照效果图进行数据的增删改查等操作，最后也希望对...
lianbiao.rar_单向链表
09-24
单向链表是一种基本的数据结构，它在计算机科学和编程中有着广泛的应用。与数组不同，链表中的元素不是在内存中连续存储的，而是通过指针连接起来，每个节点包含数据部分和指向下一个节点的指针部分。这种存储方式...
链表的用法示例
06-25
可以让你更深的了解并使用链表，但是解释说明比较少，全看个人领悟了，最好找书参考一下
单向链表的C语言实现
11-07
C语言指针实现单向链表 初学者看，非常简单。 时间非常多的功能不同位置的插入、删除、查找；
数据结构与算法:单向链表实现与封装
08-26
"数据结构与算法：单向链表实现与封装" 在计算机科学中，数据结构是指计算机中...单向链表的实现与封装是数据结构和算法中的一个重要课题，通过封装，我们可以隐藏链表的实现细节，提供一个简单易用的接口供用户使用。
java单向链表代码实现
12-25
以上代码实现了一个简单的单向链表，包括插入、删除、遍历和获取链表长度的功能。在实际的软件开发中，链表常被用作基础数据结构，特别是在需要频繁进行插入和删除操作而对顺序访问性能要求不高的场景。例如，解析...
单向链表的操作的全部函数合集
07-29
单向链表是一种基本的数据结构，它由一系列节点组成，每个节点包含数据和指向下一个节点的指针。在计算机科学中，理解并掌握单向链表的运作是至关重要的，因为它们广泛应用于各种算法和数据结构的设计。下面，我们将...
链表在STM32中的应用
热门推荐
人生一路，点滴记录
12-11 1万+
目录 1、为何引入链表 2、链表实现 3、测试函数 、为何引入链表 在程序中经常面临一个问题，我们需要保存一定数量的对象，但是对象数目是不确定的，或者说是随时增加或减少的。这时候最简单的方法是创建一个足够大的数组，用来存储这些对象。我最近开发一个项目就遇到类似的问题，下面我把问题简化一下。 需求：通过PC下发一些矩形的坐标和宽高信息，每个区域有个ID编号，并在这些矩形内填充一定的数据。 通常情况下，最简单易懂的做法是，限制最多5个区域，每个区域存储1K数据。因此设置了这样的一个结构体（类似于面
单向链表的基本操作
qq_52253798的博客
01-17 420
一、什么是单向链表 单向链表也叫单链表，是链表中最简单的一种形式，它的每个节点包含两个域，一个信息域（元素域）和一个链接域。这个链接指向链表中的下一个节点，而最后一个节点的链接域则指向一个空值。 a、表元素域elem用来存放具体的数据。 b、链接域next用来存放下一个节点的位置。 c、变量p指向链表的头节点（首节点）的位置，从p出发能找到表中的任意节点。 二、链表基本操作的实现原理； （1）、添加元素； 直接添加即在链表的末尾添加，又因底层是用LinkedList实现...
【单链表的基本操作】
w_9420的博客
12-10 628
链表的基本操作
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值