个人学习代码

最新推荐文章于 2024-11-11 19:42:06 发布
最新推荐文章于 2024-11-11 19:42:06 发布
阅读量39 收藏
点赞数
文章标签： 算法 c语言 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_74544651/article/details/133468083
版权

十进制转换为其他进制：

①

#define  _CRT_SECURE_NO_WARNINGS

#include<stdio.h>

#include<stdlib.h>

typedef struct stack {

    int data[1000];

    int rear, top;

}*Stack,stack;

Stack Create_stack() {

    Stack stack = (Stack)malloc(sizeof(stack));

    stack->rear = 0;

    stack->top = stack->rear;

}

void Push(Stack stack,int n) {

    stack->data[stack->top++] = n;

}

int Pop(Stack stack) {

    int n = stack->data[stack->top - 1];

    stack->top--;

    return n;

}

int Empty(Stack stack) {

    if (stack->rear == stack->top)return 1;

    else return 0;

}

int main() {

    Stack stack = Create_stack();

    int m;

    long long n;

    scanf("%lld%d", &n, &m);

    if (n == 0)Push(stack, n);

    else

        while (n) {

            Push(stack, n % m);

            n = n / m;

        }

    while (!Empty(stack)) {

        printf("%d ",Pop(stack) );

    }

}

②

#define  _CRT_SECURE_NO_WARNINGS

#include<stdio.h>

#include<stdlib.h>

void Zh(int n,int m) {

    if (n < m) printf("%d",n);

    else {

        Zh(n / m, m); printf("%d", n % m);

    }

}

int main() {

    int n, m;

    scanf("%d%d", & n, &m);

    Zh(n, m);

}

括号匹配：

#define  _CRT_SECURE_NO_WARNINGS

#define Init_Max_Size 10

#define Increasement 20

#include<stdio.h>

#include<stdlib.h>

typedef struct stack

{

    char data[Init_Max_Size];

    int top, rear;

}Stack;

Stack* InitStack() {

    Stack *stack= (Stack*)malloc(sizeof(Stack));

    stack->rear = 0;

    stack->top = 0;

    return stack;

}

void Push(Stack* stack,char data) {

        stack->data[stack->top++] = data;

}

void Pop(Stack* stack) {

    if (!Empty(stack)) stack->top--;

    else printf("栈为空，无法出栈！\n");

}

void Print(Stack* stack) {

    if (Empty(stack)) printf("栈为空，无法打印！\n");

    else

    {

        for (int i = stack->rear; i < stack->top; i++)

            printf("%c\n", stack->data[i]);

    }

}

int Empty(Stack* stack) {

    if (stack->rear == stack->top) return 1;

    else return 0;

}

char GetTop(Stack* stack) {

    if (!Empty(stack)) return stack->data[stack->top - 1];

    else printf("栈为空，无栈顶元素！\n");

}

void Khpp(char s[]) {

    Stack* stack = InitStack();

    for (int i = 0; s[i] != '\0'; i++) {

        if (s[i] == '(') {

            Push(stack, s[i]);

        }

        else if (s[i] == ')' && GetTop(stack) == '(') {

            Pop(stack);

        }

        else {

            printf("匹配失败！\n");

            return;

        }

        

    }

    if (Empty(stack)) {

        free(stack);

        printf("匹配成功！\n");

    }

    else printf("匹配失败！\n");

}

int main() {

    

    char s[100];

    scanf("%s", s);

    Khpp(s);

    return 0;

}

链式前向星（静态邻接表）存图：

#include<iostream>

using namespace std;

typedef struct edge{

    int next, to, cost;

}Edge;

int head[10];

Edge edges[10];

int i;

void Add(int from, int to, int cost) {

    edges[++i].next = head[from];

    edges[i].to = to;

    edges[i].cost = cost;

    head[from] = i;

}

int main() {

    int n;

    cin >> n;

    while (n--) {

        int from, to, cost;

        cin >> from >> to >> cost;

        Add(from, to, cost);

    }

    for ( int j = head[1]; j; j = edges[j].next) {

        printf("%d %d\n", edges[j].to, edges[j].cost);

    }

}

