第10节 链表回顾

最新推荐文章于 2023-10-02 20:41:16 发布
最新推荐文章于 2023-10-02 20:41:16 发布
阅读量90 收藏
点赞数
分类专栏： 数据结构与算法 文章标签： 数据结构与算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/pt_raspi_fresher/article/details/87120932
版权

-------------------------------------资源来源于网络,仅供自学使用,如有侵权,联系我必删.

第一:

链表SeqList2.0

在SeqList.c里面优化了一行代码!!!!

#ifndef _SEQLIST_H_
#define _SEQLIST_H_

typedef void SeqList;
typedef void SeqListNode;

SeqList* SeqList_Create(int capacity);

void SeqList_Destroy(SeqList* list);

void SeqList_Clear(SeqList* list);

int SeqList_Length(SeqList* list);

int SeqList_Capacity(SeqList* list);

int SeqList_Insert(SeqList* list, SeqListNode* node, int pos);

SeqListNode* SeqList_Get(SeqList* list, int pos);

SeqListNode* SeqList_Delete(SeqList* list, int pos);

#endif


#include <stdio.h>
#include <malloc.h>
#include "SeqList.h"

typedef unsigned int TSeqListNode;

typedef struct _tag_SeqList
{
    int capacity;
    int length;
    TSeqListNode* node;
} TSeqList;

SeqList* SeqList_Create(int capacity) // O(1)
{
    TSeqList* ret = NULL;
    
    if( capacity >= 0 )
    {
        ret = (TSeqList*)malloc(sizeof(TSeqList) + sizeof(TSeqListNode) * capacity);
    }
    
    if( ret != NULL )
    {
        ret->capacity = capacity;
        ret->length = 0;
        ret->node = (TSeqListNode*)(ret + 1);
    }
    
    return ret;
}

void SeqList_Destroy(SeqList* list) // O(1)
{
    free(list);
}

void SeqList_Clear(SeqList* list) // O(1)
{
    TSeqList* sList = (TSeqList*)list;
    
    if( sList != NULL )
    {
        sList->length = 0;
    }
}

int SeqList_Length(SeqList* list) // O(1)
{
    TSeqList* sList = (TSeqList*)list;
    int ret = -1;
    
    if( sList != NULL )
    {
        ret = sList->length;
    }
    
    return ret;
}

int SeqList_Capacity(SeqList* list) // O(1)
{
    TSeqList* sList = (TSeqList*)list;
    int ret = -1;
    
    if( sList != NULL )
    {
        ret = sList->capacity;
    }
    
    return ret;
}

int SeqList_Insert(SeqList* list, SeqListNode* node, int pos) // O(n) 
{
    TSeqList* sList = (TSeqList*)list;
    int ret = (sList != NULL);
    int i = 0;
    
    ret = ret && (sList->length + 1 <= sList->capacity);
    ret = ret && (0 <= pos);
    
    if( ret )
    {
        if( pos >= sList->length )
        {
            pos = sList->length;
        }
        
        for(i=sList->length; i>pos; i--)
        {
            sList->node[i] = sList->node[i-1];
        }
        
        sList->node[i] = (TSeqListNode)node;
        
        sList->length++;
    }
    
    return ret;
}

SeqListNode* SeqList_Get(SeqList* list, int pos) // O(1) 
{
    TSeqList* sList = (TSeqList*)list;
    SeqListNode* ret = NULL;
    
    if( (sList != NULL) && (0 <= pos) && (pos < sList->length) )    //修正:这里把等号去掉了
    {
        ret = (SeqListNode*)(sList->node[pos]);
    }
    
    return ret;
}

SeqListNode* SeqList_Delete(SeqList* list, int pos) // O(n)
{
    TSeqList* sList = (TSeqList*)list;
    SeqListNode* ret = SeqList_Get(list, pos);
    int i = 0;
    
    if( ret != NULL )
    {
        for(i=pos+1; i<sList->length; i++)
        {
            sList->node[i-1] = sList->node[i];
        }
        
        sList->length--;
    }
    
    return ret;
}

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

