4.数组dddd

最新推荐文章于 2022-06-27 09:29:05 发布
最新推荐文章于 2022-06-27 09:29:05 发布
阅读量549 收藏
点赞数
分类专栏： C 文章标签： c语言 排序算法 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a2076188013/article/details/122457536
版权

文章目录

一维数组创建和初始化

数组创建

数组:一组相同类型的集合
type_t arr_name [const_n];
C99标准之前是不支持使用变量的,只能是常量
C99中增加了变长数组的概念,允许数组的大小是变量
要求编译器支持C99标准,但常见的编译器(VS)对C99支持不够好
Linux - Centos 7 gcc编译器
image-20220110223102573

char arr3[10];
float arr4[1];
double arr5[20];

数组初始化

int arr1[10] = {1,2,3};
//不完全初始化,剩余元素默认为0
int arr2[] = {1,2,3,4};
int arr3[5] = {1，2，3，4，5}；
char arr4[3] = {'a',98, 'c'};
//98 是 'b'的ASCII值
char arr5[] = {'a','b','c'};//数组大小3个字节
char arr6[] = "abc";//还有一个\0
//数组大小4个字节

image-20220110223757978

sizeof与strlen

char arr1[] = {‘a’,‘b’,‘c’};
char arr2[] = “abc”;
arr2中放的是abc’\0’

char arr1[] = { 'a', 'b', 'c' };
//arr1有3个元素，数组的大小是3个字节
printf("%d\n", sizeof(arr1));
printf("%d\n", strlen(arr1));//随机值

char arr2[] = "abc";//a b c \0
//arr2有4个元素，数组的大小是4个字节
printf("%d\n", sizeof(arr2));
printf("%d\n", strlen(arr2));//3

sizeof是操作符,计算变量所占空间大小,任何类型都相同
不在乎内存中是否存在\0
strlen是函数,只针对字符串,计算字符串长度,遇到\0停止
不包括\0
数组如果不初始化,那么就会被赋为随机值,不可控

char acX[] = “abcdefg”;
char acY[] = {‘a’,’b’,’c’,’d’,’e’,’f’,’g’};

数组acX长度大于数组acY长度
但如果问字符串acX长度与字符串acY长度比较 则不能确定
因为acY后面没有\0 strlen遇到\0才会停止故求出来的是随机值

一维数组的使用

[] 下标引用操作符

#include <stdio.h>
int main()
{
int arr[10] = {0};//数组的不完全初始化
   //计算数组的元素个数
   int sz = sizeof(arr)/sizeof(arr[0]);
//对数组内容赋值,数组是使用下标来访问的，下标从0开始。所以：
int i = 0;//做下标
for(i=0; i<10; i++)//这里写10，好不好？
{
arr[i] = i;
}
//输出数组的内容
for(i=0; i<10; ++i)
{
printf("%d ", arr[i]);
}
return 0;
}

//计算数组元素个数:
int arr[10];
int sz = sizeof(arr)/sizeof(arr[0]);
//40 / 4 = 10

一维数组在内存中的存储

int main()
{
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
int* p = &arr[0];
 //打印数组每个元素的地址
int i = 0;
for (i = 0; i < 10; i++)
  {
	printf("&arr[%d] = %p\n", i, &arr[i]);
	printf("%p\n", p + i);//p+i 是数组中arr[i]的地址
	printf("%p ----- %p\n", p + i, &arr[i]);
	printf("%d ", * (p + i));//1 2 3 4 5 6 7 8 9 10
  }
    //整型指针,+1跳过一个整型元素
return 0;
}

image-20220110225156519

0x0c表示十进制的12
p+i 与&arr[i] 等价

二维数组

二维数组创建

int arr[3][4]; //三行四列,每个元素是int型
char arr[3][5];
double arr[2][4];

其实就是数学里的矩阵

二维数组初始化

int arr[3][4] = { {1,2},{3,4},{5,6} };
//不完全初始化
//1 2 0 0
//3 4 0 0
//5 6 0 0
//二维数组初始化不能省略列,行可以省略

image-20220110225843442

#include<stdio.h>
int main()
{
       int arr[3][4] = { {1,2},{2,2},{3,3,3} };
       int arr[][4] = { 1,2,3,4,5,6,7,8,9,10,11,12 };
       return 0;
}

二维数组使用与存储

