数据结构学习入门

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

1、基本概念
数据：如int a;
数据对象：性质相同的数据元素的集合，如int array[10];
数据元素：组成数据的基本单元（一个一个的结点），如array[0] array[1];
数据项：如

struct Teacher
{
    int age;//即是数据项
    char name[64];//即是数据项
}

数据结构（常见有数组、链表、树、图）：研究结点和结点之间的关系,如：散列、1:1、1：N、N:N
存储结构可分为：顺序、链式、索引（跟目录的功能类似）、散列（应用于百度网盘上传时，当进行上传操作时，首先检测是否有相同的文件存在，若有，直接生成链接指向即可。如今的算法有md5、sha1）
数据的操作（5种）：插删改查排
O()表示法用来表示算法的复杂度，往往只关注操作数量的最高次数。
复杂度分为时间复杂度和空间复杂度。
空间换时间：如求出一个数组中出现次数最多的数字：
—-》方法：遍历数组，开辟一个空间数组，用来存放每一个数字出现的次数，如1的次数存放到num[0]中，i的次数存放到num[i-1]中（每出现一次i，num[i-1]++），然后求出num[]的最大值，就可知道出现次数最多的那个数。
2、线性表

//*****线性表顺序储存*****///
//在结构体中套1级指针
//
typedef struct _tag_SeqList
{
    int length;
    int capacity;
    unsigned int *node;   //int* node[]
}TSeqList;
//链表的创建
SeqList* SeqList_Create(int capacity)
{
    int ret = 0;
    TSeqList *tmp = NULL;

    tmp = (TSeqList *)malloc(sizeof(TSeqList));//先创建头结点
    if (tmp == NULL)
    {
        ret = -1;
        printf("func SeqList_Create() err:%d \n", ret);
        return NULL;
    }
    memset(tmp, 0, sizeof(TSeqList));

    //根据capacity 的大小分配节点的空间
    tmp->node = (unsigned int *)malloc(sizeof(unsigned int *) * capacity);
    if (tmp->node  == NULL)
    {
        ret = -2;
        printf("func SeqList_Create() err: malloc err %d \n", ret);
        return NULL;
    }
    tmp->capacity = capacity;
    tmp->length = 0;
    return tmp;
}
//开辟内存时进行了两次，所以释放时也应该进行两次
void SeqList_Destroy(SeqList* list)
{
    TSeqList *tlist = NULL;
    if (list == NULL)
    {
        return ;
    }
    tlist = (TSeqList *)list;
    if (tlist->node != NULL)
    {
        free(tlist->node);
    }

    free(tlist);

    return ;
}

//清空链表 //回到初始化状态
void SeqList_Clear(SeqList* list)
{
    TSeqList *tlist = NULL;
    if (list == NULL)
    {
        return ;
    }
    tlist = (TSeqList *)list;
    tlist->length = 0; 
    return ;
}

int SeqList_Length(SeqList* list)
{
    TSeqList *tlist = NULL;
    if (list == NULL)
    {
        return -1;
    }
    tlist = (TSeqList *)list;
    return tlist->length;
}

int SeqList_Capacity(SeqList* list)
{

    TSeqList *tlist = NULL;
    if (list == NULL)
    {
        return -1;
    }
    tlist = (TSeqList *)list;
    return tlist->capacity;
}
//先进行元素后移，再插入元素
int SeqList_Insert(SeqList* list, SeqListNode* node, int pos)
{
    int i =0, ret = 0;
    TSeqList *tlist = NULL;

    if (list == NULL || node==NULL ||  pos<0)
    {
        ret = -1;
        printf("fun SeqList_Insert() err:%d \n", ret);
        return ret;
    }
    tlist = (TSeqList*)list;

    //判断是不是满了
    if (tlist->length >= tlist->capacity)
    {
        ret = -2;
        printf("fun SeqList_Insert() (tlist->length >= tlist->capacity) err:%d \n", ret);
        return ret;
    }

    //容错修正  6个长度 容量20;用户pos10位置插入（可通过容错修正为紧接着最后一个元素插入）..
    if (pos>=tlist->length)
    {
        pos = tlist->length; //
    }

    //1 元素后移
    for(i=tlist->length; i>pos; i--)
    {
        tlist->node[i] = tlist->node[i-1];
        //a[7] = a[6]
    }
    // i = 3
    // 2插入元素
    tlist->node[i] = (unsigned int )node;
    tlist->length ++;
    return 0;
}

