单向链表

最新推荐文章于 2024-08-04 17:29:18 发布
最新推荐文章于 2024-08-04 17:29:18 发布
阅读量123 收藏
点赞数
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41006871/article/details/80470638
版权

#include<stdio.h>
#include<stdlib.h>
#include<conio.h>
typedef int elemtype;///定义类型，下次修改可以直接在这里修改
typedef struct node
{
    elemtype data;///数据域
    struct node *next;///指针域
}linklist;


linklist *initLinkList();///初始化链表


void creatLinkList(linklist *);///创建链表


void displayLinkList(linklist *);///输出链表


linklist *search_loc(linklist *,int );///查找链表的节点


void search_val(linklist *,elemtype ,int *);///查找链表的值


int del_loc(linklist *,int );///删除链表的节点


int del_val(linklist *,elemtype );///删除链表的值


int insert_loc(linklist *,int ,elemtype );///插入节点的值


int insert_val(linklist *,elemtype ,elemtype );///出入值的节点


void clear();///清屏


int main()
{
    int choice,loc,ok;
    elemtype m,n;
    linklist *L,*temp;///L是头结点，temp是接下来用来存地址使用的
    do{
        printf("\t\t\t*************************\n");
        printf("\t\t\t*1.初始化链表\t\t*\n");
        printf("\t\t\t*2.创建链表    \t\t*\n");
        printf("\t\t\t*3.输出链表    \t\t*\n");
        printf("\t\t\t*4.查找链表节点\t\t*\n");
        printf("\t\t\t*5.查找链表的值\t\t*\n");
        printf("\t\t\t*6.删除链表的节点\t*\n");
        printf("\t\t\t*7.删除链表的值的节点   *\n");
        printf("\t\t\t*8.插入链表的节点的值   *\n");
        printf("\t\t\t*9.插入链表的节点的值   *\n");
        printf("\t\t\t*0.退出      \t\t*\n");
        printf("\t\t\t*************************\n");
        printf("请输入你需要的操作数:");
        scanf("%d",&choice);
        if(choice==0)
            break;
        switch(choice)
        {
            case 1: L=initLinkList();break;///初始化链表之后得把地址赋值给L
            case 2: creatLinkList(L);break;
            case 3: displayLinkList(L);break;
            case 4: printf("请输入你需要查找的节点位置:");
                    scanf("%d",&loc);
                    temp=search_loc(L,loc);///查找到节点之后返回地址赋值给temp
                    if(temp==NULL)
                        printf("NULL\n");
                    else
                        printf("%p",temp);///%p是输出计算机的地址
                    break;
            case 5: loc=0;///初始化loc，如果没有查找到节点loc是0
                    printf("请输入你需要的查找的数值:");
                    scanf("%d",&n);
                    search_val(L,n,&loc);///loc传地址，在函数查找到后传回地址
                    if(loc==0)
                        printf("NULL");
                    else
                        printf("该数值在%d的位置\n",loc);
                    break;
            case 6: printf("请输入你需要删除的节点位置:");
                    scanf("%d",&loc);
                    ok=del_loc(L,loc);
                    if(ok)
                        printf("删除成功\n");
                    else
                        printf("删除失败\n");
                    break;
            case 7: printf("请输入你需要删除的值:");
                    scanf("%d",&n);
                    ok=del_val(L,n);
                    if(ok)
                        printf("删除成功\n");
                    else
                        printf("删除失败\n");
                    break;
            case 8: printf("请输入你要插入的位置:");
                    scanf("%d",&loc);
                    printf("请输入你要插入的值:");
                    scanf("%d",&n);
                    ok=insert_loc(L,loc,n);
                    if(ok)
                        printf("插入成功\n");
                    else
                        printf("插入失败\n");
                    break;
            case 9: printf("请输入你需要插入在某值的前面的值:");
                    scanf("%d",&m);
                    printf("请输入你需要插入的值:");
                    scanf("%d",&n);
                    ok=insert_val(L,m,n);
                    if(ok)
                        printf("插入成功\n");
                    else
                        printf("插入失败\n");
                    break;
            default:printf("输入错误，请重新输入\n");break;
        }
        clear();
    }while(1);


    return 0;
}