#include<stdio.h>
int main()
{
       int arr[3][4] = { 1,2,3,4,5,6,7,8,9,10,11,12 };
       int i = 0;
       int j = 0;
       for (i = 0; i < 3; i++)
       {
               for (j = 0; j < 4; j++)
               {
                      printf("&arr[%d][%d] = %p\n", i, j, &arr[i][j]);
               }
       }
       for (i = 0; i < 3; i++)
       {
               for (j = 0; j < 4; j++)
               {
                      printf("arr[%d][%d] = %d\n", i, j, arr[i][j]);
               }
       }
       return 0;
}

二维数组理解为一维数组的数组

在内存中是连续储存的,第二行紧跟着第一行
每一行是一个一维数组
以为是这样存储,但实际是连续存储
image-20220110230226081

数组越界

数组的下标如果小于0，或者大于n-1，就是数组越界访了，超出了数组合法空间的访问。
C语言本身是不做数组下标的越界检查，编译器也不一定报错，但是编译器不报错，并不意味着程序就是正确的，
所以程序员写代码时，最好自己做越界的检查。

数组前面后面还是有空间的

#include <stdio.h>
int main()
{
int arr[10] = {1,2,3,4,5,6,7,8,9,10};
   int i = 0;
   for(i=0; i<=10; i++)
  {
       printf("%d\n", arr[i]);//当i等于10的时候，越界访问了
  }
return 0;
}

1
2
3
4
5
6
7
8
9
10
-858993460
数组越界,程序已经错了,但并没有报错,编译器能力有限,有时候识别不出来越界
image-20220111110819712

c语言支持多维数组,但是比较少用

数组作为函数参数

冒泡排序

核心思想:
两两相邻元素进行比较,如果有肯能需要交换

一趟冒泡排序搞定一个数字
让当前待排序数组中的一个元素来到最终应该出现的位置上
10个元素,9躺冒泡排序
image-20220111111334042

#include <stdio.h>
//void bubble_sort(int* arr,int sz) 这样写也可以 
//指针大小是4,不能在函数内算数组元素个数
void bubble_sort(int arr[], int sz)
{
       int i = 0;
       for (i = 0; i < sz - 1; i++)
       {
               //一趟冒泡排序的过程
               int j = 0;
               //一趟冒泡排序比较的对数
               //第二趟比较8对,第三躺比较7对
               for (j = 0; j < sz - 1 - i; j++)
               {
                      if (arr[j] > arr[j + 1])
                      {
                              int tmp = arr[j];
                              arr[j] = arr[j + 1];
                              arr[j + 1] = tmp;
                      }
               }
       }
}
int main()
{
       //数组传参
       int arr[] = { 3,1,5,2,4,9,0,7,6,8 };
       //设计一个函数对arr数组进行排序-冒泡排序
       int sz = sizeof(arr) / sizeof(arr[0]);
       bubble_sort(arr, sz);//数组名代表的就是数组
       //数组传参,实际上传过去的不是整个数组,传过去的是数组首元素地址
       //避免空间浪费,只需要传首元素地址,就能依据地址找到所有元素
       int i = 0;
       for (i = 0; i < 10; i++)
       {
               printf("%d ", arr[i]);
       }
       return 0;
}

数组名是什么?

补充：

  1. sizeof(数组名)，计算整个数组的大小，sizeof内部单独放一个数组名，数组名表示整个数
    组。
  2. &数组名，取出的是整个数组的地址。&数组名，数组名表示整个数组。
#include <stdio.h>
int main()
{
       int arr[] = { 1,2,3,4,5 };
       printf("%p\n", arr);//00AFF92C
       printf("%p\n", &arr[0]);//00AFF92C
       printf("%p\n", &arr);//00AFF92C
       printf("%d\n", sizeof(arr));//20
       printf("%p\n", arr+1);//00AFF930
       printf("%p\n", &arr[0]+1); //00AFF930
    //跳过4字节
       printf("%p\n", &arr+1); //00AFF940
    //跳过一整个数组,20字节
       //sizeof是例外
       return 0;
}

整个数组地址与数组首元素地址相同
数组名 == 数组首元素地址
数组地址从起始位置开始
数组地址和数组首元素地址意义不一样,值是一样的

游戏

三子棋

image-20220111114226776

test.c 游戏的测试逻辑

#define _CRT_SECURE_NO_WARNINGS 
#include"game.h"
void menu()
{
        printf("******************************\n");
        printf("*********   1.play   *********\n");
        printf("*********   0.exit   ********\n");
        printf("******************************\n");
}

