数据结构（C语言 Clion)

最新推荐文章于 2024-06-13 10:13:20 发布
最新推荐文章于 2024-06-13 10:13:20 发布
阅读量105 收藏
点赞数
文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/JYing___/article/details/128637866
版权

线性表

链表

单向链表

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

typedef int E;

struct ListNode{
    E element;
    struct ListNode * next;
};

typedef struct ListNode * Node;

void initList(Node node){
    node->next = NULL;
}

bool insertList(Node head, E element, int index) {
    if(index < 1) return 0;
    while (--index){
        head = head->next;
        if(head == NULL) return 0;
    }

    Node node = static_cast<Node>(malloc(sizeof(struct ListNode)));
    if(node == NULL) return 0;
    node->element = element;
    node->next = head->next;
    head->next = node;

    return 1;
}

bool deleteList(Node head, int index){
    if(index < 1) return 0;
    while(--index) {
        head = head->next;
        if(head == NULL) return 0;
    }
    if(head->next == NULL) return 0;

    Node tmp = head->next;
    head->next = head->next->next;
    free(tmp);
    return 1;
}

E * getList(Node head, int index){
    if(index < 1) return 0;
    do{
        head = head->next;
        if(head == NULL) return 0;
    } while (--index);
    return &head->element;
}
//查找对应元素位置
int findList(Node head, E element){
    head = head->next;
    int i = 1;
    while(head){
        if(head->element == element) return i;
        head = head->next;
        i++;
    }
    return -1;
}
//求链表的长度
int sizeList(Node head){
    int i = -1;
    while(head){
        head = head->next;
        i++;
    }
    return i;
}
void printList(Node head){
    while (head->next){
        head = head->next;
        printf("%d ",head->element);
    }
    printf("\n");
}

int main(){
    struct ListNode head;
    initList(&head);
    printf("%d\n",sizeList(&head));
    for(int i = 1; i <= 3; i++){
        insertList(&head,i*100,i);
    }
    deleteList(&head,4);
    printList(&head);
    printf("%d\n",*getList(&head,1));
    printf("%d\n",findList(&head,100));
    printf("%d\n",sizeList(&head));
}

双向链表

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

typedef int E;

struct ListNode {
    E element;
    struct ListNode * next;//指向下一节点的指针
    struct ListNode * prev;//指向上一节点的指针
};

typedef struct ListNode * Node;

//初始化
void initList(Node head){
    head->next = head->prev = NULL;
}

//插入
_Bool insertList(Node head, E element, int index){
    if(index < 1) return 0;
    while (--index){
        head = head->next;
        if(head == NULL) return 0;
    }
    Node node = malloc(sizeof(struct ListNode));
    if(node == NULL) return 0;
    node->element = element;
    if(head->next != NULL) {
        node->next = head->next;
        head->next->prev = node;
    }else{
        node->next = NULL;
    }
    head->next = node;
    node->prev = head;
    return 1;
}

//删除
_Bool deleteList(Node head, int index){
    if(index < 1) return 0;
    while (--index){
        head = head->next;
        if(head == NULL) return 0;
    }
    if(head->next == NULL) return 0;
    Node tmp = head->next;
    if(head->next->next){
        head->next = head->next->next;
        head->next->next->prev = head;
    } else {
        head->next = NULL;
    }
    free(tmp);
    return 1;
}

int main(){
    struct ListNode head;
    initList(&head);
    for (int i = 1; i <= 5; ++i)
        insertList(&head,i * 100,i);

    deleteList(&head,3);

    Node node = &head;  //正向遍历
    do {
        node = node->next;
        printf("%d -> ",node->element);
    }while (node->next != NULL);
    printf("\n");
    /*
    do {//反向遍历
        printf("%d -> ", node->element);
        node = node->prev;
    }while(node->prev != NULL);
     */
}

栈

用数组实现栈

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

typedef int E ;

struct Stack{
    E * array;
    int capacity;//容量
    int top;//栈顶元素下标
};

typedef struct Stack * ArrayStack;