///初始化链表
linklist *initLinkList()
{
    linklist *L;
    L=(linklist *)malloc(sizeof(linklist));
    if(!L)
        printf("初始化失败\n");
    else
        printf("初始化成功\n");
    L->next=NULL;
    return L;///初始化完返回地址
}


///创建链表
void creatLinkList(linklist *L)
{
    linklist *p,*q,*temp;
    int num,data;
    temp=L;
    while(temp->next!=NULL)
    {
        temp=temp->next;
    }
    ///采取的是尾插法，再次进入的时候的尾插的头节点应该是链表的最后一个节点，继续插入
    p=temp;///未插入数据之前，头节点就是上一次链表的头节点
    printf("\t\t\t请输入你需要的添加数量:");
    scanf("%d",&num);
    printf("\t\t\t请输入%d个数据:",num);
    while(num--)
    {
        scanf("%d",&data);
        q=(linklist *)malloc(sizeof(linklist));
        q->data=data;
        q->next=p->next;
        p->next=q;
        p=q;
    }
}




///输出链表
void displayLinkList(linklist *L)
{
    linklist *p;
    p=L;
    printf("\t\t\t以下是链表的数据:");
    if(!p->next)///链表如果是空的应该立马输出空的,并返回
    {
        printf("NULL\n");
        return ;
    }
    while(p->next!=NULL)
    {
        p=p->next;
        printf("%d ",p->data);
    }
    printf("\n");
}


///查找链表的节点
linklist *search_loc(linklist *L,int loc)
{
    int position=0;
    linklist *p;
    p=L;
    if(!p->next)
    {
        ///链表为空的，输出NULL
        return NULL;///返回空地址
    }
    while(p->next!=NULL)
    {
        p=p->next;
        ++position;
        if(position==loc)///查找到节点并跳出
            break;
    }
    if(position==loc)
        return p;
    else
        return NULL;///查找不到返回空
}




///查找链表的值
void search_val(linklist *L,int n,int *loc)
{
    int position=0;
    linklist *p;
    p=L;
    if(!p->next)
    {
        ///链表为空的，输出NULL
        return ;///并返回
    }
    while(p->next!=NULL)
    {
        p=p->next;
        ++position;
        if(p->data==n)
            *loc=position;///loc是指针，只要让loc指向position的地址，返回的时候就可以改变loc的值
    }
    return ;
}


///删除链表的节点
int del_loc(linklist *L,int loc)
{
    int position=0,ok=0;
    linklist *p,*q;
    p=L;q=L;
    if(!p->next)
    {
        printf("NULL\n");///链表为空的，输出NULL
        return 0;///删除失败返回0
    }
    while(q->next!=NULL)
    {
        q=q->next;///用q来查找需要删除的值
        ++position;
        if(position==loc)
        {
            p->next=q->next;///p是要删除的前一个，那只要它的next指向要删除的下一个地址就跳过了要删除的值
            free(q);///释放空间
            q=p;///释放完q得指向p，那样p的next也就是q的next，让q的链表正常，也就让L的链表连接正常
            ok=1;///删除成功
            break;
        }
        p=q;///这样一直循环就是p永远是要删除的前一个地址，删除的时候需要
    }
    if(ok)
        return 1;///删除成功返回1
    else
        return 0;///删除失败返回0
}


