数据结构和算法

最新推荐文章于 2023-08-19 15:54:00 发布
最新推荐文章于 2023-08-19 15:54:00 发布
阅读量199 收藏
点赞数
分类专栏： C语言 文章标签： 单链表 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CSDN_Xian/article/details/112321577
版权

文章目录

所用语言——C语言

数据结构

数据结构就是数据存放的思想

数组

特点：元素是连续的

缺点：增、删元素很复杂

链表

链表的概念

链表是很多结构体通过存放下一结构体指针地址的数据结构。

特点：链表各节点的地址是不连续的

初始化链表

#include <stdio.h>
#include <stdlib.h>
// 1.定义链表节点结构体
struct Node{
    int data;//数据域
    struct Node *next;//指针域
};
int main()
{
    // 2.初始化各节点
    struct Node node1 = {1,NULL};
    struct Node node2 = {2,NULL};
    struct Node node3 = {3,NULL};
    // 3.连接各节点
    node1.next = &node2;
    node2.next = &node3;
    // 4.通过首节点打印整个链表内容
    printf("%d\t%d\t%d",node1.data,node1.next->data,node1.next->next->data);
    return 0;
}

链表的遍历

通过链表头遍历整个链表；不同于遍历数组通过for循环中下标的递增来遍历，遍历链表通过while循环中指针指向的变更来遍历

#include <stdio.h>
#include <stdlib.h>
struct Node{
    int data;
    struct Node *next;
};
// 传入链表头遍历链表
void printLink(struct Node *head){
    struct Node *point;
    point = head;
    while(point != NULL){
        printf("%d ",point->data);
        // 打印完数据域指针移到下一个节点
        point = point->next;
    }
    putchar('\n');
}
int main()
{
    struct Node node1 = {1,NULL};
    struct Node node2 = {2,NULL};
    struct Node node3 = {3,NULL};
    struct Node node4 = {4,NULL};

    node1.next = &node2;
    node2.next = &node3;
    node3.next = &node4;
    
    printLink(&node1);
    return 0;
}

统计链表节点个数及链表查找

查询链表中是否有data这个数据，有的话返回1没有返回0

#include <stdio.h>
#include <stdlib.h>
struct Node{
    int data;
    struct Node *next;
};
void printLink(struct Node *head){
    struct Node *point;
    point = head;
    while(point != NULL){
        printf("%d ",point->data);
        point = point->next;
    }
    putchar('\n');
}
// 统计链表节点个数
int getLinkTotalNodeNum(struct Node *head){
    int cnt = 0;
    while(head != NULL){
        cnt++;
        head = head->next;
    }
    return cnt;
}
// 查找数据
int searchLink(struct Node *head,int data){
    while(head != NULL){
        if(head->data == data){
            return 1;
        }
        head = head->next;
    }
    return 0;
}
int main()
{
    struct Node node1 = {1,NULL};
    struct Node node2 = {2,NULL};
    struct Node node3 = {3,NULL};
    struct Node node4 = {4,NULL};

    node1.next = &node2;
    node2.next = &node3;
    node3.next = &node4;
    
    printLink(&node1);
    
    int ret = getLinkTotalNodeNum(&node1);
    printf("total num = %d\n",ret);
    
    ret = searchLink(&node1,1);
    if(ret == 0){
        printf("no 1");
    }else{
        printf("have 1");
    }
    return 0;
}

从指定节点后插入新节点

先将新节点指向原节点的下一个节点，再让原节点指向新节点。注意：函数参数尽量传指针，直接传结构体啊哈C会出错

如果有链表节点的数据重复还能插入新节点吗？

#include <stdio.h>
#include <stdlib.h>
struct Node{
    int data;
    struct Node *next;
};
// 遍历链表
void printLink(struct Node *head){
    struct Node *point;
    point = head;
    while(point != NULL){
        printf("%d ",point->data);
        point = point->next;
    }
    putchar('\n');
}
// 在指定节点后插入新节点
int insertFromBehind(struct Node *head, int data, struct Node *new){
    struct Node *p = head;
    while(p != NULL){
        if(p->data == data){
            new->next = p->next;
            p->next = new;
            return 1;
        }
        p = p->next;
    }
    return 0;
}
int main()
{
    struct Node node1 = {1,NULL};
    struct Node node2 = {2,NULL};
    struct Node node3 = {3,NULL};
    struct Node node4 = {4,NULL};
    struct Node new = {100,NULL};

    node1.next = &node2;
    node2.next = &node3;
    node3.next = &node4;
    
    insertFromBehind(&node1,3,&new);
    printLink(&node1);//1 2 3 100 4
    
    return 0;
}