//初始化
_Bool initStack(ArrayStack stack){
    stack->array = malloc(sizeof(E) * 10);
    if(stack->array == NULL) return 0;
    stack->capacity = 10;
    stack->top = -1;
    return 1;
}

//遍历
void printStack(ArrayStack stack){
    printf("| ");
    for (int i = 0; i < stack->top + 1; ++i){
        printf("%d, ",stack->array[i]);
    }
    printf("\n");
}

//入栈
_Bool pushStack(ArrayStack stack, E element){
    if(stack->top + 1 == stack->capacity){//判断塞满没 塞满扩容
        int newCapacity = stack->capacity + (stack->capacity >> 1);
        E * newArray = realloc(stack->array, newCapacity * sizeof(E));
        if(newArray == NULL) return 0;
        stack->array = newArray;
        stack->capacity = newCapacity;
    }
    stack->array[++stack->top] = element;
    return 1;
}

//判断栈是否为空
_Bool isEmpty(ArrayStack stack){
    return stack->top == -1;
}

//出栈
E popStack(ArrayStack stack){
    return stack->array[stack->top--];
}

int main(){
    struct Stack stack;
    initStack(&stack);
    for (int i = 0; i < 10; ++i){
        pushStack(&stack, i * 100);
    }
    printStack(&stack);
    while(!isEmpty(&stack)) {
        printf("%d ", popStack(&stack));
    }
}

在这里插入图片描述

用链表实现栈

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

typedef int E;

struct LNode{
    E element;
    struct LNode * next;
};

typedef struct LNode * Node;

//初始化
void initStack(Node head){
    head->next = NULL;
}

//入栈
_Bool pushStack(Node head, E element) {
    Node node = malloc(sizeof(struct LNode));
    if(node == NULL) return 0;
    node->element = element;
    node->next = head->next;
    head->next = node;
    return 1;
}

//遍历打印
void printStack(Node head){
    //printf("| ");
    head = head->next;
    while(head){
        printf("%d ",head->element);
        head = head->next;
    }
    printf("|");
}
//判断是否为空
_Bool isEmpty(Node head){
    return head->next == NULL;
}

//出栈
E popStack(Node head){
    Node tmp = head->next;
    E e = tmp->element;
    head->next = head->next->next;
    free(tmp);
    return e;
}

int main(){
    struct LNode head;
    initStack(&head);
    for (int i = 0; i < 3; ++i){
        pushStack(&head,i * 100);
    }
    printStack(&head);
    printf("\n");
    while (!isEmpty(&head)){
        printf("%d ", popStack(&head));
    }
}

在这里插入图片描述

队列

顺序表实现队列

循环队列重复使用一个数组（大小固定 不能扩容）

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

typedef int E;

struct Queue {
    E * array;
    int capacity;
    int front, rear;
};

typedef struct Queue * ArrayQueue;

//初始化
_Bool initQueue(ArrayQueue queue){
    queue->array = malloc(sizeof(E) * 10);
    if(queue->array == NULL) return 0;
    queue->capacity = 10;
    queue->front = queue->rear = 0;
    return 1;
}

//入队
_Bool  offerQueue(ArrayQueue queue, E element){
    int pos = (queue->rear + 1) % queue->capacity;
    if(pos == queue->front)
        return 0;
    queue->rear = pos;
    queue->array[queue->rear] = element;
    return 1;
}

//判断是否为空
_Bool isEmpty(ArrayQueue queue){
    return queue->rear == queue->front;
}

//出队
E pollQueue(ArrayQueue queue){
    queue->front = (queue->front + 1) % queue->capacity;
    return queue->array[queue->front];
}

//打印
void printQueue(ArrayQueue queue){
    printf("<<< ");
    int i = queue->front;
    do {
        i = (i + 1) % queue->capacity;
        printf("%d ", queue->array[i]);
    } while(i != queue->rear);
    printf("<<<\n");
}