/* run this program using the console pauser or add your own getch, system("pause") or input loop */

int main(int argc, char *argv[]) 
{
    SeqList* list = SeqList_Create(10);
    
    int i = 0;
    int j = 1;
    int k = 2;
    int x = 3;
    int y = 4;
    int z = 5;
    
    SeqList_Insert(list, &i, 0);
    SeqList_Insert(list, &j, 0);
    SeqList_Insert(list, &k, 0);
    SeqList_Insert(list, &x, 0);
    SeqList_Insert(list, &y, 0);
    SeqList_Insert(list, &z, 0);
    
    SeqList_Delete(list, 5);
    
    printf("%x\n", SeqList_Get(list, 5));
    
    SeqList_Destroy(list);
    
    return 0;
}

第二:

循环链表CircleList2.0

有3处修正

#ifndef _CIRCLELIST_H_
#define _CIRCLELIST_H_

typedef void CircleList;
typedef struct _tag_CircleListNode CircleListNode;
struct _tag_CircleListNode
{
    CircleListNode* next;
};

CircleList* CircleList_Create();

void CircleList_Destroy(CircleList* list);

void CircleList_Clear(CircleList* list);

int CircleList_Length(CircleList* list);

int CircleList_Insert(CircleList* list, CircleListNode* node, int pos);

CircleListNode* CircleList_Get(CircleList* list, int pos);

CircleListNode* CircleList_Delete(CircleList* list, int pos);

CircleListNode* CircleList_DeleteNode(CircleList* list, CircleListNode* node);

CircleListNode* CircleList_Reset(CircleList* list);

CircleListNode* CircleList_Current(CircleList* list);

CircleListNode* CircleList_Next(CircleList* list);

#endif

#include <stdio.h>
#include <malloc.h>
#include "CircleList.h"

typedef struct _tag_CircleList
{
    CircleListNode header;
    CircleListNode* slider;
    int length;
} TCircleList;

CircleList* CircleList_Create() // O(1)
{
    TCircleList* ret = (TCircleList*)malloc(sizeof(TCircleList));
    
    if( ret != NULL )
    {
        ret->length = 0;
        ret->header.next = NULL;
        ret->slider = NULL;
    }
    
    return ret;
}

void CircleList_Destroy(CircleList* list) // O(1)
{
    free(list);
}

void CircleList_Clear(CircleList* list) // O(1)
{
    TCircleList* sList = (TCircleList*)list;
    
    if( sList != NULL )
    {
        sList->length = 0;
        sList->header.next = NULL;
        sList->slider = NULL;
    }
}

int CircleList_Length(CircleList* list) // O(1)
{
    TCircleList* sList = (TCircleList*)list;
    int ret = -1;
    
    if( sList != NULL )
    {
        ret = sList->length;
    }
    
    return ret;
}

int CircleList_Insert(CircleList* list, CircleListNode* node, int pos) // O(n)
{ 
    TCircleList* sList = (TCircleList*)list;
    int ret = (sList != NULL) && (pos >= 0) && (node != NULL);
    int i = 0;
    
    if( ret )
    {
        CircleListNode* current = (CircleListNode*)sList;
        
        for(i=0; (i<pos) && (current->next != NULL); i++)
        {
            current = current->next;
        }
        
        node->next = current->next;
        current->next = node;
        
        if( sList->length == 0 )
        {
            sList->slider = node;       
        }
        
        sList->length++;
        
        //修正1:判断插入是否为表头,为表头则修正
        if( current == (CircleListNode*)sList )
        {
            CircleListNode* last = CircleList_Get(sList, sList->length - 1);
            
            last->next = current->next;
        }
    }
    
    return ret;
}

CircleListNode* CircleList_Get(CircleList* list, int pos) // O(n)
{
    TCircleList* sList = (TCircleList*)list;
    CircleListNode* ret = NULL;
    int i = 0;
    
    if( (sList != NULL) && (pos >= 0) && (sList->length > 0) )
    {
        CircleListNode* current = (CircleListNode*)sList;
        
        for(i=0; i<pos; i++)
        {
            current = current->next;
        }
        
        ret = current->next;
    }
    
    return ret;
}