///删除链表的值
int del_val(linklist *L,int n)
{
    int ok=0;
    linklist *p,*q;
    p=L;q=L;
    if(!p->next)
    {
        printf("NULL\n");///链表为空的，输出NULL
        return 0;///删除失败返回0
    }
    while(q->next!=NULL)
    {
        q=q->next;///该删除值的方法与删除节点的方法一样，就不再重复解释了
        if(q->data==n)
        {
            p->next=q->next;
            free(q);
            q=p;
            ok=1;
            break;
        }
        p=q;
    }
    if(ok)
        return 1;///删除成功返回1
    else
        return 0;///删除失败返回0
}


///插入节点的值
int insert_loc(linklist *L,int loc,int n)
{
    int position=0,flag=0;
    linklist *p,*temp;
    temp=(linklist *)malloc(sizeof(linklist));
    temp->data=n;
    p=L;
    if(!p->next)
    {
        printf("NULL\n");///链表为空的，输出NULL
        return 0;///插入失败返回0
    }
    while(p->next!=NULL)
    {
        p=p->next;
        ++position;
        if(position==loc-1)///插入的值是loc，我们查找到loc的前一个就够了
        {
            flag=1;
            break;
        }
    }
    temp->next=p->next;///p是loc-1的位置，p->next的位置就是loc了，让temp的next指向loc，那么temp的位置也就变成loc的位置了
    p->next=temp;///p->next就是loc指向temp，也就是插入成功了，temp的位置变成loc的位置了
    if(flag)
        return 1;///插入成功返回1
    else
        return 0;///插入失败返回0
}




///插入值的节点
int insert_val(linklist *L,int m,int n)
{
    int loc=0,position=0,flag=0;
    linklist *p,*q,*temp;
    temp=(linklist *)malloc(sizeof(linklist));
    q=(linklist *)malloc(sizeof(linklist));
    temp->data=n;
    p=L;
    q=L;
    if(!p->next)
    {
        printf("NULL\n");///链表为空的，输出NULL
        return 0;///插入失败返回0
    }
    while(p->next!=NULL)
    {
        p=p->next;
        ++loc;
        if(p->data==m)
        {
            flag=1;
            break;
        }
    }
    while(q->next!=NULL)
    {
        q=q->next;
        ++position;
        if(position==loc-1)
            break;
    }
    temp->next=q->next;
    q->next=temp;
    if(flag)
        return 1;
    else
        return 0;
}


///清屏
void clear()
{
    printf("\n请按任意键技继续......");
    getch();
    system("cls");
}
#include<stdio.h>
#include<stdlib.h>
#include<conio.h>
typedef int elemtype;///定义类型，下次修改可以直接在这里修改
typedef struct node
{
    elemtype data;///数据域
    struct node *next;///指针域
}linklist;


linklist *initLinkList();///初始化链表


void creatLinkList(linklist *);///创建链表


void displayLinkList(linklist *);///输出链表


linklist *search_loc(linklist *,int );///查找链表的节点


void search_val(linklist *,elemtype ,int *);///查找链表的值


int del_loc(linklist *,int );///删除链表的节点


int del_val(linklist *,elemtype );///删除链表的值


int insert_loc(linklist *,int ,elemtype );///插入节点的值


int insert_val(linklist *,elemtype ,elemtype );///出入值的节点


void clear();///清屏


