最新数据结构（C语言版本）_c语言数据结构，C C++开发核心知识笔记共2100页

最新推荐文章于 2024-07-29 13:48:22 发布

2401_84978623

最新推荐文章于 2024-07-29 13:48:22 发布

阅读量317

点赞数 3

文章标签： c语言 c++ 学习

本文链接：https://blog.csdn.net/2401_84978623/article/details/138981010

版权

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

3.算法是对特定问题求解步骤的一种描述，算法具有如下特性：有穷性、确定性、可行性、输入、输出。

4.算法的度量：

时间复杂度
空间复杂度

第二章线性表

1.线性表的定义：

存在唯一一个“第一个”元素
存在唯一一个“最后一个”元素
除第一个元素外，每一个元素都有且只有一个前驱
除最后一个元素外，每个元素都有且只有一个后继

2.线性表合并的方法：

将表A中的元素逐个和B中的比较，不同就加入到B中。时间复杂度为O(len(A)*len(B))
AB是有序排列的前提下，使用两个指针分别指向A和B，将两者较小的元素插入到C中，然后移动较小的指针，直到全部插入到C。时间复杂度为O(len(A)+len(B))

3.线性表的顺序实现：满足LOC(A(i+l))=LOC(A(i))+l，LOC表示元素地址。特点：下标读取快O(1)，插入删除O(n)。

#include <stdlib.h>
#ifndef SEQUENCE\_LINER\_LIST\_H
#define SEQUENCE\_LINER\_LIST\_H

/\*
 线性表的顺序实现
\*/
#define LIST\_INIT\_SIZE 100 //初始分配量
#define LIST\_INCREMENT 10 //增量
#define LIST\_TYPE int //存储类型

typedef struct strSequenceLinerList
{
    LIST_TYPE *elem;        //存储空间基址
    unsigned int length;    //当前长度
    unsigned int listSize;  //当前存储容量
}SequnceLinerList;

static enum Status
{
    OK,
    FAILED,
    OVERFLOW
};

/\* 线性表初始化 \*/
Status initSequenceLinerList(SequnceLinerList& list)
{
    list.elem = (LIST_TYPE *)malloc(sizeof(LIST_TYPE)*LIST_INIT_SIZE);
    if (!list.elem)
    {
        return OVERFLOW;
    }
    list.length = 0;
    list.listSize = LIST_INIT_SIZE;
    return OK;
}

/\* 扩展 \*/
Status resizeSequenceLinerList(SequnceLinerList& list)
{
    printf("Resize...\n");
    list.elem = (LIST_TYPE*)realloc(list.elem, sizeof(LIST_TYPE)*(list.listSize + LIST_INCREMENT));
    if (!list.elem)
    {
        return OVERFLOW;
    }
    list.listSize += LIST_INCREMENT;
    return OK;
}

/\* 打印 \*/
void printSequnceLinerList(SequnceLinerList& list)
{
    printf("Begin print list...\n");
    printf("length=%d,listSize=%d.\n",list.length,list.listSize);
    unsigned int i = 0;
    for (; i < list.length-1;++i)
    {
        printf("%d,",list.elem[i]);
    }
    printf("%d\n", list.elem[i]);
    printf("End print list.\n");
}

/\* 线性表插入:position表示插入的位置，从1开始。第一个元素是list.elem[0] \*/
Status insertSequenceLinerList(SequnceLinerList& list, unsigned int position, LIST_TYPE value)
{
    if (position<1 || position>list.length+1)
    {
        return FAILED;
    }
    if (list.length >= list.listSize)
    {
        Status res = resizeSequenceLinerList(list);
        if (OK != res)
        {
            return FAILED;
        }
    }

    LIST_TYPE* p = &list.elem[position -1];
    LIST_TYPE* q = &list.elem[list.length];
    for (; p != q; --q)
    {
        *(p + 1) = *p;
    }
    list.length++;
    *p = value;
    return OK;
}

/\* 删除元素 \*/
Status deleteSequenceLinerList(SequnceLinerList& list, unsigned int position)
{
    if (position<1 || position>list.length)
    {
        return FAILED;
    }

    LIST_TYPE* p = &list.elem[position - 1];
    LIST_TYPE* q = &list.elem[list.length - 1];
    for (; p != q; ++p)
    {
        *p = *(p+1);
    }
    --list.length;
    return OK;
}

/\* 查找：第一个值的下标 \*/
unsigned int findSequenceLinerList(SequnceLinerList& list, int value)
{
    for (unsigned int i = 0; i < list.length;++i)
    {
        if (value == list.elem[i])
        {
            return i;
        }
    }
    return -1;
}