CircleListNode* CircleList_Delete(CircleList* list, int pos) // O(n)
{
    TCircleList* sList = (TCircleList*)list;
    CircleListNode* ret = NULL;
    int i = 0;
    
    if( (sList != NULL) && (pos >= 0) && (sList->length > 0) )//修正3:循环链表为空,只有表头,则不需要删除
    {
        CircleListNode* current = (CircleListNode*)sList;
        CircleListNode* last = NULL;
        
        for(i=0; i<pos; i++)
        {
            current = current->next;
        }
       
        //修正2:只有在删除第一个元素时才会遍历让last指向最后一个元素
        if( current == (CircleListNode*)sList )
        {
            last = (CircleListNode*)CircleList_Get(sList, sList->length - 1);
        }
        
        ret = current->next;
        current->next = ret->next;
        
        sList->length--;
        
        if( last != NULL )
        {
            sList->header.next = ret->next;
            last->next = ret->next;
        }
        
        if( sList->slider == ret )
        {
            sList->slider = ret->next;
        }
        
        if( sList->length == 0 )
        {
            sList->header.next = NULL;
            sList->slider = NULL;
        }
    }
    
    return ret;
}

CircleListNode* CircleList_DeleteNode(CircleList* list, CircleListNode* node) // O(n)
{
    TCircleList* sList = (TCircleList*)list;
    CircleListNode* ret = NULL;
    int i = 0;
    
    if( sList != NULL )
    {
        CircleListNode* current = (CircleListNode*)sList;
        
        for(i=0; i<sList->length; i++)
        {
            if( current->next == node )
            {
                ret = current->next;
                break;
            }
            
            current = current->next;
        }
        
        if( ret != NULL )
        {
            CircleList_Delete(sList, i);
        }
    }
    
    return ret;
}

CircleListNode* CircleList_Reset(CircleList* list) // O(1)
{
    TCircleList* sList = (TCircleList*)list;
    CircleListNode* ret = NULL;
    
    if( sList != NULL )
    {
        sList->slider = sList->header.next;
        ret = sList->slider;
    }
    
    return ret;
}

CircleListNode* CircleList_Current(CircleList* list) // O(1)
{
    TCircleList* sList = (TCircleList*)list;
    CircleListNode* ret = NULL;
    
    if( sList != NULL )
    {
        ret = sList->slider;
    }
    
    return ret;
}

CircleListNode* CircleList_Next(CircleList* list) // O(1)
{
    TCircleList* sList = (TCircleList*)list;
    CircleListNode* ret = NULL;
    
    if( (sList != NULL) && (sList->slider != NULL) )
    {
        ret = sList->slider;
        sList->slider = ret->next;
    }
    
    return ret;
}


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

/* run this program using the console pauser or add your own getch, system("pause") or input loop */

struct Value
{
    CircleListNode header;
    int v;
};

int main(int argc, char *argv[])
{
    CircleList* list = CircleList_Create();
    
    struct Value v1;
    struct Value v2;
    struct Value v3;
    struct Value v4;
    struct Value v5;
    struct Value v6;
    struct Value v7;
    struct Value v8;
    
    int i = 0;
    
    v1.v = 1;
    v2.v = 2;
    v3.v = 3;
    v4.v = 4;
    v5.v = 5;
    v6.v = 6;
    v7.v = 7;
    v8.v = 8;
    
    //头插法
    CircleList_Insert(list, (CircleListNode*)&v1, 0);
    CircleList_Insert(list, (CircleListNode*)&v2, 0);
    CircleList_Insert(list, (CircleListNode*)&v3, 0);
    CircleList_Insert(list, (CircleListNode*)&v4, 0);
    
    for(i=0; i<2*CircleList_Length(list); i++)
    {
        struct Value* pv = (struct Value*)CircleList_Get(list, i);
        
        printf("%d\n", pv->v);
    }
    
    while( CircleList_Length(list) > 0 )
    {
        CircleList_Delete(list, 0);
    }
    
    printf("\n");
    
    CircleList_Destroy(list);
    
	return 0;
}

