嵌入式养成计划-19-数据结构之单向循环链表

已于 2023-08-29 17:04:33 修改
阅读量60 收藏
点赞数
分类专栏： C/C++ 数据结构与算法 文章标签： 数据结构 链表 c++ 开发语言 c语言 linux
于 2023-08-29 08:55:06 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52625576/article/details/132553783
版权

五十一、单向循环链表

51.1 单向循环链表的思想

  • 创建时 : 头结点的next指针域指向头结点
  • 插入时 : 尾结点的next指针域指向头结点
  • 到尾结点条件 ： 当前结点的next指针域是否指向头结点

51.2 与单链表的区别

  • 单链表:
    1. 创建时 : 头结点的next指针域指向NULL
    2. 插入时 ： 尾结点的next指针域指向NULL
    3. 到尾结点条件 ： 当前结点的next指针域是否指向NULL
  • 单向循环链表:
    1. 头结点的next指针域指向头结点
    2. 尾结点的next指针域指向头结点
    3. 当前结点的next指针域是否指向头结点

51.3 单向循环链表功能实现完整代码

51.3.1 接口(head.h)

#ifndef __HEAD_H__
#define __HEAD_H__

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

//	重命名数据域的数据类型名
typedef int data;

//  数据域是一个联合体，指针域指向下一结点
typedef struct myCirLinkList
{
    
    union
    {
        data num;   //  表示数据内容
        int len;    //  len表示当前有多少结点(头结点除外)
    };
    //  指向下一结点的指针
    struct myCirLinkList *next;
} cirLinkNode; //  结构体类型名重命名为cirLinkNode

// 创建单向循环链表
cirLinkNode *init();

// 单链表的判空
int is_empty(cirLinkNode *L);

// 单链表的尾插
int tail_insert(cirLinkNode *l, data value);

// 单链表的头插
int head_insert(cirLinkNode *l, data value);

//  指定下标插入
int inset_by_index(cirLinkNode *l, int index, data value);

//  指定下标删除
int del_by_index(cirLinkNode *l, int index);

//  头删
int head_del(cirLinkNode *l);

//  尾删
int tail_del(cirLinkNode *l);

//  按值删除,返回删除的下标
int del_by_value(cirLinkNode *l, data value);

// 单链表的按值查找，返回下标
int find_by_value(cirLinkNode *l, data value);

// 单链表的按值修改,返回下标
int change_by_value(cirLinkNode *l, data old_value, data new_value);

// 单链表的按位置查找，返回对应的值
data find_by_index(cirLinkNode *l, int index);

// 单链表的选择排序
int select_sort(cirLinkNode *l);

// 单链表的冒泡排序
int bubble_sort(cirLinkNode *l);

//  输出单链表
int output(cirLinkNode *l);

//  单链表去重
int remove_duplicates(cirLinkNode *l);

//  释放单链表
int free_cirLinkNode(cirLinkNode **l);

//  单链表的翻转,循环头插
int flip_cirLinkNode(cirLinkNode *l);


#endif

51.3.2 功能实现(circularLinkedList.c)

#include "head.h"
// 创建单向循环链表
cirLinkNode *init()
{
    cirLinkNode *p=(cirLinkNode*)malloc(sizeof(cirLinkNode));
    //	申请失败时返回NULL
    if (NULL == p)
    {
        printf("创建单向循环链表失败\n");
        return NULL;
    }
    //  初始结点数为0(头结点除外)
    p->len = 0;
    //  初始结点的指针域指向头结点
    p->next = p;
    //  返回申请的堆区空间的首地址
    return p;
    
}

// 单向循环链表的判空
int is_empty(cirLinkNode *l)
{
    if (NULL == l)
    {
        printf("传入参数为空\n");
        return -1;
    }
    //  只有一个头结点,或者结点数为0(头结点除外),此时链表为空,返回1
    if (l == l->next || l->len == 0)
    {
        return 1;
    }
    return 0; //  链表不是空,返回0
}