SeqListNode* SeqList_Get(SeqList* list, int pos)
{
    int i =0;
    SeqListNode *ret = 0;
    TSeqList *tlist = NULL;

    if (list == NULL || pos<0)
    {
        printf("fun SeqList_Get() err:%d \n", ret);
        return NULL;
    }
    tlist = (TSeqList*)list;

    ret = (void *)tlist->node[pos];
    return ret;
}

SeqListNode* SeqList_Delete(SeqList* list, int pos)
{
    int i = 0;
    SeqListNode *ret = 0;
    TSeqList *tlist = NULL;

    if (list == NULL ||  pos<0) //检查
    {
        printf("fun SeqList_Delete() err:%d \n", ret);
        return NULL;
    }
    tlist = (TSeqList*)list;

    ret = (SeqListNode *)tlist->node[pos]; //缓存pos的位置

    for (i=pos+1; i<tlist->length; i++)  //pos位置后面的元素前移
    {
        tlist->node[i-1] = tlist->node[i];
    }
    tlist->length --;
    return ret;
}

这里写图片描述
链表技术领域的推演
这里写图片描述
链表的插入
这里写图片描述
链表的删除
注：指向头结点的指针循环遍历时：
—-》遍历第一次，指向位置0；
—-》遍历第二次，指向位置1；
—-》遍历第n次，指向位置n-1；
—》所以，如果想要知道位置n的元素，需要最后加上ret=current->next

/****线性表的链式储存*****/
让一个结构体单元包含一个线性表结点，线性表结点位于结构体单元的首地址，也即是实现了二级指针。
指针指向谁，就把谁的地址赋给指针；
分清楚链表的操作逻辑和辅助指针变量之间的关系。
typedef struct _tag_LinkListNode
{
    struct _tag_LinkListNode * next;
}LinkListNode;

typedef struct _tag_LinkList
{
    LinkListNode header;
    int length;
}TLinkList;

LinkList* LinkList_Create()
{
    TLinkList *ret = NULL;
    ret = (TLinkList *)malloc(sizeof(TLinkList ));
    memset(ret, 0, sizeof(TLinkList));
    ret->length  = 0;
    ret->header.next = NULL;
}

void LinkList_Destroy(LinkList * list)
{
    if(list != NULL)
    {
        free(list);
        list = NULL;
    }
}

//让链表恢复到初始化状态
void LinkList_Clear(LinkList* list)
{
    TLinkList *tList = NULL;
    if(list == NULL)
    {
        return;
    }
    tList = (TLinkList *)list;
    tList->length = 0;
    tList->header.next = NULL;
    return;
}

int LinkList_Length(LinkList* list)
{
    TLinkList *tList = NULL;
    if(list == NULL)
    {
        return;
    }
    tList = (TLinkList *)list;
    return tList->length;
}

int LinkList_Insert(LinkList* list, LinkListNode* node, int pos)
{
    int ret = 0;
    LinkListNode *current = NULL;
    TLinkList &tList = NULL;
    if(list == NULL || node == NULL || pos < 0)
    {
        ret = 0;
        printf("func LinkList_Insert() err:%d\n", ret);
        return ret;
    }
    tList = (TLinkList *)list;
    current = &(tList->header);//让辅助指针变量指向链表的头部
    for(i=0; i<pos && current->next != NULL; i++)
    {
        current = current->next;
    }
    //让node连接后续链表
    node->next = current->next;
    //让前面的链表连接新的node节点
    current->next = node;
    tList->length ++;
    return 0；
}

LinkListNode* LinkList_Get(LinkList* list, int pos)
{
    int ret = 0，i = 0;
    LinkListNode *current = NULL;
    TLinkList &tList = NULL;
    if(list == NULL || node == NULL || pos < 0)
    {
        ret = 0;
        printf("func LinkList_Insert() err:%d\n", ret);
        return ret;
    }
    tList = (TLinkList *)list;
    current = &(tList->header);
    for(i=0; i<pos && current->next != NULL; i++)//跳pos次
    {
        current = current->next;
    }
    return current->next；
}