/\* 排序(冒泡) \*/
void sortSequeceLinerList(SequnceLinerList& list)
{
    unsigned int i = 0;
    unsigned int j = 0;
    for (; i < list.length-1;++i)
    {
        for (j = i + 1; j < list.length; ++j)
        {
            if (list.elem[i]>list.elem[j])
            {
                LIST_TYPE tmp = list.elem[i];
                list.elem[i] = list.elem[j];
                list.elem[j] = tmp;
            }
        }
    }
}

/\* 销毁 \*/
void destroySequenceLincerList(SequnceLinerList& list)
{
    delete list.elem;
    list.elem = NULL;
}

#endif

4.线性表的链式实现：通过p=p.next查找具体位置的链表。特点：插入、删除快O(n)。

#include <stdio.h>
#include <stdio.h>
#ifndef LINK_LINER_LIST_H
#define LINK_lINER_LIST_H
#define LINK_LIST_TYPE int

/\*
 线性表的链表实现
\*/
typedef struct strLinkLinerList
{
    LINK_LIST_TYPE data;
    struct strLinkLinerList\* pNext;
}LinkLinerList;

LinkLinerList\* head = NULL;

/\* 链表初始化 \*/
Status initLinkLinerList()
{
    if (NULL == head)
    {
        head = (LinkLinerList\*)malloc(sizeof(LinkLinerList));
        if (!head)
        {
            return OVERFLOW;
        }
        head->pNext = NULL;
        return OK;
    }
    else
    {
        return FAILED;
    }
}

/\* 添加元素 \*/
Status insertLinkLinerList(LINK_LIST_TYPE value)
{
    if (NULL == head)
    {
        return FAILED;
    }
    LinkLinerList\* p = head;
    while (p->pNext)
    {
        p = p->pNext;
    }
    LinkLinerList\* tmp = (LinkLinerList\*)malloc(sizeof(LinkLinerList));
    if (!tmp)
    {
        return OVERFLOW;
    }
    tmp->data = value;
    tmp->pNext = NULL;
    p->pNext = tmp;
    return OK;
}

/\*打印\*/
void printLinkLinerList()
{
    printf("Begin print...\n");
    if (NULL == head || NULL == head->pNext)
    {
        printf("List is null.");
    }
    LinkLinerList\* p = head->pNext;
    while (p->pNext)
    {
        printf("%d,",p->data);
        p = p->pNext;
    }
    printf("%d\n", p->data);
    printf("End print.\n");
}

/\* 排序 \*/
Status sortLinkLinerList()
{
    if (NULL == head || NULL == head->pNext)
    {
        return FAILED;
    }
    LinkLinerList\* p = head->pNext;
    LinkLinerList\* q = p->pNext;
    while (p)
    {
        q = p->pNext;
        while (q)
        {
            if (p->data > q->data)
            {
                LINK_LIST_TYPE tmp = p->data;
                p->data = q->data;
                q->data = tmp;
            }
            q = q->pNext;
        }
        p = p->pNext;
    }
    return OK;
}

/\* 长度 \*/
unsigned int lengthLinkLinerList()
{
    if (head == NULL || head->pNext == NULL)
    {
        return 0;
    }
    LinkLinerList\* p = head->pNext;
    unsigned int length = 0;
    while (p)
    {
        p = p->pNext;
        length++;
    }
    return length;
}

/\* 删除 \*/
Status deleteLinkLinerList(unsigned int position)
{
    if (position > lengthLinkLinerList() || position < 1)
    {
        return FAILED;
    }
    else
    {
        LinkLinerList\* p = head;
        LinkLinerList\* q = p->pNext;
        if (NULL == p || NULL == q)
        {
            return FAILED;
        }
        while (--position)
        {
            p = p->pNext;
            q = p->pNext;
        }
        p->pNext = q->pNext;
        free(q);
        return OK;
    }
}

/\* 销毁 \*/
void destroyLinkLinerList()
{
    if (NULL == head)
    {
        return;
    }
    else
    {
        LinkLinerList\* p = head->pNext;
        LinkLinerList\* q = p;
        while (p)
        {
            p = p->pNext;


![img](https://img-blog.csdnimg.cn/img_convert/efdfaa781a311a427becd6775b7b3898.png)
![img](https://img-blog.csdnimg.cn/img_convert/fe12f7499ab8dabcd366301ecb4bb6f0.png)

**既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上C C++开发知识点，真正体系化！**

**由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新**

**[如果你需要这些资料，可以戳这里获取](https://bbs.csdn.net/topics/618668825)**

\* q = p;
        while (p)
        {
            p = p->pNext;


[外链图片转存中...(img-6KQshTxM-1715878908864)]
[外链图片转存中...(img-0rYR1IzF-1715878908864)]

**既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上C C++开发知识点，真正体系化！**

**由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新**

**[如果你需要这些资料，可以戳这里获取](https://bbs.csdn.net/topics/618668825)**