// 单向循环链表的尾插
int tail_insert(cirLinkNode *l, data value)
{
    if (NULL == l)
    {
        printf("传入参数为空\n");
        return -1;
    }
    //  防止头结点指向改变,故新建一个指针指向头结点
    cirLinkNode *p = l;
    //  循环向后指,直到p指向最后一个结点
    while (l != p->next)
    {
        p = p->next;
    }
    //  新申请一个结点的空间,用ll指向
    cirLinkNode *ll = (cirLinkNode *)malloc(sizeof(cirLinkNode));
    //  新结点的值为传进来的值
    ll->num = value;
    //  新结点的next指针域指向头结点
    ll->next = l;
    //  新结点插到最后
    p->next = ll;
    //  结点计数变量+1
    l->len++;
    return 0;
}

// 单向循环链表的头插
int head_insert(cirLinkNode *l, data value)
{
    if (NULL == l)
    {
        printf("传入参数为空\n");
        return -1;
    }
    //  防止头结点指向改变,故新建一个指针指向头结点
    cirLinkNode *p = l;
    //  新申请一个结点的空间,用ll指向
    cirLinkNode *ll = (cirLinkNode *)malloc(sizeof(cirLinkNode));
    //  新结点的值为传进来的值
    ll->num = value;
    //  新结点的next指针域指向头结点的原下一结点,即原第一结点
    ll->next = p->next;
    //  让头结点指向这个新结点
    p->next = ll;
    //  结点计数变量+1
    l->len++;
    return 0;
}

//  根据位置插入
int inset_by_index(cirLinkNode *l, int index, data value)
{
    if (NULL == l)
    {
        printf("传入参数为空\n");
        return -1;
    }
    if (index <= 0 || index > l->len)
    {
        printf("传入的下标有问题\n");
        return -1;
    }
    //  防止头结点指向改变,故新建一个指针指向头结点
    cirLinkNode *p = l;
    //  记录当前下标
    int i = 1;
    while (1)
    {
        //  如果当前下标与传进来的下标相等,进行头插
        //  因为此时指针p已经循环指向了此下标对应的结点的首地址
        if (i == index)
        {
            // head_insert(p, value);   //  不能直接调用头插法,因为传进来的头结点不是真正头结点
            cirLinkNode *ll = (cirLinkNode *)malloc(sizeof(cirLinkNode));
            ll->num = value;
            ll->next = p->next;
            p->next = ll;
            //  插入后退出循环
            break;
        }
        //  如果找到了最后还没找到,说明位置参数不对
        if (l == p->next)
        {
            printf("传入位置参数不合法\n");
            //  位置参数不对,return -1 表示函数异常结束
            return -1;
        }
        //  这一圈没找到则当前下标+1向后找
        ++i;
        //  p向后指,继续向后找
        p = p->next;
    }
    //  找到并插入后,结点数+1
    l->len++;
    return 0;
}


//  头删
int head_del(cirLinkNode *l)
{
    if (NULL == l)
    {
        printf("传入参数为空\n");
        return -1;
    }
    if (is_empty(l))
    {
        printf("只有头结点,无法进行删除\n");
        return -1;
    }
    //  防止头结点指向改变,故新建一个指针指向头结点
    cirLinkNode *p = l;
    //  保存待删除的结点,第一结点
    cirLinkNode *q = l->next;
    //  将头结点的next指针域指向下下一结点
    p->next = q->next;
    //  释放第一结点的空间
    free(q);
    q = NULL;
    //  结点计数变量-1
    l->len--;
    return 0;
}

//  尾删
int tail_del(cirLinkNode *l)
{
    if (NULL == l)
    {
        printf("传入参数为空\n");
        return -1;
    }
    if (is_empty(l))
    {
        printf("只有头结点,无法进行删除\n");
        return -1;
    }

    //  防止头结点指向改变,故新建一个指针指向头结点
    cirLinkNode *p = l;
    //  循环找到最后一个结点
    while (1)
    {
        //  如果下一结点的next指针域指向头结点
        //  说明当前结点是倒数第二个结点
        if (NULL == p->next->next)
        {
            //  q指向最后这个结点
            cirLinkNode *q = p->next;
            //  倒数第二个结点的next指针域指向头结点
            p->next = l;
            //  释放最后这个结点的空间
            free(q);
            q = NULL;
            //  退出循环
            break;
        }
        //  当前结点不是倒数第二个结点时继续向下找
        p = p->next;
    }
    //  删除后,结点计数变量-1
    l->len--;
    return 0;
}