第三:

双向链表DLinkList2.0

有1处修正

#ifndef _DLINKLIST_H_
#define _DLINKLIST_H_

typedef void DLinkList;
typedef struct _tag_DLinkListNode DLinkListNode;
struct _tag_DLinkListNode
{
    DLinkListNode* next;
    DLinkListNode* pre;
};

DLinkList* DLinkList_Create();

void DLinkList_Destroy(DLinkList* list);

void DLinkList_Clear(DLinkList* list);

int DLinkList_Length(DLinkList* list);

int DLinkList_Insert(DLinkList* list, DLinkListNode* node, int pos);

DLinkListNode* DLinkList_Get(DLinkList* list, int pos);

DLinkListNode* DLinkList_Delete(DLinkList* list, int pos);

DLinkListNode* DLinkList_DeleteNode(DLinkList* list, DLinkListNode* node);

DLinkListNode* DLinkList_Reset(DLinkList* list);

DLinkListNode* DLinkList_Current(DLinkList* list);

DLinkListNode* DLinkList_Next(DLinkList* list);

DLinkListNode* DLinkList_Pre(DLinkList* list);

#endif

#include <stdio.h>
#include <malloc.h>
#include "DLinkList.h"

typedef struct _tag_DLinkList
{
    DLinkListNode header;
    DLinkListNode* slider;
    int length;
} TDLinkList;

DLinkList* DLinkList_Create() // O(1)
{
    TDLinkList* ret = (TDLinkList*)malloc(sizeof(TDLinkList));
    
    if( ret != NULL )
    {
        ret->length = 0;
        ret->header.next = NULL;
        ret->header.pre = NULL;
        ret->slider = NULL;
    }
    
    return ret;
}

void DLinkList_Destroy(DLinkList* list) // O(1)
{
    free(list);
}

void DLinkList_Clear(DLinkList* list) // O(1)
{
    TDLinkList* sList = (TDLinkList*)list;
    
    if( sList != NULL )
    {
        sList->length = 0;
        sList->header.next = NULL;
        sList->header.pre = NULL;
        sList->slider = NULL;
    }
}

int DLinkList_Length(DLinkList* list) // O(1)
{
    TDLinkList* sList = (TDLinkList*)list;
    int ret = -1;
    
    if( sList != NULL )
    {
        ret = sList->length;
    }
    
    return ret;
}

int DLinkList_Insert(DLinkList* list, DLinkListNode* node, int pos) // O(n)
{ 
    TDLinkList* sList = (TDLinkList*)list;
    int ret = (sList != NULL) && (pos >= 0) && (node != NULL);
    int i = 0;
    
    if( ret )
    {
        DLinkListNode* current = (DLinkListNode*)sList;
        DLinkListNode* next = NULL;
        
        for(i=0; (i<pos) && (current->next != NULL); i++)
        {
            current = current->next;
        }
        
        next = current->next;
        
        current->next = node;
        node->next = next;
        
        if( next != NULL )
        {
            next->pre = node;
        }
        
        node->pre = current;
        
        if( sList->length == 0 )
        {
            sList->slider = node;
        }
        
        //修正1:插入为第一个元素,current则指向表头,那么pre指向空
        if( current == (DLinkListNode*)sList )
        {
            node->pre = NULL;
        }
        
        sList->length++;
    }
    
    return ret;
}

DLinkListNode* DLinkList_Get(DLinkList* list, int pos) // O(n)
{
    TDLinkList* sList = (TDLinkList*)list;
    DLinkListNode* ret = NULL;
    int i = 0;
    
    if( (sList != NULL) && (0 <= pos) && (pos < sList->length) )
    {
        DLinkListNode* current = (DLinkListNode*)sList;
        
        for(i=0; i<pos; i++)
        {
            current = current->next;
        }
        
        ret = current->next;
    }
    
    return ret;
}

