王道OJ中级阶段(16-26题)

最新推荐文章于 2025-09-20 22:59:29 发布
原创 最新推荐文章于 2025-09-20 22:59:29 发布 · 405 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#算法 #数据结构 #考研 #c语言

目录

第16题

第17题

第18题

第19题

第20题

第21题

第22题

第24题

第25题

第26题

  • 第16题

#include <stdio.h>

//静态分配
#define MaxSize 50
typedef int ElemType;//方便后续修改顺序表存储的数据类型
typedef struct{
    ElemType data[MaxSize];
    int Length;
}SqList;

//插入函数
bool ListInsert(SqList &L,int i,ElemType element){
    //判断插入位置是否合法
    if(i<1 || i>L.Length+1)
    {
        return false;
    }
    //判断顺序表是否已经存满
    if(L.Length==MaxSize)
    {
        return false;
    }
    //第i个位置对应下标为i-1，所以原来下标是i-1以及之后的元素都要向后移动，j>=i-1
    //for()括号内考虑循环结束时的边界条件
    for(int j=L.Length;j>=i-1;j--)
    {
        //考虑循环开始时的边界条件
        //第Length个元素对应下标为Length-1，移动到下标为Length的位置上
        L.data[j]=L.data[j-1];
    }
    L.data[i-1]=element;//将新元素插入下标为i-1的位置上
    L.Length++;//顺序表长度加1
    return true;
}

//删除函数
bool ListDelete(SqList &L,int i,ElemType &del){
    //判断删除的位置是否合法
    if(i<1 || i>L.Length)
    {
        return false;
    }
    del=L.data[i-1];
    for(int j=i;j<=L.Length-1;j++)
    {
        L.data[j-1]=L.data[j];
    }
    L.Length--;
    return true;
}

//打印函数
void PrintList(SqList L){
    for(int i=0;i<=L.Length-1;i++)
    {
        printf("%3d",L.data[i]);
    }
    printf("\n");
}

int main() {
    SqList L;
    bool ret;
    ElemType element,del;
    int i;//要删除元素的位置
    L.data[0]=1;
    L.data[1]=2;
    L.data[2]=3;
    L.Length=3;
    scanf("%d",&element);
    ret=ListInsert(L,2,element);
    if(!ret)
    {
        printf("false\n");
        return 0;
    }
    PrintList(L);
    scanf("%d",&i);
    ret=ListDelete(L,i,del);
    if(!ret)
    {
        printf("false\n");
        return 0;
    }
    PrintList(L);
    return 0;
}

  • 第17题

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

typedef int ElemType;
typedef struct LNode{
    ElemType data;
    struct LNode *next;
}LNode,*LinkList;

void PrintList(LinkList L){
    L=L->next;
    while(L!=NULL)
    {
        printf("%d",L->data);//打印当前结点数据
        L=L->next;//指向下一个结点
        if(L!=NULL)
        {
            printf(" ");
        }
    }
    printf("\n");
}

LinkList List_HeadInsert(LinkList &L){
    LNode *s;
    ElemType x;
    L=(LNode *)malloc(sizeof(LNode));
    L->next=NULL;
    scanf("%d",&x);
    while(x!=9999){
        s=(LNode *)malloc(sizeof(LNode));
        s->data=x;
        s->next=L->next;
        L->next=s;
        scanf("%d",&x);
    }
    return L;
}

LinkList List_TailInsert(LinkList &L){
    ElemType x;
    L=(LNode *)malloc(sizeof(LNode));
    L->next=NULL;
    LNode *s,*r=L;
    scanf("%d",&x);
    while(x!=9999){
        s=(LNode *)malloc(sizeof(LNode));
        s->data=x;
        r->next=s;
        r=s;
        scanf("%d",&x);
    }
    r->next=NULL;
    return L;
}

int main(){
    LinkList L;
    List_HeadInsert(L);
    PrintList(L);
    List_TailInsert(L);
    PrintList(L);
    return 0;
}

  • 第18题

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

typedef int ElemType;
typedef struct LNode{
    ElemType data;
    struct LNode *next;
}LNode,*LinkList;

void PrintList(LinkList L)
{
    L = L->next;
    while (L != NULL)
    {
        printf("%3d", L->data);//打印当前结点数据
        L = L->next;//指向下一个结点
    }
    printf("\n");
}