//  指定下标删除,头结点之后
int del_by_index(cirLinkNode *l, int index)
{
    if (NULL == l)
    {
        printf("传入参数为空\n");
        return -1;
    }
    if (index <= 0 || index > l->len)
    {
        printf("传入的下标有问题\n");
        return -1;
    }
    if (is_empty(l))
    {
        printf("只有头结点\n");
        return -1;
    }
    //  防止头结点指向改变,故新建一个指针指向头结点
    cirLinkNode *p = l;
    //  记录当前下标
    int i = 1;
    while (1)
    {
        //  如果当前下标与传进来的下标相等,进行删除
        //  此时指针p的next指针域已经循环指向了要找的下标对应的结点
        //  即p指向要删除的结点的前一结点
        if (i == index)
        {
            //  q指向这个要删除的结点
            cirLinkNode *q = p->next;
            //  让要删除的结点前一结点和后面一个结点连接
            //  越过要删除的这个结点
            p->next = q->next;
            //  释放要删除的这一结点的空间
            free(q);
            q = NULL;
            //  删除后退出循环
            break;
        }
        //  循环到了最后还没找到这个下标对应的结点
        if (l == p->next)
        {
            //  提示位置参数不对,并返回-1表示函数异常结束
            printf("传入位置参数不合法\n");
            return -1;
        }
        //  这一圈没找到则当前下标+1向后找
        ++i;
        //  p继续向后指,向后接着找
        p = p->next;
    }
    //  删除后,结点计数变量-1
    l->len--;
    return 0;
}


//  按值删除,返回删除的下标
int del_by_value(cirLinkNode *l, data value)
{
    if (NULL == l)
    {
        printf("传入参数为空\n");
        return -1;
    }
    if (is_empty(l))
    {
        printf("只有头结点\n");
        return -1;
    }
    //  防止头结点指向改变,故新建一个指针指向头结点
    cirLinkNode *p = l;
    //  记录当前下标
    int i = 1;
    //  循环向后找
    while (1)
    {
        //  如果下一结点的值与传进来的值相同,则进行删除
        if (value == p->next->num)
        {
            //  指针q指向下一结点,即要删除的结点
            cirLinkNode *q = p->next;
            //  当前结点的next指针域指向要删除的结点的下一个结点
            p->next = q->next;
            //  释放要删除的结点的空间
            free(q);
            l->len--;
            //  返回当前所在下标
            return i;
        }
        //  如果找到了最后还没找到就退出循环
        if (l == p->next)
        {
            break;
        }
        //  这一圈没找到则当前下标+1向后找
        ++i;
        //  p继续向后指,向后接着找
        p = p->next;
    }
    //  循环没找到,输出找不到这个值
    printf("找不到这个值\n");
    //  返回-1表示函数异常结束
    return -1;
}

// 单向循环链表的按值查找,返回下标,头结点之后
int find_by_value(cirLinkNode *l, data value)
{
    if (NULL == l)
    {
        printf("传入参数为空\n");
        return -1;
    }
    if (is_empty(l))
    {
        printf("只有头结点\n");
        return -1;
    }
    //  防止头结点指向改变,故新建一个指针指向头结点的下一结点
    cirLinkNode *p = l->next;
    //  记录当前位置
    int i = 1;
    //  循环向后找
    while (1)
    {
        //  如果下一结点的值与传进来的值相同,则返回当前位置
        if (value == p->num)
        {
            return i;
        }
        //  如果找到了最后还没找到就退出循环
        if (l == p->next)
        {
            break;
        }
        //  这一圈没找到则当前下标+1向后找
        ++i;
        //  p继续向后指,向后接着找
        p = p->next;
    }
    //  循环没找到,输出找不到这个值
    printf("链表中没有这个值\n");
    //  返回-1表示函数异常结束
    return -1;
}