从指定节点前插入新节点

为什么要有返回值为结构体指针？不能是void吗？

因为链表头也有可能被改变

#include <stdio.h>
#include <stdlib.h>
struct Node{
    int data;
    struct Node *next;
};
// 遍历链表
void printLink(struct Node *head){
    struct Node *point;
    point = head;
    while(point != NULL){
        printf("%d ",point->data);
        point = point->next;
    }
    putchar('\n');
}
// 从节点前插入新节点
struct Node* insertFromfor(struct Node *head, int data, struct Node *new){
    struct Node *p = head;
    if(p->data == data){
        new->next = head;
        return new;
    }
    while(p->next != NULL){
        if(p->next->data == data){
            new->next = p->next;
            p->next = new;
            return head;
            //一定要在这里return head，因为不return下一句p指向的永远是新节点，新节点的next节点中data永远等于data，会一直进到if中，即在data前一直插入新节点
        }
        p = p->next;
    }
    return head;
}
int main()
{
    struct Node node1 = {1,NULL};
    struct Node node2 = {2,NULL};
    struct Node node3 = {3,NULL};
    struct Node node4 = {4,NULL};
    struct Node new = {100,NULL};

    node1.next = &node2;
    node2.next = &node3;
    node3.next = &node4;
    
    struct Node *head = NULL;
    head = &node1;
    head = insertFromfor(head, 2, &new);
    printLink(head);//1 100 2 3 4
    return 0;
}

链表删除指定节点

#include <stdio.h>
#include <stdlib.h>
struct Node{
    int data;
    struct Node *next;
};
void printLink(struct Node *head){
    struct Node *point;
    point = head;
    while(point != NULL){
        printf("%d ",point->data);
        point = point->next;
    }
    putchar('\n');
}
// 删除指定节点
struct Node* deleteNode(struct Node *head, int data){
    struct Node *p = head;
    if(p->data == data){
        head = head->next;
        // free(p);动态创建链表用malloc函数时可以用free
        return head;
    }
    while(p->next != NULL){
        if(p->next->data == data){
            p->next = p->next->next;
            return head;
            //这里return掉是因为防止最后一个节点是NULL后，没有p->next无法进行while判断导致程序崩溃
        }
        //这里的遍历只为找if的条件
        p = p->next;
    }
    return head;
}
int main()
{
    struct Node node1 = {1,NULL};
    struct Node node2 = {2,NULL};
    struct Node node3 = {3,NULL};
    struct Node node4 = {4,NULL};

    node1.next = &node2;
    node2.next = &node3;
    node3.next = &node4;
    struct Node *head = &node1;
    printLink(head);
    head = deleteNode(head, 2);
    printLink(head);
    return 0;
}

链表动态创建之头插法

不断在链表的头部插入新节点

#include <stdio.h>
#include <stdlib.h>
struct Node{
    int data;
    struct Node *next;
};
void printLink(struct Node *head){
    struct Node *point;
    point = head;
    while(point != NULL){
        printf("%d ",point->data);
        point = point->next;
    }
    putchar('\n');
}
// 头插法
struct Node* insertFromHead(struct Node *head){
    struct Node *newNode;
    while(1){
        newNode = (struct Node *)malloc(sizeof(struct Node));
        // 不要出现野指针，要给next初始化为NULL
        newNode->next = NULL;
        printf("请输入新节点的数据：");
        scanf("%d",&(newNode->data));
        if(newNode->data == 0){
            printf("0 quit\n");
            return head;
        }
        if(head == NULL){
            head = newNode;
        }else{
            newNode->next = head;
            head = newNode;
        }
    }
    return head;
}
int main()
{
    struct Node *head = NULL;
    head = insertFromHead(head);
    printLink(head);
    return 0;
}

头插法优化

尾插法创建链表

从链表的尾部不断插入新节点