LinkList List_TailInsert(LinkList &L){
    ElemType x;
    L=(LNode *)malloc(sizeof(LNode));
    L->next=NULL;
    LNode *s,*r=L;
    scanf("%d",&x);
    while(x!=9999){
        s=(LNode *)malloc(sizeof(LNode));
        s->data=x;
        r->next=s;
        r=s;
        scanf("%d",&x);
    }
    r->next=NULL;
    return L;
}

LNode *GetElem(LinkList L,int i){
    LNode *p=L;
    int j=0;
    if(i<0)
    {
        return NULL;
    }
    while(j<i && p!=NULL)
    {
        p=p->next;
        j++;
    }
    return p;
}

bool ListInsert(LinkList &L,int i,ElemType e){
    LNode *p=GetElem(L,i-1);
    if(p==NULL)
    {
        return false;
    }
    LNode *s=(LNode *)malloc(sizeof(LNode));
    s->data=e;
    s->next=p->next;
    p->next=s;
    return true;
}

bool ListDelete(LinkList &L,int i,ElemType &e){
    LNode *p=GetElem(L,i-1);
    if(p==NULL || p->next==NULL)
    {
        return false;
    }
    LNode *q=p->next;
    e=q->data;
    p->next=q->next;
    free(q);
    return true;
}

int main(){
    LinkList L;
    ElemType e;
    List_TailInsert(L);
    printf("%d\n",GetElem(L,2)->data);
    ListInsert(L,2,99);
    PrintList(L);
    ListDelete(L,4,e);
    PrintList(L);
    return 0;
}

  • 第19题

#include <stdio.h>

#define Size 50
typedef int ElemType;
typedef struct{
    ElemType data[Size];
    int top;
}SqStack;

#define MaxSize 5
typedef int ElemType;
typedef struct{
    ElemType data[MaxSize];
    int front,rear;
}SqQueue;

void InitQueue(SqQueue &Q){
    Q.front=Q.rear=0;
}

bool EnQueue(SqQueue &Q,ElemType x){
    if((Q.rear+1)%MaxSize==Q.front)
    {
        return false;
    }
    Q.data[Q.rear]=x;
    Q.rear=(Q.rear+1)%MaxSize;
    return true;
}

bool DeQueue(SqQueue &Q,ElemType &x){
    if(Q.rear==Q.front)
    {
        return false;
    }
    x=Q.data[Q.front];
    Q.front=(Q.front+1)%MaxSize;
    return true;
}

void InitStack(SqStack &S){
    S.top=-1;
}

bool Push(SqStack &S,ElemType x){
    if(S.top==MaxSize-1)
    {
        return false;
    }
    S.data[++S.top]=x;
    return true;
}

bool Pop(SqStack &S,ElemType &x){
    if(S.top==-1)
    {
        return false;
    }
    x=S.data[S.top--];
    return true;
}

int main(){
    SqStack S;
    InitStack(S);
    ElemType x;
    for(int i=1;i<=3;i++)
    {
        scanf("%d",&x);
        Push(S,x);
    }
    for(int i=1;i<=3;i++)
    {
        Pop(S,x);
        printf("%2d",x);
    }
    printf("\n");

    SqQueue Q;
    InitQueue(Q);
    for(int i=1;i<=5;i++)
    {
        int ret;
        scanf("%d",&x);
        ret=EnQueue(Q,x);
        if(!ret)
        {
            printf("false\n");
        }
    }
    for(int i=1;i<=4;i++)
    {
        DeQueue(Q,x);
        printf("%2d",x);
    }
    printf("\n");
    return 0;
}

  • 第20题