// 单向循环链表的按值修改,返回下标
int change_by_value(cirLinkNode *l, data old_value, data new_value)
{
    if (NULL == l)
    {
        printf("传入参数为空\n");
        return -1;
    }
    if (is_empty(l))
    {
        printf("只有头结点\n");
        return -1;
    }
    //  防止头结点指向改变,故新建一个指针指向头结点的下一结点
    cirLinkNode *p = l->next;
    //  记录当前位置
    int i = 1;
    //  循环向后找
    while (1)
    {
        //  如果下一结点的值与传进来的旧值相同,则用新值进行修改并返回当前位置
        if (old_value == p->num)
        {
            p->num = new_value;
            return i;
        }
        //  如果找到了最后还没找到就退出循环
        if (l == p->next)
        {
            break;
        }
        //  这一圈没找到则当前下标+1向后找
        ++i;
        //  p继续向后指,向后接着找
        p = p->next;
    }
    //  循环没找到,输出找不到这个值
    printf("链表中没有这个值\n");
    //  返回-1表示函数异常结束
    return -1;
}

// 单向循环链表的按位置查找，返回对应的值
data find_by_index(cirLinkNode *l, int index)
{
    if (NULL == l)
    {
        printf("传入参数为空\n");
        return -1;
    }
    if (index < 0 || index > l->len)
    {
        printf("传入的下标有问题\n");
        return -1;
    }
    if (is_empty(l))
    {
        printf("只有头结点\n");
        return -1;
    }
    //  防止头结点指向改变,故新建一个指针指向头结点的下一结点
    cirLinkNode *p = l->next;
    //  记录当前位置
    int i = 1;
    //  循环向后找
    while (1)
    {
        //  如果当前位置与传进来的下标相同,则返回这个位置的值
        if (i == index)
        {
            return p->num;
        }
        //  如果找到了最后还没找到则提示位置参数不对
        if (l == p->next)
        {
            printf("传入位置参数不合法\n");
            //  返回-1表示函数异常结束
            return -1;
        }
        //  这一圈没找到则当前下标+1向后找
        ++i;
        //  p继续向后指,向后接着找
        p = p->next;
    }
}


// 单向循环链表的简单选择排序,降序
int select_sort(cirLinkNode *l)
{
    if (NULL == l)
    {
        printf("传入参数为空\n");
        return -1;
    }
    if (is_empty(l))
    {
        printf("只有头结点,无法进行简单选择排序\n");
        return -1;
    }
    //  防止头结点指向改变,故新建一个指针指向头结点的下一结点
    //  结点指针p后面表示当前结点,结点指针q后面表示被比较的的结点
    cirLinkNode *p = l->next, *q;
    //  外层循环,控制循环次数
    while (1)
    {
        //  后面没有结点了,结束外层循环
        if (l == p->next)
        {
            break;
        }
        //  指针q指向p的下一结点
        //  表示被比较的结点是从当前结点的下一结点开始,会到最后一个结点
        q = p->next;
        //  假设最大值的结点是当前结点
        cirLinkNode *max = p;
        //  内层循环,表示比较次数
        while (1)
        {
            //  如果被比较的结点比当前认定的最大结点的值还大
            if (q->num > max->num)
            {
                //  那么让最大结点指针指向这个结点
                max = q;
            }
            //  如果被比较的结点到了最后一个,则退出内层循环
            if (l == q->next)
            {
                break;
            }
            //  被比较的结点逐个往后挪
            q = q->next;
        }
        //  当前结点与最大结点指针指向的结点进行值交换
        data t = max->num;
        max->num = p->num;
        p->num = t;

        //  当前结点逐个往后挪
        p = p->next;
    }
    return 0;
}