递归

递归汉诺塔：

#define  _CRT_SECURE_NO_WARNINGS

#include<stdio.h>

#include<stdlib.h>

void Hnod(int n, char a, char b, char c) {

    if (n == 1)printf("%c->%c\n", a, c);

    else {

        Hnod(n-1,a,c,b);

        printf("%c->%c\n", a, c);

        Hnod(n - 1, b, a, c);

    }

}

int main() {

    Hnod(10,'A','B','C');

}

快速排序：

//#define  _CRT_SECURE_NO_WARNINGS

#include<iostream>

#include<Algorithm>

#include<time.h>

using namespace std;

int a[100];

void qsort(int l, int r) {

    if (l >= r)return;

    int i = l, j = r, k = a[(l+r)/2];

    while (i <= j) {

        while (i <= j && a[j] > k)j--;

        while (i <=j && a[i] < k)i++;

        if (i > j)break;

        swap(a[i++], a[j--]);

    }

    qsort(l, j); qsort(i, r);

}

int main() {

    int n;

    cin >> n;

    for (int i = 1; i <= n; i++)cin >> a[i];

    srand(time(0));

    qsort(1, n);

    for (int i = 1; i <= n; i++)

        cout << a[i] << " ";

    return 0;

}

归并排序：

#include<iostream>

using namespace std;

int a[100], b[100];

void merge_sort(int l, int r) {

    if (l >= r)return;

    int mid = (l + r) / 2;

    merge_sort(l, mid); merge_sort(mid + 1, r);

    int i = l, j = mid + 1, k = l;

    while (i <= mid && j <= r) {

        if (a[i] <= a[j]) {

            b[k++] = a[i++];

        }

        else {

            b[k++] = a[j++];

        }

    }

    while (i <= mid) {

        b[k++] = a[i++];

    }

    while (j <= r) {

        b[k++] = a[j++];

    }

    for (int i = l; i <= r; i++)

        a[i] = b[i];

}

int main() {

    int n;

    cin >> n;

    for (int i = 1; i <= n; i++)cin >> a[i];

    merge_sort(1, n);

    for (int i = 1; i <= n; i++)cout << a[i]<<" ";

    return 0;

}

逆序对对个数：

#include<iostream>

using namespace std;

int a[100], b[100],cnt;

void merge_sort(int l, int r) {

    if (l >= r)return;

    int mid = (l + r) / 2;

    merge_sort(l, mid); merge_sort(mid + 1, r);

    int i = l, j = mid + 1, k = l;

    while (i <= mid && j <= r) {

        if (a[i] <= a[j]) {

            b[k++] = a[i++];

        }

        else {

            b[k++] = a[j++];

            cnt += (mid - i + 1);

        }

    }

    while (i <= mid) {

        b[k++] = a[i++];

    }

    while (j <= r) {

        b[k++] = a[j++];

    }

    for (int i = l; i <= r; i++)

        a[i] = b[i];

}

int main() {

    int n;

    cin >> n;

    for (int i = 1; i <= n; i++)cin >> a[i];

    merge_sort(1, n);

    for (int i = 1; i <= n; i++)cout << a[i]<<" ";

    cout << endl;

    cout << cnt;//逆序对个数

    return 0;

}

全排列：

#include<iostream>

using namespace std;

int vis[100],pl[100],n;

void DFS(int step) {

    if(step==n+1)

    {

        for(int i=1; i<=n; i++)

            cout << pl[i] << ' ';

        cout<< endl;

        return;

    }

    else {

        for(int i=1; i<=n; i++) {

            if(!vis[i])

            {

                vis[i]=1;

                pl[step]=i;

                DFS(step+1);

                vis[i]=0;

            }

        }

    }

}

int main() {

cin >> n;

    DFS(1);

    return 0;

}

n皇后问题：