#include <stdio.h>
#include <stdlib.h>
typedef char ElemType;
typedef struct BiTNode{
    ElemType data;
    struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;

typedef struct tagNode{
    BiTNode *p;
    struct tagNode *next;
}tagNode,*tag;

void PreOrder(BiTree T){
    if(T!=NULL) {
        printf("%c", T->data);
        PreOrder(T->lchild);
        PreOrder(T->rchild);
    }
}

 
int main(){
    ElemType c;
    BiTree T=NULL;
    BiTNode *tnew;
    tagNode *rear=NULL,*pcur=NULL,*s;
    while(scanf("%c",&c))
    {
        if(c=='\n')
        {
            break;
        }
        tnew=(BiTNode *)calloc(1,sizeof(BiTNode));
        tnew->data=c;
        s=(tagNode *)calloc(1,sizeof(tagNode));
        s->p=tnew;
        if(T==NULL)
        {
            T=tnew;
            rear=pcur=s;
        }else{
            rear->next=s;
            rear=s;
            if(pcur->p->lchild==NULL)
            {
                pcur->p->lchild=tnew;
            }else if(pcur->p->rchild==NULL){
                pcur->p->rchild=tnew;
                pcur=pcur->next;
            }
        }
    }
    PreOrder(T);
    return 0;
}

  • 第21题

#include <stdio.h>
#include <stdlib.h>
typedef char ElemType;
typedef struct BiTNode{
    ElemType data;
    struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;

typedef struct tagNode{
    BiTNode *p;
    struct tagNode *next;
}tagNode,*tag;

typedef struct LinkNode{
    BiTNode *data;
    struct LinkNode *next;
}LinkNode;

typedef struct{
    LinkNode *front,*rear;
}LinkQueue;

bool IsEmpty(LinkQueue Q){
    return Q.front==Q.rear;
}

void InitQueue(LinkQueue &Q){
    Q.front=Q.rear=(LinkNode *)malloc(sizeof(LinkNode));
    Q.front->next=NULL;
}

void EnQueue(LinkQueue &Q,BiTNode * x){
    LinkNode *s=(LinkNode *)malloc(sizeof(LinkNode));
    s->data=x;
    s->next=NULL;
    Q.rear->next=s;
    Q.rear=s;
}

bool DeQueue(LinkQueue &Q,BiTNode * &x){
    if(Q.rear==Q.front)
    {
        return false;
    }
    LinkNode *p=Q.front->next;
    x=p->data;
    Q.front->next=p->next;
    if(Q.rear==p)
    {
        Q.rear=Q.front;
    }
    free(p);
    return true;
}

void InOrder(BiTree T){
    if(T!=NULL) {
        InOrder(T->lchild);
        printf("%c", T->data);
        InOrder(T->rchild);
    }
}
void PostOrder(BiTree T){
    if(T!=NULL) {
        PostOrder(T->lchild);
        PostOrder(T->rchild);
        printf("%c", T->data);
    }
}

void LevelOrder(BiTree T){
    LinkQueue Q;
    InitQueue(Q);
    BiTNode *p;
    EnQueue(Q,T);
    while(!IsEmpty(Q))
    {
        DeQueue(Q,p);
        putchar(p->data);
        if(p->lchild!=NULL)
        {
            EnQueue(Q,p->lchild);
        }
        if(p->rchild!=NULL)
        {
            EnQueue(Q,p->rchild);
        }
    }

}
int main(){
    ElemType c;
    BiTree T=NULL;
    BiTNode *tnew;
    tagNode *rear=NULL,*pcur=NULL,*s;
    while(scanf("%c",&c))
    {
        if(c=='\n')
        {
            break;
        }
        tnew=(BiTNode *)calloc(1,sizeof(BiTNode));
        tnew->data=c;
        s=(tagNode *)calloc(1,sizeof(tagNode));
        s->p=tnew;
        if(T==NULL)
        {
            T=tnew;
            rear=pcur=s;
        }else{
            rear->next=s;
            rear=s;
            if(pcur->p->lchild==NULL)
            {
                pcur->p->lchild=tnew;
            }else if(pcur->p->rchild==NULL){
                pcur->p->rchild=tnew;
                pcur=pcur->next;
            }
        }
    }
    InOrder(T);
    printf("\n");
    PostOrder(T);
    printf("\n");
    LevelOrder(T);
    printf("\n");
    return 0;
}

  • 第22题

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

typedef int ElemType;
typedef struct{
    ElemType *elem;
    int TableLen;
}SSTable;

typedef struct BSTNode{
    ElemType data;
    struct BSTNode *lchild,*rchild;
}BSTNode,*BiTree;

void InOrder(BiTree T,int str[]){
    static int k=0;
    if(T!=NULL) {
        InOrder(T->lchild,str);
        printf("%3d", T->data);
        str[k++]=T->data;
        InOrder(T->rchild,str);
    }
}

bool BST_Insert(BiTree &T,ElemType m){
    BSTNode * NewNode=(BSTNode *)calloc(1,sizeof(BSTNode));
    NewNode->data=m;
    if(T==NULL){
        T=NewNode;
        return true;
    }
    BSTNode * p=T,*parent=NULL;
    while (p!=NULL){
        parent=p;
        if(m<p->data){
            p=p->lchild;
        }
        else if(m>p->data){
            p=p->rchild;
        }
        else{
            return false;
        }
    }
    if(m>parent->data){
        parent->rchild=NewNode;
    }else{
        parent->lchild=NewNode;
    }
    return true;
}

void Creat_BST(BiTree &T,ElemType str[],int len){
    T=NULL;
    for(int i=0;i<len;i++)
        BST_Insert(T,str[i]);
}

int Binary_Search(SSTable ST,ElemType key){
    int low=0,high=ST.TableLen-1,mid;
    while(low<=high)
    {
        mid=(low+high)/2;
        if(key==ST.elem[mid])
        {
            return mid;
        }
        else if(ST.elem[mid]>key)
        {
            high=mid-1;
        }
        else
        {
            low=mid+1;
        }
    }
    return -1;
}

int main(){
    BiTree T=NULL;
    int str[10];
    for(int i=0;i<10;i++){
        scanf("%d",&str[i]);
    }
    Creat_BST(T,str,10);
    InOrder(T,str);
    printf("\n");
    SSTable ST;
    ST.elem=str;
    ST.TableLen=10;
    printf("%d",Binary_Search(ST,21));
    return 0;
}

  • 第24题

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

typedef int ElemType;

void swap(ElemType &a,ElemType &b){
    ElemType temp=a;
    a=b;
    b=temp;
}

void print(ElemType A[],int len){
    for(int i=0;i<len;i++){
        printf("%3d",A[i]);
    }
    printf("\n");
}

void InsertSort(ElemType A[],int len){
    int i,j;
    ElemType temp;
    for(i=1;i<len;i++){
        if(A[i]<A[i-1]){
            temp=A[i];
            for(j=i-1;j>=0&&A[j]>temp;j--){
                A[j+1]=A[j];
            }
            A[j+1]=temp;
        }
    }
}


void BubbleSort(ElemType A[],int len){
    for(int i=0;i<len-1;i++){
        bool flag= false;
        for(int j=len-1;j>i;j--){
            if(A[j]<A[j-1]){
                swap(A[j],A[j-1]);
                flag= true;
            }
        }
        if(!flag){
            return;
        }
    }
}

int Partition(ElemType A[],int low,int high){
    ElemType pivot=A[low];
    while(low<high){
        while(low<high&&A[high]>=pivot){
            high--;
        }
        A[low]=A[high];
        while(low<high&&A[low]<=pivot){
            low++;
        }
        A[high]=A[low];
    }
    A[low]=pivot;
    return low;
}

void QuickSort(ElemType A[],int low,int high){
    if(low<high){
        int pivotpos= Partition(A,low,high);
        QuickSort(A,low,pivotpos-1);
        QuickSort(A,pivotpos+1,high);
    }
}

int main(){
    ElemType A[10],B[10],C[10];
    for(int i=0;i<=9;i++){
        scanf("%d",&A[i]);
        B[i]=C[i]=A[i];
    }
    BubbleSort(A,10);
    print(A,10);
    InsertSort(B,10);
    print(B,10);
    QuickSort(C,0,9);
    print(C,10);
    return 0;
}

  • 第25题

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

typedef int ElemType;

void swap(ElemType &a,ElemType &b){
    ElemType temp=a;
    a=b;
    b=temp;
}

void print(ElemType A[],int len){
    for(int i=0;i<len;i++){
        printf("%3d",A[i]);
    }
    printf("\n");
}

void printA(ElemType A[],int len){
    for(int i=1;i<len;i++){
        printf("%3d",A[i]);
    }
    printf("\n");
}


void SelectSort(ElemType A[],int len){
    for(int i=0;i<len-1;i++){
        int min=i;
        for(int j=i+1;j<len;j++){
            if(A[j]<A[min]){
                min=j;
            }
        }
        if(min!=i){
            swap(A[i],A[min]);
        }
    }
}

void HeadAdjust(ElemType A[],int key,int len){
    A[0]=A[key];
    for(int i=2*key;i<=len;i=2*i){
        if(i<len&&A[i]<A[i+1]){
            i++;
        }
        if(A[0]>A[i]){
            break;
        }else{
            A[key]=A[i];
            key=i;
        }
    }
    A[key]=A[0];
}

void BuildMaxHeap(ElemType A[],int len){
    for(int i=len/2;i>0;i--){
        HeadAdjust(A,i,len);
    }
}

void HeapSort(ElemType A[],int len){
    BuildMaxHeap(A,len);
    for(int i=len;i>1;i--){
        swap(A[i],A[1]);
        HeadAdjust(A,1,i-1);
    }
}

int main(){
    ElemType A[11],B[10];
    A[0]=0;
    for(int i=0;i<=9;i++){
        scanf("%d",&B[i]);
        A[i+1]=B[i];
    }
    SelectSort(B,10);
    print(B,10);
    HeapSort(A,11);
    printA(A,11);
    return 0;
}

  • 第26题

#include<stdio.h>
#define N 10
typedef int ElemType;

void print(ElemType A[],int len){
    for(int i=0;i<len;i++){
        printf("%3d",A[i]);
    }
    printf("\n");
}

void Merge(ElemType A[],int low,int mid,int high){
    static ElemType B[N];
    int i=low,j=mid+1,k;
    for(k=low;k<=high;k++){
        B[k]=A[k];
    }
    for(k=low;i<=mid&&j<=high;k++){
        if(B[i]<=B[j]){
            A[k]=B[i++];
        }else{
            A[k]=B[j++];
        }
    }
    while(i<=mid){
        A[k++]=B[i++];
    }
    while(j<=high){
        A[k++]=B[j++];
    }
}

void MergeSort(ElemType A[],int low,int high){
    if(low<high){
        int mid=(low+high)/2;
        MergeSort(A,low,mid);
        MergeSort(A,mid+1,high);
        Merge(A,low,mid,high);
    }
}

int main(){
    ElemType A[10];
    for(int i=0;i<=9;i++){
        scanf("%d",&A[i]);
    }
    MergeSort(A,0,9);
    print(A,10);
    return 0;
}
C语言督学营（中级阶段）
Edward2022的博客
06-24 972
数据结构
王道计算机【C语言督学营】完整笔记
lliwenchuang的博客
03-05 1270
【王道C语言初级阶段（C语言入门代码）】【王道C语言中级阶段（C语言入门代码）】
王道C语言督学营oj练习（2024.3.16-持续更新中）
weixin_68700848的博客
03-18 1982
王道C语言督学营oj练习
王道C语言督学营oj练习（全部更新完成）
热门推荐
weixin_51330523的博客
04-10 3万+
王道C语言督学营oj练习及答案
王道C语言督学营OJ代码（初级中级高级）
m_use的博客
04-04 3336
2023王道C语言督学营OJ代码初中高级
王道C语言督学营oj练习附个人学习感受（持续更新ing）
qq_43498726的博客
02-23 7883
初级阶段 个人感受分享： 初级阶段比较基础，但像龙哥说的那样，即使是科班出身，也需要听课。龙哥讲课把C语言以及之后考研用到的数据结构、计算机组成原理都有融合，也带着一步一步进行进行调试，在代码运行和问题解决方面有很大的收获。 这里建议大家上完课立马去写作业进行巩固，否则会对知识有所遗忘，有条件的朋友可以多刷几次课程加深记忆与理解。 关于oj，有时候确实很烦人。但现在BAT企业以及考研复试都是使用oj系统，所以也是刚好的帮助大家适应。我也曾多次被oj折磨的痛不欲生，但在这个过程中也是有提升自己的耐心，当你听到
王道C语言督学营OJ练习全解【24考研最新版】
一个非常Cool的人
03-03 7151
本篇博客是在博主参加王道408专业课前置课程-----C语言督学营的学习笔记，包含了从第一节课到最后一节课的所有OJ习题题解，文章中每一题都给出了详尽的代码，并在每一题的关键部位加上了注释，记录下来的目的是方便自己以后进行复习，也希望能够帮助到大家，经过测试所有代码都可以通过王道OJ网站给出的样例，如果还有什么疑问的话评论区留言吧！（tips:网站上的样例比较简单，可能刷刷小聪明也可以通过，但是我建议大家还是按照要求来最好，毕竟是要锻炼自己的能力，投机取巧也不好！如果是感觉非常没有必要的能省则省。）
端午赠送粽子名单以及原力奖牌名单已出炉
CSDN 官方博客
06-16 5552
上榜名单请上榜博主尽快。
Java自学方法和路线，我万字推荐你这样学
<sdffdsfsdfdfs>sfsfsfsdfsdffds</sdfsDS>Fsd
09-29 2387
????????关注后回复“进群”，拉你进程序员交流群????????作者丨bigsai来源丨bigsai前言篇大家好，我是bigsai好久不见，甚是想念，文章同时收录在回车课堂(文底阅读原文可达)。无论你...
C语言oj题答案2017-10-11.rar_C语言_c语言oj题_swust oj第10题_swustoj613答案_西南大学
09-20
《C语言oj题答案2017-10-11》这个压缩包文件主要包含了在西南大学（SWUST）在线判题系统（oj）上完成的C语言编程实验题目解答。C语言作为一门基础且重要的编程语言，是计算机科学教育中的核心课程，尤其对于学习算法...
华为OJ中级，Java部分_Huawei-OJ-JAVA-Middle.zip
09-02
华为OJ中级，Java部分的资源包，具体而言，是为Java开发者量身定制的一套学习材料。该资源包的设计理念强调合理性，遵循模块化的设计原则，这不仅有利于知识点的划分，还便于今后的扩展和维护。代码中的注释风格统一...
程序设计竞赛-在线判题系统（OJ系统）【含Web端+判题端】+项目源码+文档说明
11-18
<项目介绍> - 核心技术 前端：bootstrap4+vue+thymeleaf 后端：springboot+mybaits+springsecurity+springsession 数据库：mysql+redis 服务器：tomcat+nginx 消息队列：rocketMQ - 不懂运行，下载完可以私聊问，可...
OJ系统汇总-2021-10-5.pdf
10-05
不同的OJ系统有其差异和优缺点，例如Openjudge和Poj的服务器稳定性不同，洛谷和计蒜客的判题速度不同等。 7. OJ系统在信息学奥赛和编程比赛中的应用 OJ系统在信息学奥赛和编程比赛中起着非常重要的作用，可以帮助...
王道 OJ Online Judge 中级-day6作业
fredvioce的博客
03-10 2048
目录代码使用纯 C 语言编码链接中级-day6作业DescriptionInputOutput输入输出样例注意点AC代码 代码使用纯 C 语言编码 链接 http://oj.lgwenda.com/problem/19 中级-day6作业 Description 新建一个栈，读取标准输入3个整数3 4 5，入栈3 4 5，依次出栈，打印 5 4 3，新建循环队列（Maxsize为5），读取标准输入3 4 5 6 7，入队7时，队满，打印false，然后依次出队，输出 3 4 5 6 Input 读取标准输入
算法 --- BFS 解决最短路问题
Small_entreprene的博客
09-20 395
BFS算法是解决无权图最短路径问题的有效方法，适用于网格迷宫、单词接龙等场景。其核心优势在于"一圈一圈"扩散的特性，确保首次访问即为最短路径。文章提供了BFS的通用代码模板，并通过力扣例题（如迷宫出口、基因变化、高尔夫砍树等）展示了具体实现。关键点在于状态表示清晰、转移明确，适用于所有边权重相同的图结构。对于加权图，则需使用Dijkstra等其他算法。
GRPO算法复现
TeenLucifer的博客
09-18 934
GRPO算法在qwen2.5-1.5B-Instruct模型上的复现，包含全量和LoRA微调两种方式，并通过deepspeed分布式训练框架实现
随机梯度下降（SGD）算法及其在机器学习中的应用
最新发布
MoRanzhi1203的博客
09-20 736
随机梯度下降（SGD）是一种高效的优化方法，适用于大规模数据的回归和分类任务。本文介绍了 SGD 的算法原理、数学模型、实现流程及参数解析，并通过 Python `scikit-learn` 案例展示其在回归（加州房价预测）与分类（鸢尾花分类）中的应用与可视化效果。
数据结构 静态链表的实现(算法篇)
2401_88465894的博客
09-19 803
本文系统介绍了静态链表的实现原理和操作，重点讲解了单链表和双向链表的静态数组实现方法。主要内容包括：1. 静态链表的核心组件：使用数组e[N]存储数据，ne[N]存储后继节点下标，通过下标id分配新节点位置；2. 单链表操作实现：详细说明了头插、遍历、按值查找、任意位置插入和删除等操作的O(1)实现方法；3. 双向链表扩展：在单链表基础上增加pre[N]数组实现前驱指针，支持双向遍历和前向插入操作；4. 性能优化技巧：引入mp数组实现O(1)时间复杂度的按值查找，体现空间换时间的优化思想；5. 实际应用建议
C++优选算法精选100道编程题（附有图解和源码）
铭哥不写bug的博客
09-20 478
《C++优选算法精选100道编程题》专题一双指针部分提供了5个典型问题的详细解析和代码实现：1. 移动零问题使用双指针原地操作将零移到数组末尾；2. 复写零问题通过逆向思维避免覆盖原数据；3. 快乐数问题利用快慢指针检测循环；4. 盛水容器问题采用对撞指针求最大容量；5. 有效三角形个数通过排序和双指针优化三重循环。每个问题都配有直观图解、分步分析和完整C++源码，特别适合算法学习者掌握双指针技巧。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值