void game()
{
        //数据存储到一个字符的二维数组中,玩家下棋'*' 电脑下棋'#'
        char board[ROW][COL] = { 0 };//数组的内容应该是全部空格
        InitBoard(board,ROW,COL);//初始化棋盘
        DisplayBoard(board,ROW,COL);//打印棋盘
        //下棋
        char ret = 0;
        while (1)
        {
                player_move(board,ROW,COL);
                DisplayBoard(board, ROW, COL);
                ret = is_win(board, ROW, COL);
                if (ret != 'C')//C表示游戏继续
                {
                        break;
                }
                computer_move(board, ROW, COL);
                DisplayBoard(board, ROW, COL);
                if (ret != 'C')
                {
                        break;
                }
        }
        if (ret == '*')
        {
                printf("玩家赢\n");
        }
        else if (ret == '#')
        {
                printf("电脑赢\n");
        }
        else
        {
                printf("平局\n");
        }
}

void test()
{
        int input = 0;
        srand((unsigned int)time(NULL));
        do
        {
                menu();//菜单
                printf("请选择:>");
                scanf("%d", &input);
                switch (input)
                {
                case 1:
                        game();
                        break;
                case 0:
                        printf("退出游戏\n");
                        break;
                default:
                        printf("选择错误\n");
                        break;
                }
        } while (input);
}

int main()
{
        test();
        return 0;
}

game.c 游戏的实现逻辑

image-20220111125407020

#define _CRT_SECURE_NO_WARNINGS 1
#include"game.h"
void InitBoard(char board[ROW][COL], int row, int col)
{
        int i = 0;
        int j = 0;
        for (i = 0; i < row; i++)
        {
                for (j = 0; j < col; j++)
                {
                        board[i][j] = ' ';
                }
        }
}

//版本一 只能打印3x3棋盘

/*
void DisplayBoard(char board[ROW][COL], int row, int col)
{
	int i = 0;
	int j = 0;
	for (i = 0; i < row; i++)
	{
		//数据
		printf(" %c | %c | %c \n", board[i][0], board[i][0], board[i][1]);
		//分隔行(只需打印2个)
		if(i < row - 1)
			printf("---|---|---\n");
	}
}
*/

//版本二 配合宏定义可以灵活修改
void DisplayBoard(char board[ROW][COL], int row, int col)
{
	int i = 0;
	int j = 0;
	for (i = 0; i < row; i++)
	{
		//数据 把  %c |看成一组数据,但最后一个|不打印
		for (j = 0; j < col; j++)
		{
			printf(" %c ", board[i][j]);
			if(j < col -1)//最后一个|不用打印
				printf("|");
		}
        
		printf("\n"); //打印完一行换行
        
		//分隔行 把---|看成一组数据 最后一个|不打印 
		if (i < row - 1)//最后一行分隔行也无需打印
		{
			for (j = 0; j < col; j++)
			{
					printf("---");
					if (j < col - 1)
						printf("|");
			}
		}
		printf("\n"); //打印完一行换行
	}
}


void player_move(char board[ROW][COL], int row, int col)
{
        printf("玩家下棋:>");
        int x = 0;
        int y = 0;
        while (1)
        {
                scanf("%d %d", &x, &y);
                if (x >= 1 && x <= row && y >= 1 && y <= col)//坐标合法性判断
                {
                        if (board[x - 1][y - 1] == ' ')//坐标占用判断
                        {
                                board[x - 1][y - 1] = '*';
                                break;
                        }
                        else
                        {
                                printf("该坐标被占用,请重新输入\n");
                        }
                }
                else
                {
                        printf("坐标非法,请重新输入\n");
                }
        }
}

void computer_move(char board[ROW][COL], int row, int col)
{
        int x = 0;
        int y = 0;
        printf("电脑下棋:>\n");
        while (1)
        {
                x = rand() % ROW;//0 - 2
                y = rand() % COL;//0 - 2
                if (board[x][y] == ' ')
                {
                        board[x][y] = '#';
                        break;
                }
        }
}


int is_full(char board[ROW][COL],int row,int col )
{
        int i = 0;
        int j = 0;
        for (i = 0; i < row; i++)
        {
                for (j = 0; j < col; j++)
                {
                        if (board[i][j] == ' ')
                        {
                                return 0;
                        }
                }
        }
        return 1;//满了
}

//版本1 is_win被写死了,只能判断ROW COL为3的情况
/*char is_win(char board[ROW][COL], int row, int col)
{
	int i = 0;
	
	//三行判断
	for (i = 0; i < row; i++)
	{
		if (board[i][0] == board[i][1] && board[i][1] == board[i][2] && board[i][1] != ' ')
		{
			return board[i][1];
		}
	}
	
	//三列判断
	for (i = 0; i < col; i++)
	{
		if (board[0][i] == board[1][i] && board[1][i] == board[2][i] && board[1][i] != ' ')
		{
			return board[1][i];
		}
	}
	
	//判断对角线
	if (board[0][0] == board[1][1] && board[1][1] == board[2][2] && board[1][1] != ' ')
	{
		return board[1][1];
	}
	if (board[0][2] == board[1][1] && board[1][1] == board[2][0] && board[1][1] != ' ')
	{
		return board[1][1];
	}
	//判断平局
	if (1 == is_full(board, row, col))
	{
		return 'Q';
	}
	//游戏继续
	return 'C';
}*/