// 单向循环链表的冒泡排序,升序
int bubble_sort(cirLinkNode *l)
{
    if (NULL == l)
    {
        printf("传入参数为空\n");
        return -1;
    }
    if (is_empty(l))
    {
        printf("只有头结点,无法进行冒泡排序\n");
        return -1;
    }
    //  防止头结点指向改变,故新建一个指针指向头结点的下一结点
    //  结点指针p控制外层循环次数,结点指针end控制内层比较次数
    //  结点指针q用于比较
    cirLinkNode *p = l->next, *q, *end = l;
    //  外层循环,表示循环次数
    while (1)
    {
        if (l == p->next) //  后面没有结点了,直接结束
        {
            break;
        }
        //  每次都从第一个数据结点开始(头结点后的第一结点)
        q = l->next;
        //  内层循环,表示比比较次数
        while (1)
        {
            //  如果 当前值 大于 后面的值,则交换
            if (q->num > q->next->num)
            {
                data t = q->num;
                q->num = q->next->num;
                q->next->num = t;
            }
            //  到了尚未比较的结点中倒数第二个结点,前面已经比较过了,该退出进行下一轮的比较了
            if (end == q->next->next)
            {
                //  更新结束条件
                end = q->next;
                break;
            }
            //  内层循环递进,用于比较的结点向后逐步挪移
            q = q->next;
        }
        //  外层循环递进,p逐渐向后指向,直到最后一个结点后进入下次循环时结束
        p = p->next;
    }
    return 0;
}


//  输出单向循环链表
int output(cirLinkNode *l)
{
    if (NULL == l)
    {
        printf("传入参数为空\n");
        return -1;
    }

    //  防止头结点指向改变,故新建一个指针指向头结点
    //  用于指向待输出的结点
    cirLinkNode *p = l;
    //  记录当前到第几个结点
    int i = 0;
    while (1)
    {
        //  是头结点时
        if (0 == i)
        {
            printf("除头结点外,其余结点个数为:%d\n", p->len);
        }
        else //  非头结点时
        {
            printf("第%d位数据为:%d\n", i, p->num);
        }
        //  位置变量+1
        ++i;
        //  如果到了最后一个结点,那么就退出(因为是先输出的,所以已经输出过了)
        if (l == p->next)
            break;
        //  待输出的结点向后逐位移动
        p = p->next;
    }
    return 0;
}


//  单向循环链表去重
int remove_duplicates(cirLinkNode *l)
{
    if (NULL == l)
    {
        printf("传入参数为空\n");
        return -1;
    }
    if (is_empty(l))
    {
        printf("只有头结点,无需去重\n");
        return -1;
    }
    //  防止头结点指向改变,故新建一个指针指向头结点
    //  用于记录当前结点
    cirLinkNode *p = l;
    //  外层循环,控制循环次数
    while (1)
    {
        //  用于记录被比较结点的前一结点
        cirLinkNode *q = p;
        //  内层循环,用于控制比较次数
        while (1)
        {
            //  如果被比较的结点到了最后一位,则退出
            if (l == q->next)
            {
                break;
            }
            //  如果当前结点的值与被比较的结点的值相同,则删除这个被比较的结点
            if (q->next->num == p->num)
            {
                //  用于指向被比较的结点
                cirLinkNode *t = q->next;
                //  被比较的前一结点的next指针域指向被比较的结点的后一结点
                q->next = t->next;
                //  释放这个被比较的结点
                free(t);
                t = NULL;
                //  结点计数变量-1
                l->len--;
            }
            //  让被比较的结点向后挪动
            q = q->next;
        }
        //  让当前结点向后挪动
        p = p->next;
        //  如果当前结点挪到了最后,则退出
        if (l == p)
        {
            break;
        }
    }
    return 0;
}


//  释放单向循环链表
int free_cirLinkNode(cirLinkNode **l)
{
    if (NULL == l)
    {
        printf("传入参数为空\n");
        return -1;
    }
    //  用于接收传来的头结点指针
    //  传来的是头结点指针的地址,所以需要解引用获得其指向的地址
    cirLinkNode *p = *l;
    //  用于存放准备释放的结点的下一结点,免得找不到了
    cirLinkNode *q = p->next;
    //  进入循环,准备逐个释放
    while (1)
    {
        //  释放当前结点
        free(p);
        //  让下一结点变成当前结点
        p = q;
        //  如果当前结点到了最后,指针又指向头结点,表示空间都释放了
        //  所以需要将头结点指针的指向更改,即需要解引用指向NULL,然后退出
        if (*l == p)
        {
            *l = NULL;
            return 0;
        }
        //  待释放结点的下一结点向后挪
        //  因为上面已经把原来待释放结点的下一结点变成了当前准备释放的结点了
        q = q->next;
    }
}