int main(){
    struct Queue queue;
    initQueue(&queue);
    for (int i = 0; i < 5; i++) {
        offerQueue(&queue, i * 100);
    }
    printQueue(&queue);
    while (!isEmpty(&queue)) {
        printf("%d ", pollQueue(&queue));
    }
    
    return 0;
}

在这里插入图片描述

用链表实现队列

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

typedef int E;

struct LNode {
    E element;
    struct LNode * next;
};

typedef struct LNode * Node;

struct Queue {
    Node front, rear;
};

typedef struct Queue * LinkedQueue;

//初始化
_Bool initQueue(LinkedQueue queue){
    Node node = malloc(sizeof(struct LNode));
    if(node == NULL) return 0;
    queue->rear = queue->front = node;
    return 1;
}

//入队
_Bool offerQueue(LinkedQueue queue, E element){
    Node node = malloc(sizeof(struct LNode));
    if(node == NULL) return 0;
    node->element = element;
    queue->rear->next = node;
    queue->rear = node;
    return 1;
}

//判断
_Bool isEmpty(LinkedQueue queue){
    return queue->rear == queue->front;
}

//出队
E pollQueue(LinkedQueue queue){
    Node tmp = queue->front->next;
    E e = tmp->element;
    queue->front->next = queue->front->next->next;
    if(queue->rear == tmp) queue->rear = queue->front;
    free(tmp);
    return e;
}

//打印
void printQueue(LinkedQueue queue){
    printf("<<< ");
    Node node = queue->front->next;
    do {
        printf("%d ", node->element);
        if(node == queue->rear) break;    //当已经打印最后一个元素后，再结束
        else node = node->next;
    } while (node);
    printf("<<<\n");
}

int main(){
    struct Queue queue;
    initQueue(&queue);
    for (int i = 0; i < 5; ++i){
        offerQueue(&queue, i*100);
    }
    printQueue(&queue);
    while (!isEmpty(&queue)) {
        printf("%d ", pollQueue(&queue));
    }
}

在这里插入图片描述

实战

删除链表中重复元素