//版本2 is_win灵活变动
char is_win(char board[ROW][COL], int row, int col)
{
        int i = 0;
        int j = 0;
        int a = 0;
        //判断行
        for (i = 0; i < row; i++)
        {
                a = 0;
                for (j = 0; j < col - 1; j++)
                {
                        if (board[i][j] == board[i][j + 1] && board[i][j] == '*')
                        {
                                a++;
                        }
                        if (board[i][j] == board[i][j + 1] && board[i][j] == '#')
                        {
                                a--;
                        }
                        if (a == col - 1)
                        {
                                return '*';
                        }
                        if (a == -col + 1)
                        {
                                return '#';
                        }
                }
        }

        //判断列
        for (i = 0; i < col; i++)
        {
                a = 0;//a需要清零
                for (j = 0; j < row - 1; j++)
                {
                        if (board[j][i] == board[j + 1][i] && board[j][i] == '*')
                        {
                                a++;
                        }
                        if (board[j][i] == board[j + 1][i] && board[j][i] == '#')
                        {
                                a--;
                        }
                        if (a == row - 1)
                        {
                                return '*';
                        }
                        if (a == -row + 1)
                        {
                                return '#';
                        }
                }
        }

        //判断左对角线
        for (i = 0, j = 0; i < row - 1; i++, j++)
        {
                if (board[i][j] == board[i + 1][j + 1] && board[i][j] == '*')
                {
                        a++;
                }
                if (board[i][j] == board[i + 1][j + 1] && board[i][j] == '#')
                {
                        a--;
                }
                if (a == row - 1)
                {
                        return '*';
                }
                if (a == -row + 1)
                {
                        return '#';
                }
        }

        //判断右对角线
        for (i = 0, j = col - 1; i < row - 1; i++, j--)
        {
                if (board[i][j] == board[i + 1][j - 1] && board[i][j] == '*')
                {
                        a++;
                }
                if (board[i][j] == board[i + 1][j - 1] && board[i][j] == '#')
                {
                        a--;
                }
                if (a == row - 1)
                {
                        return '*';
                }
                if (a == -row + 1)
                {
                        return '#';
                }
        }

        //判断平局
        if (1 == is_full(board, row, col))
        {
                return 'Q';
        }
        //游戏继续
        return 'C';
}

game.h 游戏实现函数的声明

#pragma once
#define ROW 5
#define COL 5
#include<stdio.h>
#include<time.h>
#include<stdlib.h>
//初始化棋盘
void InitBoard(char board[ROW][COL],int row,int col);
//打印棋盘
void DisplayBoard(char board[ROW][COL], int row, int col);
//玩家下棋
void player_move(char board[ROW][COL], int row, int col);
//电脑下棋
void computer_move(char board[ROW][COL], int row, int col);

//判断输赢
//玩家赢了 -'*'
//电脑赢了 -'#'
//平局 - 'Q'
//游戏继续 - 'C'
char is_win(char board[ROW][COL], int row, int col);

细节

  1. 棋盘数据打印是把 %c |看成一组数据但最后一个|不打印
    分隔行 把—|看成一组数据但最后一个|不打印且最后一行分隔行也无需打印
  2. 把要用到的头文件及函数都在头文件中声明,这样在.c文件中就只需引用自己创建的头文件,避免了头文件的重复定义
  3. 用时间戳生成随机数的时候，先使用srand函数设置种子,注意srand函数不要放在实现函数的内部，不然会导致随机数生成的很近,srand函数每次游戏只需重新设置一次
    image-20220111120333716

扫雷

9x9 二维数组存储
char board / int board 似乎都行?
先布置累
排查雷
如果用0/1表示有雷无雷 可能会产生冲突
用* #也可以 但符号太多比较麻烦
再弄一个棋盘,放排查出的雷的信息
没排查过的位置放*
所以选char board

防范数组越界,把数组再多开辟一圈就行 11x11数组 用的只是9x9
image-20220111142105836

数字3+‘0’ -> ‘3’

注意不要形成死递归

test.c