//  单向循环链表的翻转,循环头插
int flip_cirLinkNode(cirLinkNode *l)
{
    if (NULL == l)
    {
        printf("传入参数为空\n");
        return -1;
    }
    if (is_empty(l))
    {
        printf("只有头结点,无法进行翻转\n");
        return -1;
    }
    if (1 == l->len)
    {
        printf("只有一个数据结点,无需翻转\n");
        return -1;
    }

    //  让除了第一数据结点外的其他结点依次进行头插,即可得到翻转后的链表
    //  如果直接调用头插法,会重新生成结点,导致空间浪费
    //  这是个面试题
    cirLinkNode *p = l->next->next; //  记录当前需要头插的结点
    //  将原本的第一数据结点的next指针域指向头结点
    //  因为最后这个结点会变成尾结点
    l->next->next = l;
    cirLinkNode *q = p->next; //  记录下次需要头插的结点
    //  循环头插
    while (1)
    {
        //  将当前需要插入的结点的next指针域指向现在的第一数据结点
        p->next = l->next;
        //  将头结点的next指针域指向当前需要插入的结点
        //  这样当前需要插入的结点就完成了头插,变成了新的第一数据结点
        l->next = p;
        //  让下次需要头插的结点变成当前需要插入的结点
        p = q;
        //  如果下次需要头插的结点没有指向原尾结点的next指针域
        if (l != q)
        {
            q = q->next;
        }
        //  如果当前下次需要插入的结点已经指向原尾结点的next指针域
        //  即表示已经到了原尾结点的后一个结点了,那么就退出循环
        //  这样可以将原尾结点也进行头插,不然会漏掉原尾结点
        else
            break;
    }
    return 0;
}

51.3.3测试用主函数(main.c)

#include "head.h"

int main()
{
    cirLinkNode *l = init();
    output(l);

    printf("%d\n", is_empty(l));

    head_insert(l, 32);
    output(l);
    printf("%d\n", is_empty(l));

    putchar(10);

    puts("------------------------1-------------------------");

    head_insert(l, 35);
    output(l);
    putchar(10);
    puts("-------------------------2------------------------");
    tail_insert(l, 100);
    output(l);
    putchar(10);
    puts("--------------------------3-----------------------");
    head_insert(l, 32);
    output(l);
    putchar(10);
    head_insert(l, 39);
    output(l);
    putchar(10);



    printf("两极反转\n");
    flip_cirLinkNode(l);
    output(l);
    putchar(10);

    printf("简单选择排序\n");
    select_sort(l);
    output(l);
    putchar(10);

    printf("冒泡排序\n");
    bubble_sort(l);
    output(l);
    putchar(10);

    printf("去重\n");
    remove_duplicates(l);
    output(l);
    putchar(10);

    del_by_index(l, 2);
    // head_del(l);
    output(l);
    putchar(10);

    printf("%d\n", find_by_index(l, 1));
    printf("%d\n", find_by_value(l, 200));
    output(l);
    putchar(10);

    printf("%d\n", del_by_value(l, 100));
    output(l);
    putchar(10);

    printf("%p\n", l);

    printf("释放\n");
    free_cirLinkNode(&l);

    printf("%p\n", l);

    return 0;
}

51.3.4 Makefile

EXE=circularLinkedList
CC=gcc
CFLAGs=-c
OBJs+=circularLinkedList.o
OBJs+=main.o

all:$(EXE)

$(EXE):$(OBJs)
	$(CC) $^ -o $@

%.o:%.c
	$(CC) $(CFLAGs) $^ -o $@

clean:
	rm *.o circularLinkedList
