05.C语言学习3.0

已于 2023-08-15 14:49:37 修改
阅读量75 收藏
点赞数
文章标签： c语言 学习 算法
于 2023-08-08 16:35:35 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45849140/article/details/132170221
版权

05、C语言3.0

1、排序

1、冒泡排序

遍历原始数据，从第一个数开始，到倒数第二个数结束，比较这个数和下一个数的大小，如果这个数比下一个数大，则交换这两个数。这样便可以将数据中最大的数转移到数组的最后。

之后再次遍历原始数据，但是变为从第一个数开始，到倒数第三个数结束，比较这个数和下一个数的大小，如果这个数比下一个数大，则交换这两个数。这样便可以将第二大的数转移到数组的倒数第二位。
重复执行上述过程，一直到从第一个数开始，到第二个数结束，从而完成了排序过程。

#include<stdio.h>
#define ArrayLen(a) sizeof(a)/sizeof(a[0])
int bublle(int *a,int len)
{
    int temp;
    for(int i=0;i<len-1;i++)
    {
        int flag=0;//设置标志位
        for(int j=0;j<len-i-1;j++)
        {
            if(a[j]>[j+1])//当前面一个数大于后面一个数，交换他们的位子
            {
                temp=a[j];
                a[j]=a[j+1];
                a[j+1]=temp;
                flag=1;
            }
        }
        if(flag == 0)
        {
            break;
        }
    }
}
int main()
{
    int a[]={3,1,4,7,5};
    bulle(a,ArrayLen(a));
    for(int i=0;i<ArrayLen(a);i++)
    {
        printf("%d\t",a[i]);
    }
    return 0;
}//时间复杂度为:o(n^2)

优化冒泡排序：借用回调函数指定相关规则使得冒泡排序可以由自己随意选择顺序还是逆序

#include<stdio.h>
#define Arraylen(a) sizeof(a)/sizeof(a[0])//返回数组长度
int IsSmaller(int a,int b)
{
    if(a<b)
        return 1;
    else
        return 0;
}
int IsBigger(int a,int b)
{
    if(a>b)
        return 0;
    else
        return 1;
}
int BublleSort(int *a,int len,int (*rule)(int,int))
{
    int temp;
    for(int i=0;i<len-1;i++)
    {
        int flag = 0;//设置标记位检查看是否有数据未发生交换，为0则没有交换，为1则发生了交换
        for(int j=0;j<len-i-1;j++)
        {
            if(rule(a[j],a[j+1]))//使用回调函数，由使用者自行决定要选择逆序还是顺序输出
            {
                temp = a[j+1];
                a[j+1] = a[j];
                a[j] = temp;
                flag = 1;
            }
        }
        if(flag == 0)
        {
            break;
        }
    }
}
int main()
{
    int a[]={2,4,6,3,1,9,5,7,8};
    BublleSort(a,Arraylen(a),IsSmaller);
    for(int i=0;i<Arraylen(a);i++)
    {
        printf("%d\t",a[i]);
    }
    printf("\n");
    return 0;
}

2、插入排序

适用于：基本有序的数列

插入排序的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。插入排序在实现上，通常采用in-place排序（即只需用到O(1)的额外空间的排序），因而在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间。

#include<stdio.h>
#define ArrayLen(a) sizeof(a)/sizeof(a[0])
void InsertSort(int *a,int len)
{
    for(int i=1;i<len;i++)
    {
        int temp=a[i];
        int j=0;
        for(j=i-1;j>=0;j--)
        {
            if(a[j]<a[j+1])
            {
                a[j+1]=a[j];
            }
            else
            {
                break;
            }
        }
        a[j+1]=temp;
    }
}

int main()
{
    int a[]={4,2,1,6,3};
    InsertSort(a,ArrayLen(a));
    for(int i=0;i<ArrayLen(a);i++)
    {
        printf("%d\t",a[i]);
    }
    return 0;
}

3、选择排序

工作原理：第一次从待排序的数据元素中选择出最小或者最大的一个元素，存放在序列的起始位置；然后再从剩余的未排序元素中寻找到最小或者最大的元素，然后放到未排序序列的起始位置；重复该步骤直至序列完全结束。