#define _CRT_SECURE_NO_WARNINGS 1
#include"game.h"
void menu()
{
       printf("***********************\n");
       printf("*****  1. play     ****\n");
       printf("*****  0. exit     ****\n");
       printf("***********************\n");
}
void game()
{
       //创建数组
       char mine[ROWS][COLS] = { 0 };//存放布置好的雷信息
       char show[ROWS][COLS] = { 0 };//存放排查出的雷的信息
       //初始化mine数组-全字符'0'
       InitBoard(mine,ROWS,COLS,'0');
       //初始化show数组-全字符'*'
       InitBoard(show,ROWS,COLS,'*');
       //打印棋盘,只需打印9x9就行了
       //DisplayBoard(mine, ROW, COL);
       //DisplayBoard(show, ROW, COL);
       //布置雷
       SetMine(mine, ROW, COL);
       DisplayBoard(show, ROW, COL);
       //DisplayBoard(mine, ROW, COL);
       //排雷
       FindMine(mine, show, ROW, COL);
}
void test()
{
       int input = 0;
       srand((unsigned int)time(NULL));
       do
       {
               menu();
               printf("请选择:>\n");
               scanf("%d", &input);
               switch (input)
               {
               case 1:
                      //扫雷
                      game();
                      break;
               case 0:
                      printf("退出游戏\n");
                      break;
               default:
                      printf("选择错误,请重新选择\n");
                      break;
               }
       } while (input);
}
int main()
{
       test();
       return 0;
}

game.h

#pragma once
//头文件包含:符号的声明.函数的声明
#include<stdio.h>
#include<time.h>
#include<stdlib.h>
#define ROW 9
#define COL 9
#define ROWS ROW + 2
#define COLS COL + 2
#define EASY_COUNT 5
//初始化棋盘
void InitBoard(char board[ROWS][COLS], int rows, int cols, char set);
//打印棋盘
void DisplayBoard(char board[ROWS][COLS], int row, int col);
//布置雷
void SetMine(char mine[ROWS][COLS], int row, int col);
//排雷
void FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col);

game.c

#define _CRT_SECURE_NO_WARNINGS 1
#include"game.h"
 
void InitBoard(char board[ROWS][COLS], int rows, int cols, char set)
{
	int i = 0;
	int j = 0;
	for (i = 0; i < rows; i++)
	{
		for (j = 0; j < cols; j++)
		{
			board[i][j] = set;
		}
	}
}
 
//棋盘的打印
void DisplayBoard(char board[ROWS][COLS], int row, int col)
    //虽然只打印9*9,但传过去的数组依旧是11*11
{
	//1-9开始
	int i = 0;
	//打印列号
	for (i = 0; i <= col; i++) //i从0开始,避免列号错位(多多尝试就好)
	{
		printf("%d ", i);
	}
	printf("\n");
	for (i = 1; i <= row; i++)
	{
		printf("%d ", i);//打印行号
		for (int j = 1; j <= col; j++)
		{
			printf("%c ", board[i][j]);
		}
		printf("\n");
	}
}
 
//布置雷
void SetMine(char mine[ROWS][COLS], int row, int col)
{
	int count = EASY_COUNT;//布置10个雷
	while (count)
	{
		//随机产生的x y坐标是1-9
		int x = rand() % row + 1;
		int y = rand() % col + 1;
 
		if (mine[x][y] == '0')
		{
			mine[x][y] = '1';
			count--;
		}
	}
}
 

//无需写到头文件,因为不想暴露它 +static保护更加彻底 只能在game.c用
static int get_mine_count(char mine[ROWS][COLS], int x, int y) 
{
	//mine里放的是字符 需要减去'0'
	return mine[x - 1][y] + mine[x - 1][y - 1]
		+ mine[x][y - 1] + mine[x + 1][y - 1]
		+ mine[x + 1][y] + mine[x + 1][y + 1]
		+ mine[x][y + 1] + mine[x - 1][y + 1]
		- 8 * '0';
	//因为设计时11*11 所以x+1 y+1不会越界
}
 