#include <stdio.h>
#include <stdlib.h>
struct Node{
    int data;
    struct Node *next;
};
// 打印链表
void printLink(struct Node *head){
    struct Node *node = head;
    while(node != NULL){
        printf("%d\t",node->data);
        node = node->next;
    }
    putchar('\n');
}
// 尾插法不断插入新节点
struct Node* insertFromTail(struct Node *head){
    struct Node *node = head;
    struct Node *newNode = NULL;
    while(1){
        newNode = (struct Node *)malloc(sizeof(struct Node));
        newNode->data = 0;
        newNode->next = NULL;
        printf("请输入要插入的节点数据：");
        scanf("%d",&newNode->data);
        if(newNode->data == 0){
            return head;
        }
        if(head == NULL){
            head = newNode;
            node = head;
        }else{
            // 在任意链表后插入新节点都可以
            // 将node定位到链表的最后一位
            while(node != NULL){
                if(node->next == NULL){
                    break;
                }
                node = node->next;
            }
            node->next = newNode;
            node = newNode;
        }
    }
    return head;
}
int main()
{
    // 用尾插法不断插入新节点
    struct Node *head = NULL;
    head = insertFromTail(head);
    // 打印链表
    printLink(head);
    return 0;
}

链表综合

#include <stdio.h>
#include <stdlib.h>
#define GET_RESULT 1
typedef struct Node{
    int data;
    struct Node *next;
}Node;
// 遍历链表
void printLink(Node *head){
    Node *node = head;
    // printf("链表：");
    if(head == NULL){
        printf("NULL");
    }
    while(node != NULL){
        printf("%d\t",node->data);
        node = node->next;
    }
    putchar('\n');
}
// 统计链表节点个数
int getNodeNum(Node *head){
    int count = 0;
    Node *node = head;
    while(node != NULL){
        count++;
        node = node->next;
    }
    return count;
}
// 链表查找
int searchLink(Node *head, int data){
    Node *node = head;
    while(node != NULL){
        if(node->data == data){
            return 1;
        }
        node = node->next;
    }
    return 0;
}
// 从指定节点后插入新节点
Node* insertFromBehind(Node *head, int data, Node *newNode){
    Node *node = head;
    if(head == NULL){
        head = newNode;
        return head;
    }
    while(node != NULL){
        if(node->data == data){
            newNode->next = node->next;
            node->next = newNode;
            return head;
        }
        node = node->next;
    }
    return head;
}
// 从指定节点前插入新节点
Node* insertFromForward(Node *head, int data, Node *newNode){
    Node *node = head;
    if(head == NULL){
        head = newNode;
        return head;
    }
    if(head->data == data){
        newNode->next = head;
        head = newNode;
        return head;
    }
    while(node->next != NULL){
        if(node->next->data == data){
            newNode->next = node->next;
            node->next = newNode;
            return head;
        }
        node = node->next;
    }
    return head;
}
// 不断删除指定节点
Node* deleteNode(Node *head){
    int data = 0;
    Node *node = head;
    while(1){
        printf("请输入要删除的节点：");
        scanf("%d",&data);
        if(data == 0){
            return head;
        }
        if(head->data == data){
            head = head->next;
            node = head;
            continue;
        }
        while(node->next != NULL){
            if(node->next->data == data){
                node->next = node->next->next;
                break;
            }
            node = node->next;
        }
        node = head;
    }
}
// 头插法
Node* insertFromHead(Node *head){
    Node *newNode;
    while(1){
        newNode = (Node *)malloc(sizeof(Node));
        newNode->data = 0;
        newNode->next = NULL;
        printf("请输入头插法要插入的新节点数据：");
        scanf("%d",&newNode->data);
        if(newNode->data == 0){
            return head;
        }
        if(head == NULL){
            head = newNode;
        }else{
            newNode->next = head;
            head = newNode;
        }
    }
}
// 尾插法
Node* insertFromTail(Node *head){
    Node *newNode;
    Node *node = head;
    while(1){
        newNode = (Node *)malloc(sizeof(Node));
        newNode->data = 0;
        newNode->next = NULL;
        printf("请输入尾插法要插入的新节点数据：");
        scanf("%d",&newNode->data);
        if(newNode->data == 0){
            return head;
        }
        if(head == NULL){
            head = newNode;
            node = head;
        }else{
            while(node != NULL){
                if(node->next == NULL){
                    break;
                }
                node = node->next;
            }
            node->next = newNode;
            node = newNode;
        }
    }
}
int main()
{
    // 初始化链表
    Node node1 = {1,NULL};
    Node *head = &node1;
    Node node2 = {2,NULL};
    Node node3 = {3,NULL};
    head->next = &node2;
    node2.next = &node3;
    // 遍历链表
    printLink(head);
    // 统计链表节点个数
    int nodeNum = getNodeNum(head);
    printf("节点有%d个\n",nodeNum);
    // 链表查找
    int data = 0;
    printf("请输入要查找的节点：");
    scanf("%d",&data);
    int result = searchLink(head,data);
    if(result == GET_RESULT){
        printf("存在该节点\n");
    }else{
        printf("该节点不存在\n");
    }
    // 从指定节点后插入新节点
    printf("请输入要从哪个节点后插入新节点：");
    scanf("%d",&data);
    Node newNode1 = {101,NULL};
    head = insertFromBehind(head,data,&newNode1);
    printLink(head);
    // 从指定节点前插入新节点
    printf("请输入要从哪个节点前插入新节点：");
    scanf("%d",&data);
    Node newNode2 = {100,NULL};
    head = insertFromForward(head,data,&newNode2);
    printLink(head);
    // 不断删除指定节点
    head = deleteNode(head);
    printLink(head);
    // 头插法
    head = insertFromHead(head);
    printLink(head);
    // 尾插法
    head = insertFromTail(head);
    printLink(head);
    return 0;
}