#include<stdio.h>
#define Arraylen(a) sizeof(a)/sizeof(a[0])
void ChooseSort(int *a,int len)
{
    if(len=0||len=1)
        return ;
    for(int i=0;i<len;i++)
    {
        int min=i;
        int minum = a[min];
        for(int j=i+1;j<len;j++)
        {
            if(a[j]<a[min])
            {
                minum = a[j];
                min = j;
            }
        }
        int temp = a[i];
        a[i] = a[min];
        a[min] = temp;
    }
}
int main()
{
    int a[]={1,4,3,8,2,5,6};
    ChooseSort(a,Arraylen(a));
    return 0;
}

4、快速排序

一种原地排序，只需要一个很小的栈作为辅助空间，空间复杂度为O(logN)，所以适合在数据集比较大且无序的时候使用。

算法思想：

① 从数列中挑出一个元素，称为 “基准”（pivot），
② 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作。
③ 递归地把小于基准值元素的子数列和大于基准值元素的子数列排序。

算法实现：

#include<stdio.h>
#define Arraylen(a) sizeof(a)/sizeof(a[0])
void QuickSort(int *a,int start,int end)
{
    int temp=a[start];
    int left=start;
    int right=end;
    while(left<right)
    {
        while(left<right&&a[right]>temp)//找到右边比基准值小的那个数停
        {
            right--;
        }
        if(left<right)
        {
            a[left]=a[right];
            left++;
        }
        while(left<right&&a[left]<temp)//找到左边比基准值大的那个数停
        {
            left++;
        }
        if(left<right)
        {
            a[right]=a[left];
            right--;
        }
        a[left]=temp;
        QuickSort(a,start,left-1);
        QuickSort(a,right+1,end);
    }
}
int main()
{
    int a[] = {5, 3, 9, 2, 0 ,4, 6};
    QuickSort(a,Arraylen(a));
    return 0;
}

方法二:

void fastSort(int *a,int start,int end)
{
    if(start>end)
        return ;
    int temp=a[start];
    int i=start;
    int j=end;
    while(i!=j)
    {
        while(i<j&&a[j]>=temp)
            j--;
        while(i<j&&a[i]<=temp)
            i++;
        if(j>i)
        {
            int t=a[i];
            a[i]=a[j];
            a[j]=t;
        }
    }
    a[start]=a[i];
    a[i]=temp;
    FastSort(a,start,i-1);
    FastSort(a,i+1,end);
}
2、递归

递归就是指在方法的定义中使用方法自身。也就是说，递归算法是一种直接或者间接调用自身方法的算法。简言之：在定义自身的同时又出现自身的直接或间接调用。

//猴子吃桃子问题：猴子每天吃当天桃子数量的一半+1；第十天的时候只剩下一个桃子，第一天有几个桃子
#include<stdio.h>
int EatPeach(int day)
{
    if(day==10)
        return 1;
    else
        return ((EatPeach(day+1)+1)*2);
}
//求n!  n! = n * (n-1)!
int factorial(int n)
{
    if(n==1 || n==0)
        return 1;
    else
        return n*factorial(n-1);
}
//计算字符串长度
int MystrLen(char *s)
{
    if(*s == '\0')
        return 0;
    else
        return (MystrLen(s+1)+1);
}
int main()
{
    printf("%d\n",MystrLen("helloworld"));
    printf("%d\n",factorial(10));
    printf("%d\n",EatPeach(8));
    return 0;
}
3、二维数组

1、二维数组定义：

多个一维数组的集合；int a[ ][ ]={{1,2,3},{3,4,5}};

2、二维数组的初始化：

必须初始化列数（步长），否则出错

eg：int a[][]={1,2,3,4,5,6};int a[2][]={1,2,3,4,5,6} 都出错

3、相关概念

a：首行的地址 a+1：代表跨一行地址 和a[0]相同

&a：整个数组的首地址 &a+1：跨一整数组的长度