#include<iostream>
using namespace std;
int lie[200], zd[200], fd[100],n,a[200];
bool check(int i, int j) {
    if (!lie[j] && !zd[i - j + 100] && !fd[i + j]) return true;
    else return false;
}
void dfs(int hang) {
    if (hang == n + 1) {
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= n; j++) {
                if (a[i] == j)cout << 1<<" ";
                else cout << 0 << " ";
            }
            cout << endl;
        }
        cout << "------------------------------------"<<endl;
    }
    else {
        for (int j = 1; j <= n; j++) {
            if (check(hang, j)) {
                lie[j] = 1;
                zd[hang - j + 100] = 1;
                fd[hang + j] = 1;
                a[hang] = j;
                dfs(hang + 1);
                lie[j] = 0;
                zd[hang - j + 100] = 0;
                fd[hang + j] = 0;
            }
        }
    }
}
int main() {
    cout << "请输入皇后个数：";
    cin >> n;
    dfs(1);
}

字符串图：

#include<iostream>
using namespace std;
char map[100][100];
int n, m;
int main() {
    cin >> n;
    for (int i = 1; i <= n; i++)scanf("%s", map[i] + 1);//存图，行间用空格分开
    cout << endl;
    for (int i = 1; i <= n; i++)printf("%s\n", map[i] + 1);
}

油田问题：

①

#define  _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;
char map[100][100];
bool vis[100][100];//标记（x,y）格是否被遍历
int dir[4][2] = { -1,0,1,0,0,-1,0,1 };
int n, m,ans;
bool check(int x, int y) {
    return x >= 1 && x <= n && y >= 1 && y <= n;
}
void dfs(int x, int y) {
    for (int i = 0; i < 4; i++) {
        int xx = dir[i][0] + x;
        int yy = dir[i][1] + y;
        if (map[xx][yy] == '@' && !vis[xx][yy] && check(xx, yy)) {
            vis[xx][yy] = true;
            dfs(xx, yy);//递归遍历（x,y）的上下左右四个格并标记是否为油田
        }
    }
}
int main() {
    cin >> n>>m;
    for (int i = 1; i <= n; i++)scanf("%s", map[i]);
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= m; j++) {
            if (map[i][j] == '@' && !vis[i][j]) {//如果vis[i][j]为true则被遍历过而且为油田,且可能与其他油田相连
                vis[i][j] = true;
                ans++;
                dfs(i, j);
            }
        }
    }
    cout << ans;
    return 0;
}

②

#define  _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;
char map[100][100];
bool vis[100][100];//标记（x,y）格是否被遍历
int dir[4][2] = { -1,0,1,0,0,-1,0,1 };
int n, m, k;
inline bool check(int x, int y) {
    return x >= 1 && x <= n && y >= 1 && y <= m;
}
void dfs(int x, int y) {
    for (int i = 0; i < 4; i++) {
        int xx = dir[i][0] + x;
        int yy = dir[i][1] + y;
        if (map[xx][yy] == '.' && !vis[xx][yy] && check(xx, yy) && k) {
            vis[xx][yy] = true;
            dfs(xx, yy);//递归至叶子结点
            if (k)k--,map[xx][yy] = 'X';
        }
    }
    
}
int main() {
    cin >> n >> m>>k;
    for (int i = 1; i <= n; i++) scanf("%s", map[i]+1);
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= m; j++) {
            if (map[i][j] == '.' && !vis[i][j] && k) {//如果vis[i][j]为true则被遍历过而且为油田,且可能与其他油田相连
                vis[i][j] = true;
                dfs(i, j);
            }
        }
    }
    for (int i = 1; i <= n; i++) {
        cout << map[i]+1 << endl;
    }
    return 0;
}

城市连通：

#define  _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<vector>
using namespace std;
vector<int>map[100];
bool ans, vis[100];
void dfs(int from, int to) {
    if (from == to) {
        ans = true;
        return;
    }
    else {
        for (int i : map[from]) {
            if (!vis[i]) {
                vis[i] = true;
                dfs(i, to);
            }
        }
    }
}
int main() {
    int n, m;
    cin >> n >> m;
    for (int i = 1; i <= m; i++) {
        int from, to;
        cin >> from >> to;
        map[from].push_back(to);
    }
    dfs(2, 1);
    if (ans == true)cout << "YES" << endl;
    else cout << "NO" << endl;
    return 0;
}