LinkListNode* LinkList_Delete(LinkList* list, int pos)
{
    int i=0;
    LinkListNode *current = NULL;
    LinkListNode *ret = NULL;
    TLinkList &tList = NULL;
    if(list == NULL ||  pos < 0)
    {
        ret = 0;
        printf("func LinkList_Delete() err:%d\n", ret);
        return ret;
    }
    tList = (TLinkList *)list;
    current = &(tList->header);//让辅助指针变量指向链表的头部
    for(i=0; i<pos && current->next != NULL; i++)
    {
        current = current->next;
    }
    ret = current->next;//缓存被删除结点
    //连线
    current->next = ret->next;
    tList->length --;
    return 0；   
}


循环链表的插入算法

/***循环链表**/
typedef struct _tag_CircleListNode
{
    struct _tag_CircleListNode * next;
}CircleListNode;

#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)
    {
        return NULL;
    }

    ret->length = 0;
    ret->header.next = NULL;
    ret->slider = NULL;
    return ret;
}

void CircleList_Destroy(CircleList* list) // O(1)
{
    if (list == NULL)
    {
        return ;
    }
    free(list);
}

void CircleList_Clear(CircleList* list) // O(1)
{
    TCircleList* sList = (TCircleList*)list;
    if (sList == NULL)
    {
        return ;
    }
    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 (list == NULL)
    {
        return ret;
    }
    ret = sList->length;
    return ret;
}

int CircleList_Insert(CircleList* list, CircleListNode* node, int pos) // O(n)
{ 
    int ret = 0, i=0;
    TCircleList* sList = (TCircleList*)list;

    if (list == NULL || node== NULL || pos<0)
    {
        return -1;
    }
    //if( ret )
    {
        CircleListNode* current = (CircleListNode*)sList;

        for(i=0; (i<pos) && (current->next != NULL); i++)
        {
            current = current->next;
        }

        //current->next 0号节点的地址
        node->next = current->next; //1
        current->next = node; //2

        //若第一次插入节点
        if( sList->length == 0 )
        {
            sList->slider = node;
        }

        sList->length++;

        //若头插法 current仍然指向头部
        //（原因是：跳0步，没有跳走）
        if( current == (CircleListNode*)sList )
        {
            //获取最后一个元素
            CircleListNode* last = CircleList_Get(sList, sList->length - 1); 
            last->next = current->next; //3
        }
    }

    return ret;
}

CircleListNode* CircleList_Get(CircleList* list, int pos) // O(n)
{
    TCircleList* sList = (TCircleList*)list;
    CircleListNode* ret = NULL;
    int i = 0;

    if (list==NULL || pos<0)
    {
        return NULL;
    }
    //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) )
    {
        CircleListNode* current = (CircleListNode*)sList;
        CircleListNode* last = NULL;

        for(i=0; i<pos; i++)
        {
            current = current->next;
        }

        //若删除第一个元素（头结点）
        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;
        }

        //若删除元素后，链表长度为0
        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;

        //查找node在循环链表中的位置i
        for(i=0; i<sList->length; i++)
        {
            if( current->next == node )
            {
                ret = current->next;
                break;
            }

            current = current->next;
        }

        //如果ret找到，根据i去删除    
        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;
}

双向链表的不同之处
1、插入

指针分为两个next、pre
这里写图片描述

//第一个值的注意的:当链表插入第一个元素
if(next != NULL)
    next->pre = node;
node->pre = current;
//第二个值的注意的:当在0号位置插入
if(current == 新建节点)
    node->pre = NULL;

2、删除
这里写图片描述