DLinkListNode* DLinkList_Delete(DLinkList* list, int pos) // O(n)
{
    TDLinkList* sList = (TDLinkList*)list;
    DLinkListNode* ret = NULL;
    int i = 0;
    
    if( (sList != NULL) && (0 <= pos) && (pos < sList->length) )
    {
        DLinkListNode* current = (DLinkListNode*)sList;
        DLinkListNode* next = NULL;
        
        for(i=0; i<pos; i++)
        {
            current = current->next;
        }
        
        ret = current->next;
        next = ret->next;
        
        current->next = next;
        
        if( next != NULL )
        {
            next->pre = current;
            
            if( current == (DLinkListNode*)sList )
            {
                next->pre = NULL;
            }
        }
        
        if( sList->slider == ret )
        {
            sList->slider = next;
        }
        
        sList->length--;
    }
    
    return ret;
}

DLinkListNode* DLinkList_DeleteNode(DLinkList* list, DLinkListNode* node)
{
    TDLinkList* sList = (TDLinkList*)list;
    DLinkListNode* ret = NULL;
    int i = 0;
    
    if( sList != NULL )
    {
        DLinkListNode* current = (DLinkListNode*)sList;
        
        for(i=0; i<sList->length; i++)
        {
            if( current->next == node )
            {
                ret = current->next;
                break;
            }
            
            current = current->next;
        }
        
        if( ret != NULL )
        {
            DLinkList_Delete(sList, i);
        }
    }
    
    return ret;
}

DLinkListNode* DLinkList_Reset(DLinkList* list)
{
    TDLinkList* sList = (TDLinkList*)list;
    DLinkListNode* ret = NULL;
    
    if( sList != NULL )
    {
        sList->slider = sList->header.next;
        ret = sList->slider;
    }
    
    return ret;
}

DLinkListNode* DLinkList_Current(DLinkList* list)
{
    TDLinkList* sList = (TDLinkList*)list;
    DLinkListNode* ret = NULL;
    
    if( sList != NULL )
    {
        ret = sList->slider;
    }
    
    return ret;
}

DLinkListNode* DLinkList_Next(DLinkList* list)
{
    TDLinkList* sList = (TDLinkList*)list;
    DLinkListNode* ret = NULL;
    
    if( (sList != NULL) && (sList->slider != NULL) )
    {
        ret = sList->slider;
        sList->slider = ret->next;
    }
    
    return ret;
}

DLinkListNode* DLinkList_Pre(DLinkList* list)
{
    TDLinkList* sList = (TDLinkList*)list;
    DLinkListNode* ret = NULL;
    
    if( (sList != NULL) && (sList->slider != NULL) )
    {
        ret = sList->slider;
        sList->slider = ret->pre;
    }
    
    return ret;
}



#include <stdio.h>
#include <stdlib.h>
#include "DLinkList.h"
/* run this program using the console pauser or add your own getch, system("pause") or input loop */

struct Value
{
    DLinkListNode header;
    int v;
};

int main(int argc, char *argv[])
{

    DLinkList* list = DLinkList_Create();
    
    struct Value v1;
    struct Value v2;
    struct Value v3;
    struct Value v4;
    struct Value v5;
    
    v1.v = 1;
    v2.v = 2;
    v3.v = 3;
    v4.v = 4;
    v5.v = 5;
    
    DLinkList_Insert(list, (DLinkListNode*)&v1, 0);
    DLinkList_Insert(list, (DLinkListNode*)&v2, 0);
    DLinkList_Insert(list, (DLinkListNode*)&v3, 0);
    DLinkList_Insert(list, (DLinkListNode*)&v4, 0);
    DLinkList_Insert(list, (DLinkListNode*)&v5, 0);
    
    DLinkList_Reset(list);
    
    //DLinkList_Pre(list);
    
    printf("%x\n", DLinkList_Current(list));
    
    DLinkList_Destroy(list);
    
	return 0;
}

 