//递归展开一片雷
void Open_Mine(char mine[ROWS][COLS], char show[ROWS][COLS], int x, int y)
{
	if (get_mine_count(mine, x, y) == 0)
	{
		show[x][y] = ' ';
		//判断坐标是否越界以及雷是否已经被排除
		if (show[x - 1][y - 1] == '*')
			Open_Mine(mine, show, x - 1, y - 1);
		if (show[x - 1][y] == '*')
			Open_Mine(mine, show, x - 1, y);
		if (show[x - 1][y + 1] == '*')
			Open_Mine(mine, show, x - 1, y + 1);
		if (show[x][y - 1] == '*')
			Open_Mine(mine, show, x, y - 1);
		if (show[x][y + 1] == '*')
			Open_Mine(mine, show, x, y + 1);
		if (show[x + 1][y - 1] == '*')
			Open_Mine(mine, show, x + 1, y - 1);
		if (show[x + 1][y] == '*')
			Open_Mine(mine, show, x + 1, y);
		if (show[x + 1][y + 1] == '*')
			Open_Mine(mine, show, x + 1, y + 1);
	}
	else
	{
		show[x][y] = get_mine_count(mine, x, y) + '0';
	}
}
 
//遍历show,以便判断是否排雷完毕
int Travel(char show[ROWS][COLS], int row, int col)
{
	int i = 0;
	int j = 0;
	int win = 0;
	for (i = 1; i <= row; i++)
	{
		for (j = 1; j <= col; j++)
		{
			if (show[i][j] == '*')
			{
				win++;
			}
		}
	}
	return win;
}
 
 
//排雷
void FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col)
    //在mine数组中排雷,信息放到show数组中去
{
	int x = 0;
	int y = 0;
	int win = 0;
	while (1)
	{
		printf("请输入要排查的雷的坐标:>\n");
		scanf("%d %d", &x, &y);
		if (x >= 1 && x <= row && y >= 1 && y <= col)//坐标合法性排查
		{
			if (mine[x][y] == '1')
			{
				printf("很遗憾,你被炸死了\n");
				DisplayBoard(mine, row, col);
				break;
			}
			else
			{
				//计算x y坐标周围有几个雷
				//show 里面放的是字符 数字3 + '0' 就变成'3'
				//字符'0' 48  '2' -> 50 = '0' + 2
				Open_Mine(mine, show, x, y);
				DisplayBoard(show, row, col);
				
			}
		}
		else
		{
			printf("输入坐标非法,请重新输入\n");
		}
		win = Travel(show, row, col);
		if (win == EASY_COUNT)
			break;
	}
	//EASY_COUNT 设置小一点方便检验是否排雷成功
	if (win == EASY_COUNT)
	{
		printf("恭喜你,排雷成功\n");
		DisplayBoard(mine, row, col);
	}
}

扩展:
image-20220111145200966

练习

1.交换2数组

#include <stdio.h>
int main()
{
       int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
       int arr2[] = { 10,9,8,7,6,5,4,3,2,1 };
       int sz = sizeof(arr1) / sizeof(arr1[0]);
       for (int i = 0; i < sz; i++)
       {
               int tmp = arr1[i];
               arr1[i] = arr2[i];
               arr2[i] = tmp;
       }
       return 0;
}

image-20220111211528782

2.数组操作

创建一个整形数组，完成对数组的操作
实现函数init() 初始化数组为全0
实现print() 打印数组的每个元素
实现reverse() 函数完成数组元素的逆置

#include<stdio.h>
void init(int arr[10], int sz)
{
       int i = 0;
       for (i = 0; i < sz; i++)
       {
               arr[i] = 0;
       }
}
void print(int arr[10], int sz)
{
       int i = 0;
       for (i = 0; i < sz; i++)
       {
               printf("%d ", arr[i]);
       }
       printf("\n");
}
void reverse(int arr[10], int sz)
{
       int left = 0;
       int right = sz - 1;
       while (left < right)
       {
               int tmp = arr[left];
               arr[left] = arr[right];
               arr[right] = tmp;
               left++;
               right--;
       }
}
int main()
{
       int arr[10] = { 9,8,7,6,5,4,3,2,1,0 };
       int sz = sizeof(arr) / sizeof(arr[0]);
       print(arr, sz);
       reverse(arr, sz);
       print(arr, sz);
       init(arr, sz);
       print(arr, sz);
       return 0;
}

3.字符串逆序

编写一个函数 reverse_string(char* string)（递归实现）
实现：将参数字符串中的字符反向排列，不是逆序打印。
要求：不能使用C函数库中的字符串操作函数。
比如 :
char arr[] = “abcdef”;
逆序之后数组的内容变成：fedcba

递归实现:

image-20220111203930683

#include <string.h>

int my_strlen(char* s)
{
	int count = 0;
	while (*s != '\0')
	{
		count++;
		s++;
	}
	return count;
}


//[a b c d e f g \0]
//递归版本
void reverse_string(char* arr)
{
	int len = my_strlen(arr);
	char tmp = *arr;//a
	*arr = *(arr + len - 1);//找到了g
	*(arr + len - 1) = '\0';//先把g的内容赋值为\0才能识别为字符串
	if(my_strlen(arr+1)>1)//递归必须要有结束条件
		reverse_string(arr+1);//arr+1找到b的地址
	*(arr + len - 1) = tmp;//再把a放回到g的位置
}