zhk___
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
嵌入式学习-02-数据结构和算法 (链表)
03-15
嵌入式学习-02-数据结构和算法 (链表)
链表-使用PHP实现的循环链表数据结构.zip
03-13
链表是一种基础且重要的数据结构，它在计算机科学中扮演着关键角色，特别是在处理动态数据集合时。不同于数组，链表中的元素不连续存储在内存中，而是通过指针（在PHP中为对象引用）相互链接。循环链表是链表的一种...
数据结构-使用javascript讲解数据结构之链表.zip
02-12
本资料包“数据结构-使用javascript讲解数据结构之链表.zip”将深入探讨链表的概念、实现以及其在JavaScript中的应用。 链表不同于数组，数组是连续的内存空间，而链表的元素在内存中是非连续存储的。每个元素称为...
数据结构-循环链表-C语言实现循环链表功能-数据结构学习
05-26
C语言实现的数据结构中的循环链表 包含源码（.c文件），linux环境下编译生成的可执行文件，头文件 用于C语言以及数据结构的学习，熟练对循环链表边界的判定 实现了以下功能： 创建无头循环链表 向循环链表中插入...
数据结构-单向链表教程.zip
08-24
本系列教程深入剖析链表数据结构，从基础概念到高级操作，全面覆盖。首先介绍链表的提出背景，随后通过单链表的ADT（抽象数据类型）模型，阐释其理论基础。接着，通过实际代码演示单链表及结点的定义，以及如何实现...
C++笔记18•数据结构:AVL树•
qq_64446190的博客
09-06 361
AVL树
MATLAB 中双引号 ““ 和单引号 ‘‘ 的区别详解
2202_75569688的博客
09-03 502
在 MATLAB 中，双引号""和单引号''都可以用来表示字符串，但它们的作用和底层类型是不同的。理解它们之间的区别，对于正确使用字符串处理功能非常重要。本文将深入探讨 MATLAB 中""和''的区别，以及在实际编程中的应用场景。
栈—数据结构
weixin_63722559的博客
09-06 726
6、获取栈顶元素（获取栈顶元素，在外面开一个空间，将该空间的地址传过去，进行获取元素，以便于区分元素还是返回值）入栈的方向是是增栈的方式，放入数据的是满栈的方式。入栈的方向是是减栈的方式，放入数据的是满栈的方式。入栈的方向是是增栈的方式，放入数据的是空栈的方式。入栈的方向是是减栈的方式，放入数据的是空栈的方式。3、出栈（看一下，出去的元素，所以和6一样）1、入栈：先放入输入，再移动栈顶指针。2、出栈：先移动栈顶指针，再数据弹出。1、入栈：先挪栈顶指针，再放入数据。2、出栈：先移出数据，再移动指针。
【数据结构-二维前缀和】力扣1277. 统计全为 1 的正方形子矩阵
sjsjs11的博客
09-06 256
该题和力扣221.最大正方形类似，以某一格为右下角能形成最大正方形的边长，就是以该格为右下角的正方形数量。给你一个 m * n 的矩阵，矩阵中的元素不是 0 就是 1，请你统计并返回其中完全由 1 组成的 正方形 子矩阵的个数。正方形的总数 = 10 + 4 + 1 = 15.正方形的总数 = 6 + 1 = 7.边长为 1 的正方形有 10 个。边长为 2 的正方形有 4 个。边长为 3 的正方形有 1 个。边长为 1 的正方形有 6 个。边长为 2 的正方形有 1 个。输入：matrix =
数据结构---单向链表
2301_78040391的博客
09-03 293
【代码】数据结构---链表。
【数据结构初阶】——栈和队列
2302_78420373的博客
09-03 978
小伙伴们，大家好呀，今天我们学习的是数据结构中的栈和队列之前我们写过【栈和队列的OJ题】，但是有很多小伙伴不知道栈和队列讲的是什么，咱们就好好聊聊这些就是栈和队列(初阶)的全部内容了，要是想做一点题的可以看看这篇哦【栈和队列OJ题】
数据结构（1）数据结构基础（单向链表）
weixin_68239724的博客
09-03 603
数据结构是一组用来保存一种或多种特定关系的数据的集合。其主要目的是组织和存储数据，以便于高效的访问和修改。程序 = 数据结构 + 算法单向链表是一种线性数据结构，由一系列节点构成，每个节点包含数据部分和指向下一个节点的指针。它是一种灵活的存储方式，相比于数组，单向链表不需要连续的内存空间。
数据结构 栈 队列
qq_69971969的博客
09-06 494
数据的插入--->入栈 数据的删除----->出栈。函数的调用关系（保护现场，恢复现场操作，遵循先进后出，后进先出）缓存数据：主要使用队列，类似于缓冲区，防止数据丢失。允许从一端插入数据，另一端删除数据的线性存储结构。只允许从一端进行数据的插入和删除的线性存储结构。增栈 减栈：用栈顶的增长方向区分（移动方向）顺序队列：假溢出------>循环队列。满栈 空栈：栈顶所在位置是否存有元素。增栈：从内存低地址向高地址移动。减栈：从内存高地址向低地址移动。链式队列：用链表方式构造队列。
【数据结构】单链表功能的实现
2302_81312180的博客
09-03 972
图中指针变量 plist保存的是第一个节点的地址，我们称plist此时“指向”第一个节点，如果我们希望plist“指向”第二个节点时，只需要修改plist保存的内容为0x0012FFA0。链表中每个节点都是独立申请的（即需要插入数据时才去申请一块节点的空间），通过指针变量保存下一个节点位置才能从当前节点找到下一个节点。且每节车厢都有车门，假设每节车厢的车门都是锁上的状态，需要不同的钥匙才能解锁，每次只能携带一把钥匙的情况下。与顺序表不同的是，链表里的每节"车厢"都是独立申请下来的空间，我们称之为“链表中每个
数据结构————栈、队列
最新发布
qq_63843346的博客
09-06 471
在使用数组实现的队列中，如果队列的尾部已经到达数组的末尾，但数组的前部仍有空闲空间，此时队列将无法继续入队，产生假溢出。：特别是在使用数组实现的队列中，如果队列的长度远小于数组的长度，那么数组的大部分空间将被浪费。：虽然队列的遍历通常比栈更简单（因为不需要额外的空间来保存遍历过程中的元素），但在某些情况下（如需要频繁遍历队列），队列的遍历效率可能不是最优的。即最早插入队列的元素将会是第一个被移除的。：栈的遍历通常需要额外的空间来保存遍历过程中的元素，因为栈的后进先出特性使得遍历过程与元素的自然顺序相反。
数据结构——单链表相关操作
xgshxjhs_的博客
09-03 437
定义链表节点和对象类型。
【数据结构】【java】leetcode刷题记录--链表
FQY__的博客
09-06 392
链表是一种常见的基础数据结构，它由一系列节点组成，每个节点包含数据域和指向下一个节点的指针。在Java中，链表通常用于实现动态数据结构，因为它可以根据需要动态地增加或减少节点。节点结构：链表中的每个元素称为节点（Node），每个节点包含两部分：数据域（存储数据）和指针域（存储下一个节点的地址）动态性：链表的长度不是固定的，可以根据需要动态地增减节点。内存分配：链表中的节点不必在连续的内存地址中，它们可以在内存中的任何位置。
数据结构——开篇
2301_80315592的博客
09-03 627
用来保存一种或多种的数据的集合（组织和存储数据）。程序 = 数据结构+算法。
第三章 数组（5）
qq_62387839的博客
09-03 930
例如，一个拥有6个元素的数组，在排序过程中每一次循环的排序过程和结果如下图所示，绿色的数字处于正在进行比较的状态，蓝色的数字表示处于等待排序的状态，黑色的数字表示已经完成排序的状态。冒泡排序的基本思路是对比相邻的元素值，如果满足条件就交换元素值，把较小的元素移动到数组前面，把大的元素移动到数组后面（也就是交换两个元素的位置），这样较小的元素就像气泡一样从底部上升到顶部。算法比较的次数为数组长度减1，因为最后一次比较时，只剩下两个等待比较的元素，完成这两个元素的比较之后，整个数组就完成了排序。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

zhk___

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值