&a[0]：取首行地址 &a[0]+1：跨一行的地址

&a[0] [0] ：首个元素的地址 &a[0] [0]+1：跨一个元素的地址

#include<stdio.h>
int main()
{
    int a[2][3] ={{1,2,3},{4,5,6}};
    int b[2][3] ={1,2,3,4,5,6};
    for(int i=0;i<2;i++)
    {
         for(int j=0;j<3;j++)
         {
             printf("%x ",&a[i][j]);
         }
         printf("\n");
    }
    printf("%X %x %x %x\n",a,&a,&a[0],&a[0][0]);//输出相同地址
    printf("%X %x %x %x\n",a+1,&a+1,&a[0]+1,&a[0][0]+1);
    printf("%d",*((*a)+1));
    return 0;
}//*(*(a+i)+j)相当于a[i][j];

int (*p)[3] 数组指针：一个指向一个有三个int的数组的指针。和数组本身的指针表示一样；p+1表示跨一行既是12个字节。是一个二级指针，指向一个数组，* *代表取值。

int * p[3] 指针数组：这个数组里有三个指针，p+1跨一个元素，但是整个指针数组里的元素都是指针，所以跨一个元素就是一个指针的大小8个字节；

int a[5][5]={0};
int (*p)[5] = a;
printf("%x\n",p);
printf("%x\n",p+1);//输出为1707b650 1707b664跨越20个字节长度

int *p[5]=a;
printf("%x\n",p);//指针数组首元素的地址 *p代表p[0],p[0]是指向a首行的地址，**p代表取值
printf("%x\n",p+1);//输出为63b35340 63b35348跨越8个字节长度

二维数组的应用：

  • 1、杨辉三角：（a+b)^n 展开式项前面的系数

​ 1 1

​ 1 1 1 1

​ 1 2 1 ----------> 1 2 1

​ 1 3 3 1 1 3 3 1

1 4 6 4 1 1 4 4 6 1

#include<sdtio.h>
#define Size 10
int main()
{
	int a[Size][Size]={0};
    for(int i=0;i<Size;i++)
    {
        a[i][0]=1;
        a[i][i]=1;
    }
    for(int i=2;i<Size;i++)
    {
        for(int j=1;j<i;j++)
        {
            a[i][j]=a[i-1][j-1]+a[i-1][j];
        }
    }
    for(int i=0;i<Size;i++)//输出杨辉三角
    {
        for(int j=0;j<Size-i;j++)
        {
            printf("   ");
        }
        for(int j=0;j<=i;j++)
        {
            printf("%5d",a[i][j]);
		}
        printf("\n");
    }
    printf("\n");
    return 0;
}
  • 2、设置“井”字棋游戏