基础算法

冒泡排序

给定一个数组nums，有numsSize个元素，将其元素从小到大排序

//将数组中前一个元素和后一个元素比较，如果后面的元素更大，就交换元素位置，以此类推

//比如nums = {5,4,3,2,1};
//第1轮比较了4次，最大值5被排到了最后
//第2轮比较了3次，此轮的最大值4被排到了倒数第2位
//以此类推，用i代表第几轮比较，j代表第几次比较
//共比较了numsSize - 1轮，每一轮比较了numsSize - i次
void bubbleSort(int* nums, int numsSize){
    int temp, i, j;
    for (i = 1; i <= numsSize - 1; i++) {
        for(j = 1; j <= numsSize - i; j++){
            if(nums[j - 1] > nums[j]){
                temp = nums[j];
                nums[j] = nums[j - 1];
                nums[j - 1] = temp;
            }
        }
    }
}
CSDN_Xian
关注
专栏目录
Unity 面试篇|（六）数据结构和算法篇 【全面总结 | 持续更新】
游戏开发小Y的博客
01-20 5万+
先拿10000个数建堆，然后一次添加剩余元素，如果大于堆顶的数（10000中最小的），将这个数替换堆顶，并调整结构使之仍然是一个最小堆，这样遍历完后，堆中的10000个数就是所需的最大的10000个。桶排序是计数排序的升级版。它的工作原理：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。这样处理就可以分别在每个文件的10^6个数据中找出最大的10000个数，合并到一起在再找出1000*10000中的最终的结果。
kubernetes环境搭建（手动篇）
villare的博客
02-16 3488
主要内容 1.环境准备(2主机) 2.安装流程 3.问题分析 4.总结 1.环境准备（2主机） 系统：CentOS 7.3 x64 网络：局域网（VPC） 主机： master：172.16.0.17 minion-1：172.16.0.7 1.1.修改host配置 修改master和minion-1的host文件，使得各主机可通过主机名访问，方便更新和迁移； echo "1...
使用 kubeadm 安装单master kubernetes 集群（脚本版）
Mo小泽的技术博客
09-22 2524
文章目录使用 kubeadm 安装单master kubernetes 集群配置要求检查 centos / hostname检查网络安装docker及kubelet初始化 master 节点初始化 worker节点获得 join命令参数初始化worker常见错误原因worker 节点不能访问 apiserverworker 节点默认网卡移除worker节点并重试检查初始化结果安装 Ingress Controller 使用 kubeadm 安装单master kubernetes 集群 配置要求 对于 Ku
Linux安装kubernetes
cxu123321的博客
09-21 3006
每台机器器 2 GB 或更多的 RAM (如果少于这个数字将会影响您应用的运行内存)2 CPU 核心或更多 ​ 集群中的所有机器的网络彼此均能相互连接(公网和内网都可以)注意:在这里的版本号⼀一定要先通过上述命令查看后在填写，本例中的是v1.14.0后续可能版本会有 变化，因为国内的源随时可能更新k8s的版本。我们事先可以通过如下命令查看所依赖的docker镜像版本 kubeadm config images list ，来查看pod的运⾏行行状态，当所有为run的状态时，证明启动完毕。
【kubernetes】kubeadm方式部署Kubernets1.28 (最新详细硬核简单出炉)
lhq1363511234的博客
08-19 1448
本文借鉴参考多篇博客和官网编写，全文基本可以复制粘贴快速部署k8s集群。
linux怎么搭建k8s集群,Ubuntu 16.04下安装搭建Kubernetes集群环境
weixin_29997523的博客
05-14 200
简介目前Kubernetes为Ubuntu提供的kube-up脚本，不支持15.10以及16.04这两个使用systemd作为init系统的版本。这里详细介绍一下如何以非Docker方式在Ubuntu16.04集群上手动安装部署Kubernetes的过程。手动的部署过程，可以很容易写成自动部署的脚本。同时了解整个部署过程，对深入理解Kubernetes的架构及各功能模块也会很有帮助。环境信息版本信...
数据结构和算法PDF文档
06-02
1000多页的算法题解，包含数据结构，排序，查找，递归，回溯算法，二叉树，动态规划，贪心算法，双指针，滑动窗口，前缀和等。
数据结构和算法5.0.pdf
05-27
数据结构和算法5.0.pdf
c++数据结构和算法合集.zip
最新发布
12-28
c++数据结构和算法合集 c++数据结构和算法合集 c++数据结构和算法合集 c++数据结构和算法合集 c++数据结构和算法合集 c++数据结构和算法合集 c++数据结构和算法合集 c++数据结构和算法合集 c++数据结构和算法合集 ...
数据结构和算法TS：以TypeScript（完整）实现的数据结构和算法
02-05
TypeScript中的数据结构和算法 主题概述 算法复杂度分析 大O符号 时间复杂度 空间复杂度 数据结构 数组 哈希表 堆栈 s列 链表 树木 图表 演算法 递归 动态编程 比较排序 合并排序 快速排序 正在搜寻...
python 根据文件路径生成zTree插件需要的数据格式
吃瓜的猫~
07-19 332
python生成前端目录树zTree插件需要的数据格式 一、首先准备数据 ll= ['/app/', '/nficd/test_app/htmlname.py', '/nficd/test_app/migrations/', '/nficd/test_app/migrations/models.py', '/nficd/test_app/migrations/sec_audit.log', '/nf
ztree使用方法 python后台
weixin_30895603的博客
08-17 176
一、在提前加载js的地方写一段js，判断该页面是否需要添加ztree，我的项目所有提前加载的js都写在admin.js中 //增加ztree $(document).ready(function() { var t = $('#tree-style').text(); if(t.length>0){ $('#col').addClass(...
记录kubernetv1.19安装过程
mojolang
12-03 385
记录kubernetv1.19安装过程 1:运行kubeadm init时加上阿里云镜像的参数–image-repository=registry.aliyuncs.com/google_containers，如下：（版本改为自己需要的） kubeadm init --image-repository=registry.aliyuncs.com/google_containers --apiserver-advertise-address=10.24.149.226 --pod-network-cidr=
python ztree 异步加载
zhangweigangweiwu的专栏
10-25 1162
使用 python 服务端实现 ztree插件的异步加载 。开发时耗费了不少时间，所以记录下来~
python树结构_一行python实现树形结构的方法
weixin_39622747的博客
11-29 319
定义使用内置的defaultdict 我们可以很容易的定义一个树形数据结构def tree(): return defaultdict(tree)example:json风格users = tree()users['harold']['username'] = 'bell'users['handler']['username'] = 'master'我们可以使用print(json.dumps(u...
python生成网页树形节点_python爬虫中html如何转换树形结构？
weixin_40009063的博客
12-19 1006
经过一段时间的python学习，我们知道提取数据的来源不止是网页，就像抓取数据可以选择很多种库一样。在python中，BeautifulSoup和HTMLParser虽然看起来不相似，但在使用上是比较相像的。今天就html转换树形结构，小伙伴们可以尝试着用此类方法去解决，其中涉及到的新知识点我们都会额外为大家进行讲解。BeautifulSoup就是一个专门用来从html和xml文档中提取数据的库，...
树形节点ZTree
weixin_42271651的博客
02-25 249
这种树形节点是自定义的，还有一种树形节点是绑定数据库的，在我的另外一篇文章里有写到。 @{ Layout = null; } &lt;!DOCTYPE html&gt; &lt;html&gt; &lt;head&gt; &lt;meta charset="utf-8"&gt; &lt;title&gt;树形节点&lt;/title&gt; &
linux中rabbitMQ消息中间件调用./rabbitmqctl stop_app不管用，无法停止
weixin_45875049的博客
01-27 1693
通过查询进程，杀死进程 使用 kill -9 进程号进行关闭 查询进程号： ps aux|grep rabbitmq 杀死进程 kill -9 90300
linux（centos7）部署kubernetes（k8s 1.16.2）集群环境及测试
liaomingwu的专栏
04-13 3410
linux部署k8s 集群环境及测试
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值