//参数用指针的形式
void reverse_string(char* str)
{
	char* left = str;//a的地址
	char* right = str + my_strlen(str) - 1;
	while (left<right)
	{
		char tmp = *left;
		*left = *right;
		*right = tmp;
		left++;
		right--;
	}
}

//参数是数组的形式
void reverse_string(char arr[])
{
	int left = 0;
	int right = my_strlen(arr)-1;

	//交换
	while (left<right)
	{
		char tmp = arr[left];
		arr[left] = arr[right];
		arr[right] = tmp;
		left++;
		right--;
	}
}


int main()
{
	char arr[] = "abcdefg";
	reverse_string(arr);
	printf("%s\n", arr);//fedcba
	return 0;
}

image-20220111203156679

4.计算每位数之和

//写一个递归函数DigitSum(n)，输入一个非负整数，返回组成它的数字之和
//例如，调用DigitSum(1729)，则应该返回1 + 7 + 2 + 9，它的和是19
//输入：1729，输出：19

int DigitSum(size_t n)
{
	if (n <= 9)
		return n;
	else
		return DigitSum(n / 10) + n % 10;
}

int main()
{
	size_t num = 0;
	scanf("%u", &num);
	int ret = DigitSum(num);
	printf("%d\n", ret);

	return 0;
}

5.求n^k

double Pow(int n, int k)
{
	if (k == 0)
		return 1;
	else if (k > 0)
		return n * Pow(n, k - 1);
	else
		return 1.0 / Pow(n, -k);
}

int main()
{
	int n = 0;
	int k = 0;
	scanf("%d %d", &n, &k);

	double ret = Pow(n, k);

	printf("%lf\n", ret);

	return 0;
}

要注意考虑k<0的情况