if(next != NULL)
{
    next->pre = current;
    if(current == 新节点)//若第0号位置 需特殊处理
    {
        next->pre = NULL;
    }

}
沐清浅
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构与算法——从零开始学习（一）基础概念篇
csdn_aiyang的博客
12-06 25万+
前言 数据结构：是指相互之间存在一种或多种特定关系的数据元素的集合用计算机存储、组织数据的方式。数据结构分别为逻辑结构、（存储）物理结构和数据的运算三个部分。 为什么要学数据结构？ 首先，因为数据结构作为计算机专业的专业基础课程，是计算机考研的必考科目之一，如果打算报考计算机专业的研究生，你必须学好它；其次，数据结构是计算机软考、计算机等级考试等相关考试的必考内容之一，想要顺利通过这些考...
数据结构学习数据结构学习
02-12
数据结构是计算机科学中的核心概念，它涉及到如何在内存中有效地组织和...总之，“数据结构学习”是一项基础且重要的任务，它将为你的编程生涯打下坚实的基础，使你能够解决更复杂的问题，编写出更加高效和优雅的代码。
数据结构入门到精通学习（一）
chenjiali_csu的博客
10-26 2485
在很多人初学者眼里，数据结构学了并没有什么很大的用处，学习数据结构所获得的成就感远不如学一门像C++，Java这样的编程语言，最开始我学习数据结构的时候也是这么想的，那些老师课堂上讲的各种数据结构算法，总会把我绕得云里雾里，学完之后还根本不知道怎么用，于是学得一塌糊涂。但是在后来参加比赛接触了一些更加复杂的系统之后，才深深意识到数据结构的重要性。总而言之，用当初教我们的老师的一句话来说就是：“数据
数据结构基础入门
小小默：进无止境
01-16 1938
简单地说，数据结构是以某种特定的布局方式存储数据的容器。这种“布局方式”决定了数据结构对于某些操作是高效的，而对于其他操作则是低效的。首先我们需要理解各种数据结构，才能在处理实际问题时选取最合适的数据结构。 首先列出一些最常见的数据结构，我们将逐一说明： 数组 栈 队列 链表 树 图 字典树（这是一种高效的树形结构，但值得单独说明） 散列表（哈希表） 【1】数组 数组是最简单、也是使用最广泛的...
数据结构学习（一）：入门
Emrys的博客
10-08 1万+
1. 算法 + 数据结构 = 程序 问题（problem）：从输入到输出的一种映射函数 数据结构（Data Structure）：逻辑数据结构在计算机中的存储表达，支持相应的操作 算法（algorithhm）：对特定问题求解过程的描述方法 程序（program）：算法在计算机程序设计语言中的实现   2.层次 逻辑结构： （1）.线性表、栈和队列、字符串 （2）.二叉树、
数据结构（一）：入门
shaozhenghan的博客
08-15 2980
今天开始补数据结构。其实以前也学过，都忘了，今天开始一点点补回来。 1. 什么是数据结构 数据结构由数据和结构组成，它是一门研究非数值计算的程序设计问题中计算机的操作对象以及它们之间的关系和操作等的学科，数据结构是数据存储的方式。 2. 什么是算法 算法是处理数据的方法，通常我们通过分析算法的时间复杂度和空间复杂度来判断它的好坏。数据结构的不同就会导致算法的不同，数据结构的选择对算法效率会...
嵌入式数据结构基础学习
08-26
数据结构基础：了解和熟悉常见的数据结构，如数组、链表、堆栈和队列等，以便理解和使用嵌入式数据结构。 结构体（Struct）和联合体（Union）：学习结构体和联合体的定义和使用，它们是嵌入式数据结构的基本构建块...
动力数据结构学习0526
05-26
"动力数据结构学习0526"这个标题暗示了这是一个关于数据结构的学习资源，可能包括教程、课件或者练习题，用于提升对数据结构的理解和应用能力。描述中的"0526"可能是日期，表明这是在2026年5月26日更新或创建的资源...
数据结构学习.zip
06-17
总之，“数据结构学习.zip”这个压缩包为学习者提供了全面的数据结构学习资源，无论是对于初学者还是有一定基础的学习者，都能从中受益匪浅。通过深入学习和实践，不仅可以提升编程技能，还能为将来从事软件开发、...
数据结构学习指南资源整理
01-04
# 数据结构学习指南：如何利用网络资源掌握数据结构的知识和技能 数据结构是计算机科学的基础课程，它研究数据的逻辑结构和物理结构，以及数据之间的关系和操作。数据结构的选择和设计直接影响到算法的效率和程序的...
数据结构——小白入门篇
i-kernel
02-04 2万+
数据结构——小白入门篇浅谈学习心得- 我为什么想要学数据结构？****在计算机界有这样一个万能公式：数据结构 + 算法 = 程序。****在如今这计算机引领风骚的时代，不学数据结构，你凭什么想要做时代的弄潮儿；所以我毅然决然的提前自学了数据结构。 ***学习数据结构前的我是这样认为的？！什么是数据结构？数据结构要用什么语言实现？学了数据结构后能做什么？ 学习数据结构后的我有什么感触?数据结构是指相
数据结构基础知识学习（一）
追梦的小蚂蚁
04-10 675
程序设计 = 数据结构+算法 基本概念： 数据：描述客观事物的符号，是计算机中可以操作的对象，能被计算机识别，并输入给计算机处理的符号的集合。 数据元素：是组成数据的，有一定意义的基本单位，在计算机中通常作为整体处理，也被称为记录。 数据项：一个数据元素可以有若干个数据项组成。数据项是数据不可分割的最小的单位。 数据结构： 概念：相互之间存在一种或者多种特定关系的数据元素的集合。 ...
数据结构入门学习中。。。
Joker1998的博客
08-05 231
堆栈学习栈特性： LIFO 简单实现可用结构中仅含top与size 基本操作： 判断是否为空 bool isEmpty(stack *stk) { return stk->top==0; } 入栈 void push(stack *stk,int x) { if(stk->top==MAXSIZE) return; stk->val[++stk->top]=x
数据结构教程(c语言)(已完结)
热门推荐
EasyChillの博客
03-27 2万+
一、基本概念和术语 数据：是客观事物的符号表示，能够输入到计算机中并能被计算机程序处理的符号的总称 数据元素：是数据的基本单位，用于完整地描述一个对象 数据对象：是性质相同的数据元素的集合，是数据的一个子集 数据项：是组成数据元素的，有独立含义的，不可分割的最小单位 数据结构：是相互之间存在的一种或者多种的特定关系的数据元素的集合，换句话说，数据结构是带结构的数据元素的集合，“结构”，就是指数...
【数据结构与算法】从0-1小白学习之路（入门篇）
小诚信驿站
06-04 2551
入门篇： 1、算法知识入门篇： 数学基础： 对数：幂的逆运算，如果a^x =N（a>0，且a≠1），那么数x叫做以a为底N的对数，记作x=logaN，读作以a为底N的对数，其中a叫做对数的底数，N叫做真数。（N>0） 幂：2^n，n叫做2的幂次方，如果为2和3分别叫2次方，和立方。 时间复杂度： 若存在函数f(n)，使得当n趋近于无穷大时候，T(n)/f(n)的极限值为不等于零的...
注塑模设计毕业设计说明书.doc
07-17
说明书
成品库存管理系统-Excel模板
07-17
【作品名称】：成品库存管理系统-Excel模板 【适用人群】：适用于希望学习不同技术领域的小白或进阶学习者。可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。
H公司项目管理法则.docx
最新发布
07-17
H公司项目管理法则.docx
遗传算法及其MATLAB实现
07-17
遗传算法（Genetic Algorithm, GA）最先是由美国Mic- hgan大学的John Holland于1975年提出的。遗传算法是 模拟达尔文的遗传选择和自然淘汰的生物进化过程的计算 模型。它的思想源于生物遗传学和适者生存的自然规律， 是具有“生存+检测”的迭代过程的搜索算法。遗传算法 以一种群体中的所有个体为对象，并利用随机化技术指 导对一个被编码的参数空间进行高效搜索。其中，选择、 交叉和变异构成了遗传算法的遗传操作；参数编码、初始 群体的设定、适应度函数的设计、遗传操作设计、控制参 数设定等5个要素组成了遗传算法的核心内容。 下面是遗传算法的基本步骤以及基本程序流程简介附带有实现程序，可供参考与加深学习。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值