或

#define  _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;
bool ans, vis[100];
int head[100],cnt;
struct edge {
    int next, to;
}edges[100];
void add(int from, int to) {
    edges[++cnt].next = head[from];
    edges[cnt].to = to;
    head[from] = cnt;
}
void dfs(int from, int to) {
    if (from == to) {
        ans = true;
        return;
    }
    else {
        for (int i = head[from]; i; i = edges[i].next) {
            if (!vis[i]) {
                vis[i] = true;
                dfs(i, to);
            }
        }
    }
}
int main() {
    int n, m;
    cin >> n >> m;
    for (int i = 0; i < m; i++) {
        int from, to;
        cin >> from >> to;
        add(from, to);
    }
    dfs(4, 1);
    if (ans == true) cout << "YES" << endl;
    else cout << "NO" << endl;
    return 0;
}

数字转化：

#define  _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;
int n,m,step,vis[1000];
bool ans;
void dfs(int step, long long value) {
    if (value > m) return;
    else if (value == m&&!ans) {
        ans = true;
        cout << "YES" << endl;
        cout << n << ' ';
        for (int i = 1; i <= step-1; i++) {
            if (vis[i] == 1) {
                n = n * 10 + 1;
                cout << n << ' ';
            }
            else {
                n *= 2;
                cout << n << ' ';
            }
        }
        return;
    }
    else {
        vis[step] = true;//二叉树,vis[]记录分支
        dfs(step + 1, value * 10 + 1);
        vis[step] = false;
        dfs(step + 1, value * 2);
    }
}
int main() {
    cin >> n >> m;
    dfs(1, n);
    if (!ans)cout << "NO" << endl;
    return 0;
}

树染色次数最少：

#define  _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<vector>
using namespace std;
vector<int>map[20];
int step,color[20];
void dfs(int num, int frontcol) {//frontcol为父节点的颜色
    if (color[num] != frontcol)step++;//当父节点颜色与当前节点的颜色不同时step++
    for (int i : map[num]) dfs(i, color[num]);
}
int main() {
    int n;cin >> n;
    for (int i = 2; i <= n; i++) {//读入除根节点外的其他节点的父节点
        int from; cin >> from;
        map[from].push_back(i);
    }
    for (int i = 1; i <= n; i++) cin >> color[i];//读入每个节点的颜色，颜色代码1,2
    dfs(1, 0);
    cout << step << endl;
    return 0;
}