int main()
{
    int choice,loc,ok;
    elemtype m,n;
    linklist *L,*temp;///L是头结点，temp是接下来用来存地址使用的
    do{
        printf("\t\t\t*************************\n");
        printf("\t\t\t*1.初始化链表\t\t*\n");
        printf("\t\t\t*2.创建链表    \t\t*\n");
        printf("\t\t\t*3.输出链表    \t\t*\n");
        printf("\t\t\t*4.查找链表节点\t\t*\n");
        printf("\t\t\t*5.查找链表的值\t\t*\n");
        printf("\t\t\t*6.删除链表的节点\t*\n");
        printf("\t\t\t*7.删除链表的值的节点   *\n");
        printf("\t\t\t*8.插入链表的节点的值   *\n");
        printf("\t\t\t*9.插入链表的节点的值   *\n");
        printf("\t\t\t*0.退出      \t\t*\n");
        printf("\t\t\t*************************\n");
        printf("请输入你需要的操作数:");
        scanf("%d",&choice);
        if(choice==0)
            break;
        switch(choice)
        {
            case 1: L=initLinkList();break;///初始化链表之后得把地址赋值给L
            case 2: creatLinkList(L);break;
            case 3: displayLinkList(L);break;
            case 4: printf("请输入你需要查找的节点位置:");
                    scanf("%d",&loc);
                    temp=search_loc(L,loc);///查找到节点之后返回地址赋值给temp
                    if(temp==NULL)
                        printf("NULL\n");
                    else
                        printf("%p",temp);///%p是输出计算机的地址
                    break;
            case 5: loc=0;///初始化loc，如果没有查找到节点loc是0
                    printf("请输入你需要的查找的数值:");
                    scanf("%d",&n);
                    search_val(L,n,&loc);///loc传地址，在函数查找到后传回地址
                    if(loc==0)
                        printf("NULL");
                    else
                        printf("该数值在%d的位置\n",loc);
                    break;
            case 6: printf("请输入你需要删除的节点位置:");
                    scanf("%d",&loc);
                    ok=del_loc(L,loc);
                    if(ok)
                        printf("删除成功\n");
                    else
                        printf("删除失败\n");
                    break;
            case 7: printf("请输入你需要删除的值:");
                    scanf("%d",&n);
                    ok=del_val(L,n);
                    if(ok)
                        printf("删除成功\n");
                    else
                        printf("删除失败\n");
                    break;
            case 8: printf("请输入你要插入的位置:");
                    scanf("%d",&loc);
                    printf("请输入你要插入的值:");
                    scanf("%d",&n);
                    ok=insert_loc(L,loc,n);
                    if(ok)
                        printf("插入成功\n");
                    else
                        printf("插入失败\n");
                    break;
            case 9: printf("请输入你需要插入在某值的前面的值:");
                    scanf("%d",&m);
                    printf("请输入你需要插入的值:");
                    scanf("%d",&n);
                    ok=insert_val(L,m,n);
                    if(ok)
                        printf("插入成功\n");
                    else
                        printf("插入失败\n");
                    break;
            default:printf("输入错误，请重新输入\n");break;
        }
        clear();
    }while(1);


    return 0;
}


///初始化链表
linklist *initLinkList()
{
    linklist *L;
    L=(linklist *)malloc(sizeof(linklist));
    if(!L)
        printf("初始化失败\n");
    else
        printf("初始化成功\n");
    L->next=NULL;
    return L;///初始化完返回地址
}


///创建链表
void creatLinkList(linklist *L)
{
    linklist *p,*q,*temp;
    int num,data;
    temp=L;
    while(temp->next!=NULL)
    {
        temp=temp->next;
    }
    ///采取的是尾插法，再次进入的时候的尾插的头节点应该是链表的最后一个节点，继续插入
    p=temp;///未插入数据之前，头节点就是上一次链表的头节点
    printf("\t\t\t请输入你需要的添加数量:");
    scanf("%d",&num);
    printf("\t\t\t请输入%d个数据:",num);
    while(num--)
    {
        scanf("%d",&data);
        q=(linklist *)malloc(sizeof(linklist));
        q->data=data;
        q->next=p->next;
        p->next=q;
        p=q;
    }
}




///输出链表
void displayLinkList(linklist *L)
{
    linklist *p;
    p=L;
    printf("\t\t\t以下是链表的数据:");
    if(!p->next)///链表如果是空的应该立马输出空的,并返回
    {
        printf("NULL\n");
        return ;
    }
    while(p->next!=NULL)
    {
        p=p->next;
        printf("%d ",p->data);
    }
    printf("\n");
}