嵌入式开发学习者
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
链表——笔记理解
Peyriat的博客
11-14 1093
众所周知，在一个数组中插入或是删除一个元素，都会需要移动后面所有的元素，导致代码的运行效率极低 但是！链表就可以很好的解决这一问题 就这么想吧，链表是一辆火车，链表的表头就是火车头，链表的每一个元素就是火车的一节节车厢，车厢里装的东西就是元素的数据域，每个车厢之间的卡子就是元素的指针 不会吧？不会有人没有见过火车吧？不会吧不会吧？ 总之，链表就是元素之间前后依赖，串联而成的 啊，对。链表的元素是不能随机访问的，就像你要从一个车厢到远处的另一个车厢，当然不是跨越一道任意门走过去，你没有这东西，所以，
10min快速回顾C++语法（七）类、结构体、指针链表专题
热门推荐
timerring的博客
08-26 4万+
⭐写在前面的话：本系列文章旨在短时间内回顾C/C++语法中的重点与易错点，巩固算法竞赛与写题过程中常用的语法知识，精准地解决学过但有遗忘的情况，为算法刷题打下坚实的基础。10.1类与结构体 10.1.1 类的定义 10.1.2 类的使用 10.1.3 结构体的构造函数 10.2 指针和引用 10.3 链表 10.3.1 链表详解 10.3.2 遍历链表 10.3.3 链表的添加 10.3.4 链表的删除............
数据结构回顾——静态链表操作详解及C语言实现
只要思想不滑坡，想法总比问题多。
08-26 2396
使用静态数组表示的链表称为静态链表。静态链表综合了顺序表和链表的优点，既有高效的查找操作，又能快速增删元素节点。
链表介绍
jerome_777的博客
12-14 1295
链表 链表结构 底层的存储结构： 从图中我们看到，数组需要一块连续的内存空间来存储，对内存的要求比较高。如果我们申请一个 100MB 大小的数组，当内存中没有连续的、足够大的存储空间时，即便内存的剩余总可用空间大于 100MB，仍然会申请失败。 而链表恰恰相反，它并不需要一块连续的内存空间，它通过“指针”将一组零散的内存块串联起来使用，所以如果我们申请的是 100MB 大小的链表，根本不会有问题。 单链表 链表通过指针将一组零散的内存块串联在一起。其中，我们把内存块称为链表的“结点”。为了将所有的结点串起
LeetCode链表（链表操作，反转链表，奇偶链表，排序链表）
ji_meng的博客
03-06 961
本篇文章更注重于链表自身的特点。链表是一种通过指针串联在一起的线性结构。链表中的每个元素实际上是一个单独的对象，而所有对象都通过每个元素中的引用字段链接在一起。链表的入口节点称为链表的头结点也就是head。（1）单链表每一个节点由两部分组成，一个是数据域一个是指针域（存放指向下一个节点的指针），最后一个节点的指针域指向null（空指针的意思）。（2）双链表每一个节点有两个指针域。
链表知识总结及代码实现
m0_63330233的博客
10-24 2753
目录 头指针、头结点和首元结点的概念 链表的概念 链表的特性 有关链表的三个讨论 了解顺序表前首先应该了解结点等知识，下面来依次了解相关知识： 头指针、头结点和首元结点的概念 头指针: 是指向链表中第一个结点的指针 首元结点: 是指链表中存储第一个数据元素的结点 头结点: 是在链表的首元结点之前附设的一个结点; 链表的概念 定义：链表，别名链式存储结构或单链表，用于存储逻辑关系为 "一对一" 的数据。与顺序表不同，链表不限制数据的物理存储状态，换句话说，使用链表存储的数据元素...
第一课 链表
weixin_30635053的博客
10-04 610
预备知识：链表基础： 基础（c语言版） 1 #include <stdio.h> 2 struct ListNode { 3 int val; 4 struct ListNode* next; 5 }; 6 7 int main() { 8 struct ListNode node1; 9 ...
2022-07-22 回顾链表操作以及部分问题
程序员沙子的专栏
07-22 153
回顾链表操作，以及（反转，查找公共节点，闭环等）
数据结构： 数组与链表
最新发布
timberman666的博客
10-02 1793
数据结构： 数组与链表
【数据结构】链表
East-sunrise的博客
09-15 714
链表？简简单单 一看就会 一学就起飞
蓝桥杯第九届国赛练习回顾
05-13
【蓝桥杯第九届国赛练习回顾】 蓝桥杯大赛是一项在中国广受欢迎的计算机编程竞赛，旨在提升大学生和中学生的编程技能，特别是针对软件和信息技术专业。第九届蓝桥杯国赛是该赛事的重要组成部分，吸引了众多参赛者...
java代码-实训6 第十题
07-16
10. **算法和数据结构**：实训项目也可能涉及排序、查找等基本算法，如冒泡排序、快速排序、二分查找等，以及如何使用合适的数据结构（如数组、链表）来优化算法性能。 以上就是根据提供的信息推测的一些Java实训6...
Java-day-10:1.回顾2.停车系统
04-30
在Java编程的学习过程中，第十天的主题是“停车系统”，这个主题涵盖了Java在构建实际应用场景中的应用，特别是管理系统方面的知识。让我们深入探讨一下这个主题所涉及的相关知识点。 首先，停车系统通常是一个复杂...
NIIT第三模块试题
12-26
2. **数据结构与算法**：第三模块可能深入讲解了数组、链表、栈、队列、树、图等数据结构，以及排序和搜索算法（如冒泡排序、快速排序、二分查找等）。 3. **数据库管理**：可能涉及SQL语言的基本操作，如创建表、...
蓝桥杯第八届省赛练习代码
05-15
在描述中提到，逻辑不做详细介绍，可能是因为原作者认为这部分内容在他的另一篇文章——第十一届省赛练习回顾中有详细阐述，读者可以参考那篇文章来理解代码的思维过程。 在"蓝桥杯"的竞赛中，编程语言的选择通常是...
第2节 判断程序的质量
一名从事物联网开发者的博客
08-19 379
-------------------------------------资源来源于网络,仅供自学使用,如有侵权,联系我必删. 第一: 算法效率的度量 ? 事前分析估算 依据统计的方法对算法效率进行估算 ? 影响算法效率的主要因素 算法采用的策略和方法 问题的输入规模 编译器所产生的代码 计算机执行速度 第二: 算法效率的简单...
第12节 栈的应用实战一
一名从事物联网开发者的博客
02-13 354
-------------------------------------资源来源于网络,仅供自学使用,如有侵权,联系我必删. 第一: ?  在C 语言中有一些符号是成对匹配出现的 括号:     ()      []      {}    &lt;&gt; 引号:    ''    ""   解决方案 ?  算法思路 ?  从第一个字符开始扫描 ?  当遇见普通字符时忽略 ， 当遇...
第13节 栈的应用实战二
一名从事物联网开发者的博客
02-13 322
-------------------------------------资源来源于网络,仅供自学使用,如有侵权,联系我必删. 第一:     中缀表达式符合人类的阅读和思维习惯     后缀表达式符合计算机的 “ 运算习惯”     中缀表达式                 后缀表达式      5 + 3                    =&gt;     5 3 +     ...
第30节 霍夫曼树
一名从事物联网开发者的博客
02-17 217
-------------------------------------资源来源于网络,仅供自学使用,如有侵权,联系我必删. 第一: 霍夫曼树   第二: 霍夫曼树的应用   第三: 构建霍夫曼树 #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; #include &lt;malloc.h&gt; #include ...
第36节 查找的概念
一名从事物联网开发者的博客
02-20 207
-------------------------------------资源来源于网络,仅供自学使用,如有侵权,联系我必删. 第一: 查找的概念 ?  查找的定义 ?  查找表是由同一类型的数据元素构成的集合 ?  查找是根据给定的某个值 ， 在查找表中确定一个其关键字等于给定值的数据元素   ?   查找的操作 ?  静态查找    •  查询 某个 特定的 数据元素是否在查找表中 ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值