超级讨厌写代码
关注
html个人简介网页代码_HTML代码与基础
weixin_39923599的博客
01-12 6224
<!DOCTYPE HTML><html> <head> <meta http-equiv="Content-Type" content="text/html; charset=utf-8"> <title>制作我的第一个网页</title> </head> <b...
如何学习代码
ad2198084040的博客
05-01 9909
作为一名自学成才的程序员，我一直在不断敦促自己学习，我将经过本回答分享一下我个人总结出的六项重要诀窍。 　　学习编程的进程，大致如下： 　　看书、看博客、学课程或者看视频等 　　仿照着书上或者博客的代码，进行复现，复现不重要，考虑才是关键?? 　　考虑学习别人思路后，脱离书本和博客，彻底自己完成功用 　　自己完成一些DEMO，看别人项目代码，与别人评论，提高代码才能 　　在别人的框架和要求下，写代...
学习代码心得总结
doney88的博客
07-05 6973
在遇到一个自己搞不懂的问题点后，总结了以下方法论： 在csdn中查询关键字，找标题关联性最大的点开找大概10个帖子看。（查资料，先找，找一定量后，一个个再看） 看msdn 问大神 当然在找资料的时候会发现，找到相关的资料里面也有看不懂的，那就继续对看不懂的资料继续深入，就像是一个个节点。个人觉得当你达到第三层的时候差不多就该收手了，这个世界那么大你不可能搞懂世间万物所有事情。 同时脑子里一定要...
迁移学习与代码举例
u011517132的博客
03-18 1万+
迁移学习出现背景 在有监督的机器学习和尤其是深度学习的场景应用中，需要大量的标注数据。标注数据是一项枯燥无味且花费巨大的任务，关键是现实场景中，往往无法标注足够的数据。而且模型的训练是极其耗时的。因此迁移学习营运而生。 传统机器学习(主要指监督学习) 基于同分布假设 需要大量标注数据 然而实际使用过程中不同数据集可能存在一些问题，比如 数据分布差异 标注数据过期 训练数据过期，也就是好不容易标定...
极限学习机（ELM）从原理到程序实现（附完整代码）
热门推荐
思绪无限的博客
06-07 10万+
摘要：极限学习机（ELM）是当前一类非常热门的机器学习算法，被用来训练单隐层前馈神经网络（SLFN）。本篇博文尽量通俗易懂地对极限学习机的原理进行详细介绍，之后分析如何用MATLAB实现该算法并对代码进行解释。本文主要内容如下：算法的原理、算法程序实现、点击跳转至全部文件下载页
FPGA学习中的代码阅读
05-07 2555
不管是学FPGA还是C语言，任何一种代码的学习都离不开大量的代码阅读，也就是多看，多学习别人的代码。初学者在学习的过程中更为重要的是模仿，模仿别人的代码算法怎么去处理的，模仿多了，代码看的多了，能力自然就有所提升了。 说到这里不免有人问，那是不是去抄袭别人的代码啊，这种行为多可耻啊。个人认为，如果有这种高尚的想法的话，一定要尽早的放弃IT行业。对于初学者来说，要学习的东西很多都是技术成熟的了
HTML做一个个人博客页面（纯html代码）
QQ_____365392777的博客
08-11 4万+
📔网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。📓网站程序方面：计划采用最新的网页编程语言HTML5+CSS3+JS程序语言完成网站的功能设计。并确保网站代码兼容目前市面上所有的主流浏览器，已达到打开后就能即时看到网站的效果。📘网站素材方面：计划收集各大平台好看的图片素材，并精挑细选适合网页风格的图片，然后使用PS做出适合网页尺寸的图片。📒网站文件方面：网站系统文件种类包含：html网页结构文件、css网页样式文件、js网页特效文件、images网页图片文件；...
机器学习入门与实践：从原理到代码
努力是为了站在万人之中，成为别人的光
09-19 8666
机器学习是人工智能领域的一个关键分支，它使计算机能够从数据中学习和提取模式，从而实现各种任务，如图像分类、文本分析和预测。本文将带您深入机器学习的世界，从理论到实践，逐步构建机器学习模型。
Pytorch 深度学习运行代码简单教程
赫凯的博客
10-09 5399
Pytorch 是一个机器深度学习框架，易于上手，个人感觉比tensorboard要友好。 Pytorch的深度学习程序分三个模块，实现三个功能，分别是取数据、建模型、运行程序。一般是分三个.py文件写，当然也可以写在一个文件里。我喜欢写成三个文件，这样看着比较方便点，而且Pytorch把这三个功能都写的挺好的，自己用的时候继承稍微改一下就好了。 其实深度学习的最终目标，就像求 y=f(x)y = f(x)y=f(x) 这个公式中 f(x)f(x)f(x) 的最佳参数一样： 首先我们会有很多很多的 (x,
基于深度学习的恶意代码分类（一）
老油子的博客
03-15 5126
基于深度学习的恶意代码分类 1. 基于传统机器学习算法的恶意代码分类方法 恶意代码分类主要有两种应用：恶意代码检测和恶意代码家族聚类。 恶意代码检测的目的是判断未知代码是否是恶意代码，即将未知代码分为良性代码和恶意代码两类。 恶意代码家族聚类是以恶意代码为数据集，依据特征相似性和家族类别标签将恶意代码分为多类。 恶意代码分类任务主要有两个过程：特征提取过程和分类过程。其中，特征提取过程通常采用传统的恶意代码分析方法进行提取；分类过程主要分为两个步骤： 分类模型的构建和分类模型的使用： 在第一个步骤中，将提取
个人学习C语言时的代码.zip
10-18
个人学习C语言时的代码.zip个人学习C语言时的代码.zip个人学习C语言时的代码.zip个人学习C语言时的代码.zip个人学习C语言时的代码.zip个人学习C语言时的代码.zip个人学习C语言时的代码.zip
c语言文件读写操作代码（个人学习笔记）
09-19
c语言文件读写操作代码（个人学习笔记）c语言文件读写操作代码（个人学习笔记）c语言文件读写操作代码（个人学习笔记）c语言文件读写操作代码（个人学习笔记）c语言文件读写操作代码（个人学习笔记）c语言文件读写...
静态网页作品-精美个人主页源代码
09-25
针对很多人为了交作业在网上找静态网页作业，帮一个学生做的个人网页，经过美化修改，第一次发出来供初学者学习参考。 包含6个独立页面，分别为首页index.html、about.html、flash.html、message.html、photo.html、...
吴恩达机器学习个人笔记完整版 附有代码 PDF PPT
07-16
Coursera-ML-AndrewNg-Notes-master，内含有代码，文档，PPT ，Markdown，srt ,机器学习个人笔记完整版
Python基于机器学习的个人信贷违约预测识别项目源码+数据集，毕业设计项目
04-18
机器学习中的一个案例：对贷款违约行为的预测 软件架构 编程语言：Python3.7.7 编译器：PyCharm Community Edition 2020.2.3 x64 使用说明 data:数据文件 code:代码文件 result:结果文件 程序代码完整，可直接运行
数据库范式、MySQL 架构、算法与树的深入解析
最新发布
lrh35的博客
11-11 639
在数据库设计中，范式是一系列规则，用于确保数据的组织和存储具有良好的结构、完整性以及最小化的数据冗余。如果不遵循范式设计，数据可能会以平铺式罗列，仅使用冒号、分号等简单分隔。这种方式存在诸多弊端，例如在数据搜索时极为不便，数据修改也会变得十分棘手。由此，范式的概念应运而生。
点云配准之点到点，点到面，点到线ICP，NDT算法介绍
qq_54375651的博客
11-10 1224
点云配准在人工智能，自动驾驶，SLAM等任务中具有十分关键的作用，本文将介绍点云配准的点到点，点到线，点到面ICP和NDT算法
二分查找习题篇(上)
zoelinkailuo的博客
11-07 966
给定⼀个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。这里，我们把数组的元素分为两部分——小于等于target的部分[left,Bright] and 大于target的部分[Bright+1,right]。这里，我们把数组的元素分为两部分——平方后小于等于x的部分[1,mid] and 平方后大于x的部分[mid-1, x]和一个目标值，在数组中找到目标值，并返回其索引;
AI 写作（三）文本生成算法：创新与突破（3/10）
小相探索IT世界
11-08 1565
本文深入探讨了 AI 写作中的多种文本生成算法。首先介绍了生成式与判别式模型的区别与特点，包括优化准则、对观察序列的处理、训练复杂度以及支持的训练方式等方面的差异，并对比了它们在 AI 写作中的优缺点。接着详细阐述了长短期记忆网络（LSTM）在文本生成中的应用，包括技术原理与结构、实现步骤与流程以及应用示例与效果。还深入分析了 Transformer 与自注意力机制，介绍了其模型架构与组成、自注意力机制的作用以及在 AI 写作中的重要作用。
天池竞赛机器学习代码集锦
资源摘要信息: "机器学习竞赛代码.zip" 1. MRClassify - 天池数加平台OPEN_MR示例 MRClassify指的是使用MapReduce框架实现的分类算法示例。MapReduce是一种编程模型，用于处理和生成大数据集。在天池数加平台上，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值