///查找链表的节点
linklist *search_loc(linklist *L,int loc)
{
    int position=0;
    linklist *p;
    p=L;
    if(!p->next)
    {
        ///链表为空的，输出NULL
        return NULL;///返回空地址
    }
    while(p->next!=NULL)
    {
        p=p->next;
        ++position;
        if(position==loc)///查找到节点并跳出
            break;
    }
    if(position==loc)
        return p;
    else
        return NULL;///查找不到返回空
}




///查找链表的值
void search_val(linklist *L,int n,int *loc)
{
    int position=0;
    linklist *p;
    p=L;
    if(!p->next)
    {
        ///链表为空的，输出NULL
        return ;///并返回
    }
    while(p->next!=NULL)
    {
        p=p->next;
        ++position;
        if(p->data==n)
            *loc=position;///loc是指针，只要让loc指向position的地址，返回的时候就可以改变loc的值
    }
    return ;
}


///删除链表的节点
int del_loc(linklist *L,int loc)
{
    int position=0,ok=0;
    linklist *p,*q;
    p=L;q=L;
    if(!p->next)
    {
        printf("NULL\n");///链表为空的，输出NULL
        return 0;///删除失败返回0
    }
    while(q->next!=NULL)
    {
        q=q->next;///用q来查找需要删除的值
        ++position;
        if(position==loc)
        {
            p->next=q->next;///p是要删除的前一个，那只要它的next指向要删除的下一个地址就跳过了要删除的值
            free(q);///释放空间
            q=p;///释放完q得指向p，那样p的next也就是q的next，让q的链表正常，也就让L的链表连接正常
            ok=1;///删除成功
            break;
        }
        p=q;///这样一直循环就是p永远是要删除的前一个地址，删除的时候需要
    }
    if(ok)
        return 1;///删除成功返回1
    else
        return 0;///删除失败返回0
}


///删除链表的值
int del_val(linklist *L,int n)
{
    int ok=0;
    linklist *p,*q;
    p=L;q=L;
    if(!p->next)
    {
        printf("NULL\n");///链表为空的，输出NULL
        return 0;///删除失败返回0
    }
    while(q->next!=NULL)
    {
        q=q->next;///该删除值的方法与删除节点的方法一样，就不再重复解释了
        if(q->data==n)
        {
            p->next=q->next;
            free(q);
            q=p;
            ok=1;
            break;
        }
        p=q;
    }
    if(ok)
        return 1;///删除成功返回1
    else
        return 0;///删除失败返回0
}


///插入节点的值
int insert_loc(linklist *L,int loc,int n)
{
    int position=0,flag=0;
    linklist *p,*temp;
    temp=(linklist *)malloc(sizeof(linklist));
    temp->data=n;
    p=L;
    if(!p->next)
    {
        printf("NULL\n");///链表为空的，输出NULL
        return 0;///插入失败返回0
    }
    while(p->next!=NULL)
    {
        p=p->next;
        ++position;
        if(position==loc-1)///插入的值是loc，我们查找到loc的前一个就够了
        {
            flag=1;
            break;
        }
    }
    temp->next=p->next;///p是loc-1的位置，p->next的位置就是loc了，让temp的next指向loc，那么temp的位置也就变成loc的位置了
    p->next=temp;///p->next就是loc指向temp，也就是插入成功了，temp的位置变成loc的位置了
    if(flag)
        return 1;///插入成功返回1
    else
        return 0;///插入失败返回0
}




///插入值的节点
int insert_val(linklist *L,int m,int n)
{
    int loc=0,position=0,flag=0;
    linklist *p,*q,*temp;
    temp=(linklist *)malloc(sizeof(linklist));
    q=(linklist *)malloc(sizeof(linklist));
    temp->data=n;
    p=L;
    q=L;
    if(!p->next)
    {
        printf("NULL\n");///链表为空的，输出NULL
        return 0;///插入失败返回0
    }
    while(p->next!=NULL)
    {
        p=p->next;
        ++loc;
        if(p->data==m)
        {
            flag=1;
            break;
        }
    }
    while(q->next!=NULL)
    {
        q=q->next;
        ++position;
        if(position==loc-1)
            break;
    }
    temp->next=q->next;
    q->next=temp;
    if(flag)
        return 1;
    else
        return 0;
}