#include<stdio.h>
#define Size 3
#define true 1
#define false 0
//初始化二维数组的每一个元素
void InitBoard(char (*Board)[Size])
{
    for(int i=0;i<Size;i++)
    {
        for(int j=0;j<Size;j++)
        {
            Board[i][j]=' ';
        }
    }
}
//输出棋盘
void PrintBoard(char (*Board)[Size])
{
    printf("\n");
    for(int i=0;i<Size;i++)
    {
        for(int j=0;j<Size;j++)
        {
            printf(" %c ",a[i][j]);
            if(j!=Size-1)
                printf("|");
        }
        printf("\n");
        if(i!=Size-1)
            printf("---|---|---");	
    }
    printf("\n");
}
//判断下棋的位置是否合法，合法则输出
int Makemove(char (*Board)[Size],int row,int column,char player)
{
    if(row <0 ||row >=Size ||column <0||column >=Size)
    {
        printf("Illegal place!please try again!\n");
		return false;
    }    
    if(Board[row][column]!=' ')
    {
        printf("The place has been ocupied!please try again!\n");
		return false;
    }
    Board[row][column]=player;
    return true;
}
//判断赢棋的条件
int CheckisWin(char (*Board)[Size],char player)
{
    for(int i=0;i<size;i++)
    {
        if(Board[i][0]==player&&Board[i][1]==player&&Board[i][2]==player)
            return true;
    }
    for(int i=0;i<size;i++)
    {
        if(Board[0][i]==player&&Board[1][i]==player&&Board[2][i]==player)
            return true;
    }
    if(Board[0][0]==player&&Board[1][1]==player&&Board[2][2]==player)
    	return true;
    if(Board[0][2]==player&&Board[1][1]==player&&Board[2][0]==player)
    	return true;
}
//判断是否平局
int CheckisDraw(char (*Board)[Size])
{
    for(int i=0;i<Size;i++)
    {
        for(int j=0;j<Size;j++)
        {
            if(Board[i][j]==' ')
                return false;
        }
    }
    return true;
}
int main()
{
    char Board[Size][Size]={0};
    InitBoard(Board);
    
    char player='X';
    while(1)
    {
        PrintBoard(Board);
        printf("Player %c please enter your mark:",player);
        int row=0,column=0;
        scanf("%d %d",&row,&column);
        if(Makemove(Board,row-1,column-1,player)==false)
        {
            continue;
        }
        if(CheckisWin(Board,player)==true)
        {
            PrintBorad(Board);
            printf("Player %c wins!Congratulations!\n",player);
            break;
        }
        if(CheckisDraw(Borad)==true)
        {
            PrintBorad(Board);
            printf("The result is Draw！Game Over！\n");
            break;
        }
        player = (player == 'X')?'X':'O';
    }
    return 0;
}
  • 3、完成五子棋游戏
#include<stdio.h>
#define Size 15
#define true 1
#define false 0
//初始化棋盘内容
void InitBoard(char (*Board)[Size])
{
	for(int i=0;i<Size;i++)
    {
        for(int j=0;j<Size;j++)
        {
            Board[i][j]='-';
        }
    }
}
void PrintBoard(char (*Board)[Size])
{
    printf("  ");
    for(int i=0;i<Size;i++)
    {
        printf("  %2d ",i+1);
    }
    printf("\n");
    for(int i=0;i<Size;i++)
    {
        printf("%2d ",i+1);
        for(int j=0;j<Size;j++)
        {
            printf("  %c  ",Board[i][j]);
        }
        printf("\n");
    }
    printf("\n");
}
int MakeMove(char (*Board)[Size],int row,int column,char player)
{
    if(row <0 || row >= Size || column <0 ||column >= Size)
    {
        printf("Illegal place!please try again!\n");
        return false;
    }
    if(Board[row][column] != '-')
    {
        printf("This place has been ocupied!try again!\n");
        return false;
    }
    Board[row][column] = player;
    return true;
}
int CheckisWin(char (*Board)[Size],int row,int column,char player)
{
    int direction[4][2] = 
    {
        {1,0},
        {0,1},
        {1,1},
        {-1,1}
    };
    for(int i=0;i<4;i++)
    {
        int count = 1;
        int dx = row + direction[i][0];
        int dy = column + direction[i][1];

        while(dx >=0 && dx < Size && dy >= 0 && dy < Size && Board[dx][dy]==player)
        {
            count++;
            dx = dx + direction[i][0];
            dy = dy + direction[i][1];
        }
        dx = row - direction[i][0];
        dy = column - direction[i][1];
        while(dx >=0 && dx < Size && dy >= 0 && dy < Size && Board[dx][dy]==player)
        {
            count++;
            dx = dx - direction[i][0];
            dy = dy - direction[i][1];
        }
        if(count >= 5)
        {
            return true;
        }
    }
    return false;
}
int CheckIsDraw(char (*Board)[Size])
{
    for(int i=0;i<Size;i++)
    {
        for(int j=0;j<Size;j++)
        {
            if(Board[i][j] == '-')
                return false;
        }
    }
    return true;
}
int main()
{
    char Board[Size][Size]={0};
    InitBoard(Board);
    char player = 'X';

    while(1)
    {
        PrintBoard(Board);
        printf("Player %c please enter your mark:",player);
        int row=0,column=0;
        scanf("%d %d",&row,&column);
        if(MakeMove(Board,row-1,column-1,player)==false)
        {
            continue;//跳过当次循环
        }
        if(CheckisWin(Board,row-1,column-1,player)==true)
        {
            PrintBoard(Board);
            printf("Player %c wins!\n",player);
            break;
        }
        if(CheckIsDraw(Board)==true)
        {
            PrintBoard(Board);
            printf("The result is Draw!Game Over!\n");
            break;
        }    
        player = (player == 'X')? 'O' : 'X';
    }
    return 0;
}
4、二级指针