TauCeti0207
关注
专栏目录
Python编程利用ddddocr模块读取图片验证码
kriesa的博客
07-13 544
ddddocr模块读取图片验证码
数组的初始化（练习）、 数组的遍历
Wynb1020的博客
06-05 239
数组的初始化（练习） * 数组使用练习三种初始化方式 */ package cn.wu.array; public class Exe1 { public static void main(String[] args) { // 静态初始化 String[] score = new String[]{"java,60","python,70","大数据,80","人工智能,90"}; // 动态初始化 String[] s1 = new String[4]; s1[0]
dddd
duantl的专栏
02-28 6190
试卷编号：9405 所属语言：C语言 试卷方案：C语言练习 试卷总分：115分 共有题型：3种     一、单项选择   共100题 （共计100分） 第1题 （1.0分） 有以下程序 main() { int p[7]={11,13,14,15,16,17,18},i=0,k=0; while(i printf("%d\n",k); } 执行后输出的结果是
前端手动获取客户端本地文件夹下图片信息base64
LiuYi000000001的博客
06-27 821
前端手动获取固定文件夹下图片信息
pythonddddddd
github_51186756的博客
08-11 620
import json sum=0 wordVV= ‘VV’ word=‘地区’ value = {} keys = {} disc= {} qian={} with open(“C:\Users\11031\Desktop\sample-data\chinese.token.txt”, “r”,encoding=‘utf8’) as f: # 打开文件 # conten = f.read() # if word in conten: # print(conten) # sum
Ruby的字符串与数组求最大值的相关问题讨论
09-21
d = %w(albatross dog horse dddd asgfds) d.max # 返回 "horse" ``` 这个结果可能会让人感到困惑，因为从直觉上看，“asgfds”应该比“horse”在字典序上更大。为了解释这个现象，我们可以通过打印比较过程来...
python输出字母金字塔a bb ccc dddd_《程序设计基础》题库(50道)
weixin_39708854的博客
12-19 2688
海伦公式《程序设计基础》题库(50道)1、难易程度依次为：易(16道)、较易(38道)、较难(31道)、难(15道)。2、总共抽8道题，按难易程度：易(1道)、较易(4道)、较难(2道)、难(1道)； 按题型：顺序(1道)、分支(2道)、单循环(2道)、多循环(1道)、数组(1道)、字符串(1道)3、考试要求：先画流程图再写程序，理论考试，2个半小时 一、顺序结构1、 请定义4个整型变量，并打印...
es6笔记——数组循环以及新增部分
xiaozong301的博客
09-01 401
数组循环以及新增部分： ES5里面新增一些东西 循环: 1. for for(let i=0; i<arr.length; i++) 2. while arr.forEach() // 代替普通for arr.forEach(function(val, index, arr){ console.log(val, index, arr); }); arr.map() // 非常有用，做数据交互 "映射" //正常情况下，需要配合return，返回是一
matlab 找到数组中第一个不连续点_1.基础知识(1) Matlab基础知识
weixin_39574555的博客
11-20 922
前言：前两次文章有读者私信说Matlab初学，基础较差，本次分享一下Matlab的基础内容，熟练者可以跳过本文，后续的文章也会在文后加上一些基础内容分享。关键字：Matlab、数组、函数、计算、绘图正文1、MATLAB 产品1.1 MATLAB 产品描述全世界数超过百万的工程师和科学家们使用 MATLAB 来分析和设计改变世界的系统和产品。MATLAB 应用于汽车安全系统、宇宙飞船、健康...
小小电影资源播放器
02-25
小小电影资源播放器
小知识点2
aidou1314的博客
01-14 1207
1.Error while executing: am start -n错误解决方案 参考网址：https://blog.csdn.net/chunqiuwei/article/details/94738268 说明：如果手动卸载app没有卸载干净，就用了adb uninstall packageName命令运行了一下，再重新运行项目 2.手机安装apk报签名不一致（提示手机上有该应用，卸载...
计算机控制及网络技术pdf,计算机控制和网络技术-复习资料.pdf
weixin_31746993的博客
07-08 292
计算机控制和网络技术-复习资料.pdf1 简述几种典型计算机控制系统的原理与特点31.1数据采集系统(DAS)31.2直接数字控制系统(DDC)31.3监督控制系统(SCC)31.4集散控制系统(DCS)31.5现场总线控制系统(FCS)41.6工业过程计算机集成制造系统(CIMS)41.7网络控制系统42 总线的概念及分类43 串行通信基础44 被控对象传函描述：44.1放大环节44.2惯性环节...
用ddddocr识别图形字符验证码
Amoor的博客
11-03 6843
函数很简单，这里主要分享流程 目标 这是一个网站 的注册页面 找接口 先在抓包工具或者浏览器检查界面找到验证码的位置 测试 测试下重放，发现数据可以正常发送，那就拷贝headers里面的一些参数和cookie到Postman做测试 逐步添加headers信息直到能拿到数据 组合带带弟弟编码 拷贝python-requests代码到编译器，修改下即可 为什么是带带弟弟，因为他就叫这个名字 get_time_stamp13函数用于生成13位时间戳，作为文件名，文件会保存到本地进行比较 ddddocr的用
string.Format
dddd235的专栏
02-25 556
2011-02-25 C# String.Format格式说明 收藏   C#格式化数值结果表字符说明示例输出C货币string.Format ("{0:C3}", 2)＄2.000D十进制string.Format ("{0:D3}", 2)002E科学计数法1.20E+0011.20E+001G常规string.Format ("{0:G}", 2)2N用分号隔开的数字string.Format ("{0:N}", 250000)
一些黄页 网站
热门推荐
weixin_30907935的博客
01-06 43万+
1. http://www.chinabig.com/ http://www.chinabig.com/v07/product/product_sitemap.htm#10 2. www.ypinfo.com 3. www.chinapages.com/ 转载于:https://www.cnblogs.com/cy163/archive/2010/01/06/1640821.html...
基于讯为开发板的linphone3.7.0的交叉编译
ddddffffggggg的专栏
07-22 775
zlib:1.2.11 ./configure --prefix=$PREFIX 修改Makefile /////////////////////////////////////////////// CC=gcc ===> CC=arm-none-linux-gnueabi-gcc LDSHARED=gcc -shared -Wl,-soname,libz.so.1,--versio...
Altium designer 10安装破解以及出现缺少mfc71.dll文件的情况处理
j_jzmdddd的博客
03-07 6444
Altium designer 10安装破解以及缺少mfc71.dll文件无法破解 AD10破解文件百度网盘：https://pan.baidu.com/s/1H-Zlayx_jDVU6O7H907HPg 提取码：ef9z 文件mfc71.dll百度网盘：https://pan.baidu.com/s/1fHF4mSgRrsxcQ0Hyz5v-HA 提取码：s3im 一、Altium design...
js数组转字符串用逗号拼接
最新发布
11-26
以下是两种将JS数组转换为逗号分隔字符串的方法： 1.使用for循环遍历数组并拼接字符串： ```javascript var arr = [{"name":"hhh"},{"name":"dddd"}]; var str = ""; for (var i = 0; i < arr.length; i++) { str...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值