///清屏
void clear()
{
    printf("\n请按任意键技继续......");
    getch();
    system("cls");
}

--root
关注
专栏目录
数据结构-单链表的基本操作
西风的博客
11-01 2886
题目要求： 编写一个程序，实现以下单链表的基本操作（单链表的元素类型elem type为char） （1）初始化单链表 h  (2)依次插入a,b,c,d,e五个元素  (3)输出单链表h  (4)  输出单链表h的长度  (5)判断单链表h是否为空  (6)  输出单链表h的第3个元素  (7)输出元素a的位置  (8)在第4个元素位置上插入元素f  (9)输出单链表h  (10)删除h的第
C语言之单向链表详解及实例代码
12-31
1，单向链简洁。...根据示例代码中的例子，完成单向链表(single linked list)中的以字符串为数据的链表的插入、删除以及查找，并支持单向链表的反转； 3，代码实现。 #include #include <math.h>
单向链表的创建及翻转
m_nValue的专栏
04-08 922
<br />感谢XX公司的笔试啊，让我总算下定决心彻底把这个似乎很简单的问题想一想了，发觉之前自己的理解真是差强人意！<br /> <br />下面的链表翻转是通过重新创建一个新链表来实现的，空间复杂度过于不理想...<br />#include <iostream> using namespace std; struct Node { int data; Node *next; }*head; void AddNode(int value); void Swap(Node *&head
链表——将单链表从m到n的结点位置翻转
jingsuwen1的博客
05-09 8054
题目：反转链表从m-n位置的结点 For example: Given1->2->3->4->5->NULL, m = 2 and n = 4, return1->4->3->2->5->NULL. 从第二到第四的结点被反转了。 其中m和n满足条件： 1 ≤ m ≤ n ≤ length of list. 思路： 仍是逆序
c++实现单向链表
henjdx的博客
03-26 1171
单向链表属于链表中的一类，链表是用于数据元素的线性集合，其中每个元素都指向下一个元素，元素存储上并不连续。单向链表的特性是每个元素只知道其下一个元素是谁。
单向链表Python
泰敢人辣的博客
07-26 3735
链表是一种常见的数据结构，用于存储和组织数据。它由一系列节点组成，每个节点包含数据和指向下一个节点的指针。 链表相对于数组的优势在于灵活性。由于链表的节点并不一定连续存储在内存中，因此可以动态地插入和删除节点，而不需要移动其他节点。然而，链表的缺点是访问特定位置的节点较慢，需要从头节点开始遍历到指定位置。
单向链表的C语言实现
Broken_x的博客
05-28 1277
首先，我们需要定义单向链表的结点和链表本身的结构// 单向链表的结点定义// 数据域// 指针域，指向后继结点} Listnode;// 单向链表的定义// 头结点// 整个链表的元素个数和：包含标准输入输出和标准库函数。：定义链表中数据的类型为int，可以根据需要更改。：定义链表结点结构体，包含数据域data和指向后继结点的指针next。：定义链表结构体，包含指向头结点的指针head和链表的元素个数size。
单向链表SingleLinkedList
weixin_66598341的博客
09-09 1439
本文案例仅仅使用Java语言实现单向链表的一些简单的增删改查，完成反转单向链表，以及借助栈逆序遍历单向链表等功能。
C语言——单向链表
2301_79695216的博客
07-21 772
线性表的链式存储结构，我们叫做链表。将线性表L=(a0,a1,……,an-1)中各元素分布在存储器中的不同存储区域，线性表中的各元素称为结点，通过地址或指针建立结点之间的联系，所得到的存储结构为链表 结构。
单向链表与双向链表
qq_57106106的博客
07-29 953
可以解决顺序表存储空间上限，插入和删除效率低的问题链表：链式存储的线性表链表的组成：由一个个节点组成节点：由数据域和指针域组成数据域：存放数据的区域指针域：存放下一个节点地址的指针单向链表，双向链表，循环链表只能通过头节点或者头指针单向的访问后继节点的链表，称为单向链表。每个节点的指针域只记录其后继节点的地址。（火车结构）头节点结构体格式：int len；//头节点的数据域普通节点结构体格式：int data；//普通节点的数据域unionint len；//头节点的数据域。
数据结构——单向链表
最新发布
脑壳有点痒，好像要长脑子了！
08-04 1129
链表（Linked List）是一种常见的数据结构，它属于线性表的一种链式存储结构，其逻辑上相邻的元素在物理存储位置并不相邻。它由一系列节点（Node）组成，每个节点包含数据部分和指向列表中下一个节点（或者上一个节点）的指针（链接）。链表中的节点通过指针相互连接，从而形成一个序列。链表可以分为几种不同的类型，但最常见的是单向链表和双向链表。
C语言单向链表的表示与实现实例详解
12-31
C语言中的单向链表（单链表）是链表的一种，其特点是链表的链接方向是单向的，对链表的访问要通过顺序读取从头部开始。 链表中最简单的一种是单向链表，它包含两个域，一个信息域和一个指针域。这个链接指向列表中的...
单向链表类模板_单向链表类模板_fastchq_
10-03
单向链表是一种常见的数据结构，它由一系列节点组成，每个节点包含数据和指向下一个节点的指针。在C++编程中，为了实现通用性，我们通常会使用模板类来创建单向链表，以便它可以处理不同类型的元素。标题"单向链表类...
单向链表 代码架构
12-29
单向链表是一种基本的数据结构，它在计算机科学和编程中有着广泛的应用。与数组不同，链表中的元素不是在内存中连续存储的，而是通过指针或引用连接在一起，形成一个逻辑上的线性序列。单向链表的每个节点包含两部分...
Python单向链表和双向链表原理与用法实例详解
09-20
在Python中，我们可以自定义链表结构来实现单向链表和双向链表。 单向链表（Single Linked List）的特点是每个节点只包含一个指向下一个节点的引用。在单向链表中，遍历只能从头节点开始，按顺序访问每个节点，无法...
二叉树赋值版(部分功能)
qq_41006871的博客
05-27 2365
#include<stdio.h> #include<stdlib.h> #include<string.h> #include<conio.h> typedef struct BiTreenode { char data; struct BiTreenode *lchild,*rchild; }BiTree; BiTree *Cre...
学生信息链表
qq_41006871的博客
05-28 1859
#include<stdio.h> #include<string.h> #include<stdlib.h> #include<conio.h> ///本程序采用链表的操作，也就是不限空间 struct node { char num[20];///学号 char name[20];///姓名 char sex[20];//...
双向循环链表基本操作
qq_41006871的博客
05-28 979
#include<stdio.h> #include<stdlib.h> #include<conio.h> typedef struct node { struct node *prior;///前驱 int data;///数据 struct node *next;///后继 }linklist; void clear();///清屏...
循环队列基本操作
qq_41006871的博客
05-28 751
#include<stdio.h> #include<conio.h> #include<stdlib.h> #include<malloc.h> #define OK 1 #define ERROR 0 #define MAXSIZE 4///分配的最大空间 typedef struct que { int *base;///存数据 ...
C语言实现单向链表的基本操作
"这篇资源是关于单向链表的基础知识，包括如何在C语言中实现单向链表的初始化、创建、销毁等操作。" 在数据结构中，链表是一种非常重要的非线性数据结构。单向链表是其中一种形式，每个节点包含一个数据元素和一个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值