指向指针的指针，跨一个代表跨一个数组的长度，需要两个*进行取值。

一级指针跨一个代表跨一个元素的大小；一个*取值

#include<stdio.h>
int main()
{
    int a=10;
    int *ptr = &a;
    int **ptr2 = &ptr;
    printf("%d ",**ptr2);;
    return 0;
}

当设置一个一级指针p指向一个二维数组时，因为二维数组在内存中以一维数组的形式存储，所以当设置一个一级指针对其取值时，p++就是跨一个指针类型的长度。

#include<stdio.h>
int main()
{
    int a[2][3] = {1,2,3,4,5,6};
    
    int *p=&a[0];//p是一个一级指针，指向数组元素首地址
    p++;//跨4个字节，数组一个元素的大小
    printf("%d\n",*p);//2
    
    int (*q)[3] = a;//数组指针，二级指针，指向a数组的首地址
    q++;//跨12字节一整数组的长度
    printf("%x\n",*q);//输出为a[4]的地址，想要取值就是*(*(p+i)+j)取a[i][j]
    
    int (*w)[3]=&a[0][0];//数值指针，二级指针，指向a数组首元素的地址
    printf("%d\n",**w);//对他取值：结果为1
    
    int *p1[3];//指针数组，里面每一个元素都是一个一级指针,p1代表指针数组的首地址
    *(p1+1) = a[1];//p1+1代表指向a[1]这一行，把a[1]的地址给p1[1]
	printf("%d\n",*p1[1]);//对a[1]这一行的首元素取值为4
    return 0;
}

相关测试题：

a) 一个整型数 int a;

b)一个指向整数型的指针 int *a;

c)一个指向指针的指针，它指向的指针是指向一个整型数 int **a;

d)一个有10个整型数的数组 int a[10];

e)一个有10个指针的数组，该指针是指向一个整型数 int *a[10];

f)一个指向有10个整型数数组的指针 int (*a)[10];

g)一个指向函数的指针，该函数有一个整型参数并返回一个整型数 int (*p)(int)

h)一个有10个指针的数组，该指针指向一个函数，该函数有一个整型参数并返回一个整型数 int (*a[10])(int)函数指针数组

i) int ((*(*complexFunctionPointerArray)[5]))(char*,double);指向函数指针数组的指针

j) char * (*(*complexFunctionPointerArray)(int,int))[10];指向函数指针的指针数组

5、main函数

main函数，又称主函数，作为绝大部分C程序唯一的入口，是要求有返回值的，该返回值返回给（如操作系统）来表明该程序的执行状况。返回0代表程序正常执行成功，返回非0值代表程序异常结束，因此返回值需要是int整型，于是有了int main()的规范。

int main(int argc,char *argv[])

  1. 参数
  • void：不接受任何参数；
  • argc：代表程序所运行环境传递给程序的参数数量；
  • argv：指向argc+1个指针的数组的首元素的指针。数组末元素为空指针，而若前面有元素，则它们指向表示从宿主环境传递给程序的参数的字符串。若argv[0]不是空指针（或argc>0），则它指向表示程序名的字符串。若程序名从宿主环境不可用则该字符串为空。
#include<stdio.h>
#include<string.h>
#define true 1
#define false 0
typedef char* CharPiont;

int login(CharPoint (*str)[2],const char *account,const char *password)
{
    if(strcmp(account,"admin")==0)//字符串比较，匹配超级用户账号
    {
        if(strcmp(password,"123456") == 0)
        {
            printf("welcome!admin!\n");
            return true;
        }
    }
    for(int i=0;i<3;i++)//从第一行的用户开始
    {
        if(strcmp(str[i][0],account)==0)//匹配相应的账号
        {
            if(strcmp(str[i][1],password)==0)//匹配相应的密码
            {
                printf("welcome!\n");
                return true;
            }
        }
    }
    return false;
}