JYing___
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
《数据结构 C语言版|第2版 严蔚敏》算法设计题答案与书中算法源码版
08-06
采用CLion2020~2021开发，根据CMake文件的描述部署后可直接使用。本人对书中部分算法进行了优化，对参考答案中的所有错误均进行了纠正，对可能产生的bug及其触发...赠品为五本经典算法或数据结构书，链接在ReadMe.txt。
线性表的顺序表示与实现（C++版）
tongxinhaonan的专栏
05-18 3123
#define ListSize 100 typedef struct { DataType list[ListSize]; int length; }SeqList;
数据结构2-1章节线性表源码
03-02
根据数据结构-严蔚敏书籍的第2章节的2.1节的算法2-1和2-2编写代码实现验证。采用clion工具验证。 int InitList(List *L); int compare(ElemType x, ElemType y); void union_list(List *pa, List *pb); int ...
数据结构2-2章节线性表的顺序表示和实现自创源码
03-03
根据数据结构-严蔚敏书籍的第2章节的2.2节的算法2-1至2-7编写代码实现验证。采用clion工具验证 int InitList_Sq(SqList *L); int ListInsert_Sq(SqList *L, int i, ElemType e); int ListDelete_Sq(SqList *L, int i...
大一上C语言课程设计作业（Clion）.zip
04-04
此外，C 语言包含了字符型、指针型等多种数据结构形式，因此，更为庞大的数据结构运算它也可以应付。 其二，简洁性。9 类控制语句和 32个KEYWORDS是C语言所具有的基础特性，使得其在计算机应用程序编写中具有广泛的...
免费clion工具.rar
12-03
免费CLion工具包
力扣LCP 08.剧情触发时间
Pisasama的博客
06-12 310
【代码】力扣LCP 08.剧情触发时间。
牛客网刷题 | BC118 N个数之和
m0_64000959的博客
06-09 467
目前主要分为三个专栏，后续还会添加： 专栏如下： C语言刷题解析 C语言系列文章 我的成长经历感谢阅读！初来乍到，如有错误请指出，感谢！输入数字N，然后输入N个数，计算这N个数的和。第一行输入一个整数N(0≤N≤50)，第二行输入用空格分隔的N个整数。输出为一行，为第二行输入的“N个整数之和”的计算结果。使用数组的方式 先将用户输入的几个数字分别存起来定义一个变量将它数字的和加起来然后输出 代码 2 ： 输入n个数相加，应该想到循
LeetCode 算法：轮转数组c++
小金牛来了
06-09 654
LeetCode 算法：轮转数组c++
每日两题6
FZC206的博客
06-09 298
删除并获得点数 + 粉刷房子
算法训练营day03--203.移除链表元素+707.设计链表+206.反转链表
qq_42029265的博客
06-08 506
题目链接：https://leetcode.cn/problems/remove-linked-list-elements/文章讲解：https://programmercarl.com/0203.%E7%A7%BB%E9%99%A4%E9%93%BE%E8%A1%A8%E5%85%83%E7%B4%A0.html视频讲解：https://www.bilibili.com/video/BV18B4y1s7R9。
LSS 和 BEVDepth算法解读
最新发布
pytorch内部机制解读
06-13 797
当前BEV的研究大都基于深度学习的方法，从组织BEV特征信息的方式来看，主流方法分属两类：自底向上方法和自顶向下方法。自底向上方法比较早的代表工作是LSS，后来BEVDet、BEVDepth等也是基于LSS的框架来进行优化。自底向上方法核心是：Lift——对各相机的图像显性地估计像平面下采样后特征点的深度分布，得到包含图像特征的视锥（点云）；Splat——结合相机内外参把所有相机的视锥（点云）分配到BEV网格中，对每个栅格中的多个视锥点进行sum-pooling计算，形成BEV特征图；
(第31天)【leetcode题解】404、左叶子之和
m0_73755059的博客
06-10 295
给定二叉树的根节点 root ，返回所有左叶子之和。
算法：位运算题目练习
一名还在努力学习技术的程序员的博客
06-10 620
本篇博客是关于滑动窗口算法的练习题，每道题都超链接了力扣的网页，每道题都有详细的解答过程
用python分析算法安全性
2402_85292291的博客
06-08 528
首先，你需要导入一些与安全分析相关的库，如`cryptography`、`ssl`和`base64`等。在Python中分析算法安全性，通常需要结合密码学、安全领域的一些库和工具。非对称加密算法通常用于加密对称加密密钥。可以使用`Cipher`类来分析对称加密算法，如AES。
理解和实现 LRU 缓存置换算法
qq_41591215的博客
06-07 496
LRU算法的核心思想是：在缓存空间不足时，淘汰最长时间未被访问的数据项。这种策略适用于多种场景，包括Web缓存、数据库查询缓存、操作系统的页面置换等。
MATLAB实现磷虾算法(Krill herd algorithm)
corn1949的博客
06-10 588
MATLAB实现磷虾算法(Krill herd algorithm)
代码随想录算法训练营Day17|404.左叶子之和 110.平衡二叉树 222.完全二叉树的节点个数
weixin_43836337的博客
06-07 398
1、这道题需要统计出所有左叶子结点的值的和，首先要明确左叶子节点指的2.但是光凭叶子结点本身是无法判定左叶子的，因为左右孩子都是null，所以要从上一层节点往下判定。所以判断左叶子的条件语句应该是3.另外，这道题目采用后序遍历是最方便的。并且要明确递归三要素：返回值、终止条件、递归逻辑。
04-4.2.4 KMP 算法的进一步优化
G2Esports_NiKo的博客
06-10 311
喜欢《数据结构》部分笔记的小伙伴可以订阅专栏，今后还会不断更新。
c语言clion烟花代码
03-05
CLion是一款由JetBrains开发的集成开发环境（IDE），专门用于C和C++语言的开发。它提供了丰富的功能和工具，帮助开发者更高效地编写、调试和管理代码。 关于C语言的烟花代码，这是一种通过控制台输出字符来模拟烟花...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值