void SignUp(CharPoint (*str)[2],counst char *account,const char *password)
{
    for(int i=0;i<4;i++)
    {
        if(strcmp(str[i][0],"")==0)
        {
            str[i][0] = account;
            str[i][1] = password;
        }
	}
}

int main(int argc,char *argv[])
{
    char *account[3][2]=
    {
        {"zhangsan","1"},
        {"lisi","2"},
        {"wangwu","3"}
    };//存储其他用户账号，密码
    if(argc !=3)//传入命令参数的数量，其中./admin也代表了一个数量
    {
        printf("invalid input number!\n");
        return 0;
    }
    SignUp(account,argv[1],argv[2]);
    
    if(login(account,argv[1],argv[2])==false)//调用login函数判断输入的账号密码是否正确
    {
        printf("account or password error!please input again!\n");
    }
    for(int i=0;i<4;i++)
    {
        for(int j=0;j<2;j++)
        {
            printf("%s ",account[i][j]);//输出账号和密码
        }
        printf("\n");
    }
    printf("\n");
    return 0;
}
//使用./1 admin 123456输出welcome!admin!
//使用./1 zhangsan 1输出welcome!
疏影月楼台
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
学习c语言 基本数据类型
qq_45964035的博客
08-11 490
c语言
C语言学习系统 v3.0
03-27
《C语言学习系统 v3.0》是一款专为C语言初学者及进阶者设计的教育软件，旨在提供全面、系统的学习资源与实践环境。该系统涵盖了C语言的基础语法、控制结构、函数、指针、内存管理等多个核心知识点，帮助用户深入理解...
C语言学习笔记（六） | 详解操作符
KYG__U_O的博客
08-21 656
操作符 分类： 算术操作符 移位操作符 位操作符 赋值操作符 单目操作符 关系操作符 逻辑操作符 条件操作符 逗号表达式 下标引用、函数调用和结构成员 算术操作符 + - * / % 1. 除了 % 操作符之外，其他的几个操作符可以作用于整数和浮点数。 2. 对于 / 操作符如果两个操作数都为整数，执行整数除法。而只要有浮点数执行的就是浮点数除 法。 3. % 操作符的两个操作数必须为整数。返回的是整除之后的余数。 int main() { ...
C语言变量篇3.0
m0_74461402的博客
11-05 842
求平均值 ●写一个程序，输入两个整数，输出它们的平均值 int a , b ; scanf ("% d % d ",& a ,& b ); double c =( a + b )/2.0; printf ("% d 和％ d 的平均值＝% f \ n ", a , b , c ); 运算符优先级 赋值运算符 ●赋值也是运算，也有结果 ● a =6的结果是 a 被赋予的值，也就是6● a = b =6一＞ a =( b =6) “嵌入式赋值” int a =6; in
C语言迷宫游戏设计3.0
2302_77441595的博客
06-04 596
1、基于C语言的简单迷宫游戏设计 2、界面升级、图形优化、增设时间、生命值、计分 3、玩家可以通过W(上)S(下)A(左)D(右)控制小圆圈走出迷宫通关游戏 4、3.0版本唯一的缺点就是频闪过于严重，原因是显示器的刷新频率与图像帧率不同步造成的，基于gpt4.0提供的解决方案就是开辟两个缓冲区一个绘图一个显示图像！还在学习中，这个bug有望在后续版本中解决
C语言学习——指针
weixin_47306453的博客
08-17 825
指针是一个变量，用来存放地址，地址唯一标识一块内存空间。指针的大小是固定的4/8个字节。指针有类型，指针的类型决定了指针的±整数的步长，指针解引用的操作时候的权限。
C语言入门基础知识【完整版】
热门推荐
面对疾风吧，哈撒给！
12-02 3万+
C语言入门基础知识整理，快速入门~
c语言学习宝典怎么样,C语言学习宝典
weixin_36298476的博客
05-24 387
《C语言学习宝典》是一款专为c语言学习者打造的学习软件。软件包含各个阶段的C语言课程，无论你是C语言初学者还是有一定基础的学习者，这款软件都可以帮助你快速的掌握学习技巧，快速学会C语言。软件详情C语言学习宝典收集了C语言学习各阶段知识，内容包含C语言课程的全部章节内容，并有C语言经典算法和C语言章节练习题。同时含有计算机二级公共知识以及二级C语言章节考点。能够提高C语言二级考试成绩、增强C语言自学...
c语言扫雷游戏代码学习
qq_45417760的博客
06-28 2012
c语言模拟实现扫雷游戏
C语言入门学习
m0_73787492的博客
10-31 96
计算平均分
c语言学习打卡第二天
weixin_68131472的博客
03-16 885
运用while（）循环语句计算多个不同鞋码对应的脚长 #include<stdio.h> #define ADJUST 7.31 int main(void) { const double SCALE = 0.333; double shoe, foot; printf("shoe size (men's) foot length\n"); shoe = 3.0; while (shoe < 18.5) { foot = SCALE * shoe +
c语言tp3.0
01-24
本文将详细介绍TP3.0的特点、功能及其在C语言学习中的应用。 一、TP3.0简介 TP3.0是由Borland公司推出的C++编译器，它以其小巧的体积、快速的编译速度和友好的用户界面，成为80年代末至90年代初程序员的首选工具。...
c语言学习第9章完整.pptx
11-14
在C语言的学习中，第9章主要探讨了预处理指令，这是编程过程中的一个重要环节，它在实际编译之前对源代码进行处理。预处理指令主要包括宏定义、文件包含和条件编译三个部分。 首先，宏定义是C语言中预处理的一种...
C语言学习笔记
08-04
### C语言学习笔记知识点梳理 #### 一、程序设计流程 1. **确定数据结构**：根据问题的需求选择合适的数据类型和数据结构。 2. **确定算法**：设计解决问题的具体步骤，确保算法满足以下特性： - **有穷性**：算法...
tc3.0编译程序 c语言学习必备
01-16
这个压缩包文件包含了一系列与TC3.0相关的资源，对于想要学习或重温C语言的人来说是一份宝贵的学习材料。 1. **CMDLINE.CA1、CMDLINE.CA2**： 这些文件可能包含了Turbo C++ 3.0命令行界面的配置或组件。在没有图形...
C语言：求最大数不用数组
weixin_55021541的博客
08-08 145
输入一批正数用空格隔开，个数不限，输入0时结束循环，并且输出这批整数的最大值。
C语言—水手分椰子问题
最新发布
2301_80163571的博客
08-08 237
【代码】C语言—水手分椰子问题。
东方博宜24年8月-C组 - 屋顶
kuaidihezi的博客
08-06 552
小 A 在奥运会期间，前往巴黎观看奥运会的相关赛事。在某项体育比赛中，他被场馆的屋顶吸引了，这个屋顶不同于普通的屋顶，在平坦的屋顶上，设计师使用特殊材料制作的边长为 1 米正方体，设计出了各种造型。由于正方体的高矮不一，下雨时，屋顶会有一定的积水，这些积水会被保留在屋顶，用于场馆内的绿植灌溉。下图给出了一个宽度为 8 的屋顶的截面图。在截面图中，我们可以看到，白色的方块是特殊材料制作的正方体，蓝色矩形，是下雨后，屋顶上的积水区域。图中积水区域的总面积为 9 平方米。
C语言——预处理和指针
attitude_lu的博客
08-05 1437
宏定义的语法形式：#define 标识符 字符串或者是#define 宏名 宏值预处理命令都是以#开头的例如：#define n 10注意在定义宏时在宏值后面是不可以加分号的如果加了分号在预处理进行文本替换的时候会一并把分号一起替换了，比如说我在定义#define N 10的后面加上分号可以看到在进行预处理时N会被替换成10;
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值