qidao123.com技术社区-IT企服评测·应用市场

标题: CSharp_base [打印本页]

作者: 没腿的鸟 时间: 2025-4-25 00:41
标题: CSharp_base
C# 基础篇

github仓库：https://github.com/EanoJiang/CSharp_base

枚举(enum)

枚举是一个被命名的整形常量的集合
用于表示：状态类型
申明枚举：创建一个自定义的枚举类型
申明枚举变量：使用申明的自定义的枚举类型，来创建一个枚举变量
语法

//语法：枚举名以E或E_开头，作为命名规范
enum E_自定义枚举名{
自定义枚举项名字1,//枚举中的第一个默认值是0，也可以赋值，下面依次累加。
自定义枚举项名字2,//1
自定义枚举项名字3,//2
}

复制代码

在那里申明枚举

namespace语句块中
class语句块中
struct语句块中

枚举不能在函数语句块中声明

#region 在哪里申明枚举
//namespace语句块中
//class语句块中
//struct语句块中
//枚举不能再函数语句块中声明
enum E_MonsterType{
Normal,
Boss,
}
enum E_PlayerType{
Main,
Other,
}
#endregion

复制代码

枚举的用法

申明枚举变量： 前面自定义的变量名 = 默认值;
枚举和switch配套使用

#region 枚举的用法
//申明枚举变量
//前面自定义的变量名 = 默认值;
// (这里的默认值的格式：自定义的枚举类型.枚举项)枚举类型
E_MonsterType monsterType = E_MonsterType.Normal;
E_PlayerType playerType = E_PlayerType.Main;
if(playerType == E_PlayerType.Main){
Console.WriteLine("主角的逻辑");
}
else if(playerType == E_PlayerType.Other){
Console.WriteLine("其他角色的逻辑");
}
//枚举很适合和switch配套使用
//也可以贯穿，两种情况使用同一个逻辑
switch (monsterType){
case E_MonsterType.Normal:
Console.WriteLine("普通怪物的逻辑");
break;
case E_MonsterType.Boss:
Console.WriteLine("BOSS的逻辑");
break;
}
#endregion

复制代码

枚举的类型转换

#region 枚举的类型转换
//枚举转int——括号强转
int i1 = (int)playerType;
Console.WriteLine(i1);
//int 转枚举——隐式转换
playerType = 0;
Console.WriteLine(playerType);
//枚举转string——ToString()方法
string s1 = playerType.ToString();
Console.WriteLine(s1);
//string 转枚举——Parse()方法 + 自定义枚举类型括号强转
//语法：(自定义枚举类型)Enum.Parse(typeof(自定义枚举类型), "要转换的字符串");
//注意要转换的字符串必须是枚举里有的常量
playerType = (E_PlayerType)Enum.Parse(typeof(E_PlayerType), "Main");
Console.WriteLine(playerType);
#endregion

复制代码

(总结)枚举的作用

在游戏开发中，对象通常会有很多状态
每个状态需要一个变量 / 标识来表示，以便于后续使用时的判断(该对象当前处于什么状态)
不要去用int 表示他的状态，1走路 2空闲 3跑步 4跳跃
枚举的使用可以很好的分清楚各状态的含义，提高代码可读性
习题

/// <summary>
/// 状态
/// </summary>
enum E_StateOnlineType{
Offline,
Online,
Busy,
Invisible,
}

复制代码

#region 题目1 用户状态
try
{
Console.WriteLine("请输入状态(0-3):");
E_StateOnlineType state = (E_StateOnlineType)Enum.Parse(typeof(E_StateOnlineType), Console.ReadLine());
Console.WriteLine(state);
}
catch{
Console.WriteLine("输入错误,请输入0-3的数字!");
}
#endregion

复制代码

/// <summary>
/// 咖啡类型
/// </summary>
enum E_CoffeeType{
/// <summary>
/// 中杯
M,
/// <summary>
/// 大杯
/// </summary>
L,
/// <summary>
/// 特大杯
/// </summary>
XL,
}

复制代码

#region 题目2 coffee
try{
Console.WriteLine("请输入咖啡类型(M/L/XL):");
E_CoffeeType coffeeType = (E_CoffeeType)Enum.Parse(typeof(E_CoffeeType), Console.ReadLine());
switch(coffeeType){
case E_CoffeeType.M:
Console.WriteLine("中杯咖啡");
break;
case E_CoffeeType.L:
Console.WriteLine("大杯咖啡");
break;
case E_CoffeeType.XL:
Console.WriteLine("特大杯咖啡");
break;
default:
Console.WriteLine("输入错误!");
break;
}
}
catch{
Console.WriteLine("输入错误,请输入M/L/XL!");
}
#endregion

复制代码

[/code][size=5]数组[/size]
[size=4]一维数组(数组)[/size]
一维、多维、交错数组
[code]namespace 数组;
class Program
{
static void Main(string[] args)
{
#region 数组声明
//只声明数组名，不初始化
//变量类型[] 数组名;
int[] arr1;
//声明并初始化数组的长度，元素默认值是0
//变量类型[] 数组名 = new 变量类型[数组长度];
int[] arr2 = new int[5];
//声明并初始化数组的长度和元素值
//变量类型[] 数组名 = new 变量类型[数组长度] {元素值1, 元素值2, 元素值3...};
int[] arr3 = new int[5] { 1, 2, 3, 4, 5 };
//声明并初始化数组的元素值，数组长度自动计算
//变量类型[] 数组名 = new 变量类型[] {元素值1, 元素值2, 元素值3...};
int[] arr4 = new int[] { 1, 2, 3, 4};
//声明并初始化数组——最简单的方法
int[] arr5 = { 1, 2, 3, 4, 5 };
bool[] arr6 = new bool[] { true, false, true, false };
#endregion
#region 数组使用
int[] arr = { 1, 2, 3, 4, 5 };
//1. 获取数组长度
//数组名.Length
Console.WriteLine("数组长度：" + arr.Length);
//2. 获取数组元素
//数组名[索引]
//注意不要越界
Console.WriteLine("数组第一个元素：" + arr[0]);
//3. 修改数组元素
//数组名[索引] = 新值;
arr[0] = 10;
Console.WriteLine("修改后的数组第一个元素：" + arr[0]);
//4. 遍历数组
for(int i = 0; i < arr.Length; i++){
Console.WriteLine("数组第" + i + "个元素：" + arr[i]);
}
//5. 增加数组元素(先拷贝数组)
int[] array2 = new int[6];
for(int i = 0; i < arr.Length; i++){
array2[i] = arr[i];
}
arr = array2;
arr[5] = 6;
Console.WriteLine("增加后的数组：" + string.Join(",", arr));
//6. 删除数组元素(先拷贝数组)
int[] array3 = new int[4];
for(int i = 0; i < 4; i++){
array3[i] = arr[i];
}
arr = array3;
Console.WriteLine("删除后的数组：" + string.Join(",", arr));
//7. 查找数组元素
int elem = 3;
for(int i = 0; i < arr.Length; i++){
if(arr[i] == elem){
Console.WriteLine("元素" + elem + "在数组的索引为：" + i);
break;
}
}
#endregion
}
}

复制代码

用来批量存储游戏中同一类型的所有对象，比如所有的enemy和player

习题

#region 1
int[] arr1 = new int[100];
for(int i = 0; i < arr1.Length; i++){
arr1[i] = i;
}
Console.WriteLine(string.Join(",", arr1));
#endregion

复制代码

#region 2
int[] arr2 = new int[100];
for(int i = 0; i < arr2.Length; i++){
arr2[i] = arr1[i] * 2;
}
Console.WriteLine(string.Join(",", arr2));
#endregion

复制代码

#region 3
Random r1 = new Random();
int[] arr3 = new int[10];
for(int i = 0; i < arr3.Length; i++){
arr3[i] = r1.Next(0, 101);
}
Console.WriteLine(string.Join(",", arr3));
#endregion

复制代码

#region 4
Random r = new Random();
int[] arr = new int[10];
for(int i = 0; i < arr.Length; i++){
arr[i] = r.Next(0, 101);
}
Console.WriteLine("原数组："+string.Join(",", arr));
//MAX MIN
int max = arr[0];
int min = arr[0];
int sum = 0;
for(int i = 0; i < arr.Length - 1; i++){
max = (max >= arr[i])? max : arr[i];
min = (min <= arr[i])? min : arr[i];
sum += arr[i];
}
Console.WriteLine("最大值："+max);
Console.WriteLine("最小值："+min);
Console.WriteLine("和："+sum);
double avg = (double)sum / arr.Length;
Console.WriteLine("平均值："+avg);
#endregion

复制代码

#region 5
Random r2 = new Random();
int[] arr4 = new int[10];
for(int i = 0; i < arr4.Length; i++){
arr4[i] = r2.Next(0, 101);
}
Console.WriteLine("原数组："+string.Join(",", arr4));
for(int i = 0; i < arr4.Length /2; i++){
arr4[i] = arr4[i] + arr4[arr4.Length-1-i];
arr4[arr4.Length-1-i] = arr4[i] - arr4[arr4.Length-1-i];
arr4[i] = arr4[i] - arr4[arr4.Length-1-i];
}
Console.WriteLine("反转后："+string.Join(",", arr4));
#endregion

复制代码

#region 6
Random r3 = new Random();
int[] arr5 = new int[10];
for(int i = 0; i < arr5.Length; i++){
arr5[i] = r3.Next(-100, 101);
}
Console.WriteLine("原数组："+string.Join(",", arr5));
for(int i = 0; i < arr5.Length; i++){
if(arr5[i]>0) arr5[i]++;
else if(arr5[i]<0) arr5[i]--;
}
Console.WriteLine("变化后："+string.Join(",", arr5));
#endregion

复制代码

#region 7
int[] arr6 = new int[10];
//输入
try{
for(int i = 0; i < arr6.Length; i++){
Console.Write("请输入第{0}个元素：", i+1);
arr6[i] = Convert.ToInt32(Console.ReadLine());
}
}
catch{
Console.WriteLine("输入有误，程序退出");
}
Console.WriteLine("原数组："+string.Join(",", arr6));
//MAX MIN
int max = arr6[0];
int min = arr6[0];
int sum = 0;
for(int i = 0; i < arr6.Length - 1; i++){
max = (max >= arr6[i])? max : arr6[i];
min = (min <= arr6[i])? min : arr6[i];
sum += arr6[i];
}
Console.WriteLine("最大值："+max);
Console.WriteLine("最小值："+min);
Console.WriteLine("平均值："+(double)sum / arr6.Length);
#endregion

复制代码

交错数组

数组的数组
特点：存储确定行数，不确定列数的数据

#region 8
string[] arr7 = new string[25];
for(int i = 0; i < arr7.Length; i++){
arr7[i] = (i%2 == 0)? "■": "□";
}
for(int i = 0; i < arr7.Length; i++){
Console.Write(arr7[i]);
if((i+1)%5 == 0 && i!= 0){
Console.WriteLine();
}
}
#endregion

复制代码

值类型和引用类型

引用类型：string、数组、(class)类

值类型：其他数据类型，结构体

区别：
值类型：在相互赋值的时间把内容拷贝给对方，一个变另一个不会变
引用类型：两者指向同一个值，一个变另一个也变

namespace 二维数组;
class Program
{
static void Main(string[] args)
{
#region 二维数组的申明
//申明但不初始化：
//变量类型[,] 二维数组变量名
int[,] arr1;
//变量类型[,] 二维数组变量名 = new int[行数,列数];
int[,] arr2 = new int[3, 3];
//申明+初始化：
//变量类型[,] 二维数组变量名 = new int[行数,列数] { {元素1,元素2,元素3...}, {元素1,元素2,元素3...},... };
int[,] arr3 = new int[3, 3] { { 1, 2, 3 },
{ 4, 5, 6 },
{ 7, 8, 9 }};
//行列自动计算
int[,] arr4 = new int[,] { { 1, 2, 3 },
{ 4, 5, 6 },
{ 7, 8, 9 }};
#endregion
#region 二维数组的使用
//1.二维数组的长度
int[,] array1 = new int[,]{ {1,2,3},
{4,5,6},
{7,8,9}};
//二维数组名.GetLength(dimesion)，dimesion为0表示行，为1表示列
//行
Console.WriteLine(array1.GetLength(0));
//列
Console.WriteLine(array1.GetLength(1));
//2.获取二维数组的元素
//二维数组名[行,列]
Console.WriteLine(array1[0, 0]);
//3.修改二维数组的元素
//二维数组名[行,列] = 元素值
array1[0, 0] = 10;
Console.WriteLine(array1[0, 0]);
//4.遍历二维数组
for (int i = 0; i < array1.GetLength(0); i++)
{
for (int j = 0; j < array1.GetLength(1); j++)
{
Console.Write(array1[i, j] + " ");
}
Console.WriteLine();
}
Console.WriteLine("**************");
//5.增加数组元素
int[,] array2 = new int[4,3];
//先拷贝原数组元素
for (int i = 0; i < array1.GetLength(0); i++)
{
for (int j = 0; j < array1.GetLength(1); j++)
{
array2[i, j] = array1[i, j];
}
}
array1 = array2;
array1[3, 0] = 100;
array1[3, 1] = 101;
array1[3, 2] = 102;
for(int i = 0; i < array1.GetLength(0); i++)
{
for(int j = 0; j < array1.GetLength(1); j++)
{
Console.Write(array1[i, j] + " ");
}
Console.WriteLine();
}
Console.WriteLine("***************");
//6.删除数组元素
//先拷贝原数组元素
int[,] array3 = new int[2, 3];
for (int i = 0; i < array3.GetLength(0); i++)
{
for (int j = 0; j < array3.GetLength(1); j++)
{
array3[i, j] = array1[i, j];
}
}
array1 = array3;
for(int i = 0; i < array1.GetLength(0); i++)
{
for(int j = 0; j < array1.GetLength(1); j++)
{
Console.Write(array1[i, j] + " ");
}
Console.WriteLine();
}
//7.查找数组元素
for(int i = 0; i < array1.GetLength(0); i++)
{
for(int j = 0; j < array1.GetLength(1); j++)
{
if(array1[i,j] == 6)
{
Console.WriteLine("元素6的位置为：{0},{1}", i, j);
}
}
}
#endregion
}
}

复制代码

WHY？

值类型存储在栈空间——系统分配，主动回收，小而快
引用类型存储在堆空间——手动申请开释，大而慢

值类型每次申明相当于开了一个栈空间，赋值的时间互不影响。
引用类型申明的时间开的栈空间存放的是一个指针(地址)，指向一块堆内存，赋值的时间其实赋的是地址。

习题

10
20
"123"

string——特殊的引用类型

每次重新赋值的时间在堆内存重新分配空间，地址也会重新分配

#region 1
int[,] arr1 = new int[100, 100];
int count = 1;
Console.WriteLine("1到10000的二维数组：");
for (int i = 0; i < arr1.GetLength(0); i++){
for (int j = 0; j < arr1.GetLength(1); j++){
arr1[i, j] = count;
count++;
Console.Write(arr1[i, j] + " ");
}
Console.WriteLine();
}
#endregion

复制代码

习题

#region 2
int[,] arr2 = new int[4, 4];
Random r = new Random();
Console.WriteLine("随机生成的4x4二维数组：");
for (int i = 0; i < arr2.GetLength(0); i++){
for (int j = 0; j < arr2.GetLength(1); j++){
arr2[i, j] = r.Next(1, 101);
Console.Write(arr2[i, j] + " ");
}
Console.WriteLine();
}
Console.WriteLine("将数组的右上角区域清零：");
for (int i = 0; i < arr2.GetLength(0); i++){
for (int j = 0; j < arr2.GetLength(1); j++){
if(i < arr2.GetLength(0) / 2 && j >= arr2.GetLength(1) / 2){
arr2[i, j] = 0;
}
Console.Write(arr2[i, j] + " ");
}
Console.WriteLine();
}
#endregion

复制代码

总结

只要是整体重新赋值（像new int[]）地址就会改变
而单独改一个元素，地址不会改变
函数(方法)

函数基础

作用：

封装代码
提高代码复用率
抽象举动

写在哪儿？

class(类)语句块中
struct(结构体)语句块中

语法

#region 3
int[,] arr3 = new int[3, 3];
Random r = new Random();
Console.WriteLine("随机生成的3x3二维数组：");
for (int i = 0; i < arr3.GetLength(0); i++){
for (int j = 0; j < arr3.GetLength(1); j++){
arr3[i, j] = r.Next(1, 11);
Console.Write(arr3[i, j] + " ");
}
Console.WriteLine();
}
Console.WriteLine("对角线:");
int sum = 0;
for (int i = 0; i < arr3.GetLength(0); i++){
for (int j = 0; j < arr3.GetLength(1); j++){
if(i == j || i+j == 3-1){
sum += arr3[i, j];
Console.Write(arr3[i, j] + " ");
}
}
Console.WriteLine();
}
Console.WriteLine("对角线的和为：" + sum);
#endregion

复制代码

在学习类和结构体之前，static必须写
函数名用帕斯卡命名法，比如：MyName()
参数名用驼峰命名法
纵然函数返回类型是void，也可以选择性使用return

使用

#region 4
int[,] arr4 = new int[5, 5];
Random r = new Random();
//记录最大值的位置
int maxRow = 0, maxCol = 0;
Console.WriteLine("随机生成的5x5二维数组：");
for (int i = 0; i < arr4.GetLength(0); i++){
for (int j = 0; j < arr4.GetLength(1); j++){
arr4[i, j] = r.Next(1, 11);
Console.Write(arr4[i, j] + " ");
if(arr4[maxRow, maxCol] < arr4[i, j]){
maxRow = i;
maxCol = j;
}
}
Console.WriteLine();
}
Console.WriteLine("最大值{0}的位置：({1},{2})" , arr4[maxRow, maxCol], maxRow, maxCol);
Console.WriteLine("****所有最大值元素{0}的位置****");
for(int i = 0; i < arr4.GetLength(0); i++){
for(int j = 0; j < arr4.GetLength(1); j++){
if(arr4[i,j] == arr4[maxRow, maxCol]){
Console.WriteLine("最大值{0}的位置：({1},{2})" , arr4[maxRow, maxCol], i, j);
}
}
}
#endregion

复制代码

关于return

#region 5
int[,] arr5 = new int[5, 5] { { 0,0,0,0,0},
{ 0,0,0,0,0},
{ 0,0,1,1,0},
{ 0,0,0,0,0},
{ 0,0,0,0,0}};
void transArray(int[,] arr){
//用来记录行和列是否有1的真值数组
bool[] boolRow = new bool[arr.GetLength(0)];
bool[] boolCol = new bool[arr.GetLength(1)];
//标记行和列
for(int i = 0; i < arr.GetLength(0); i++){
for(int j = 0; j < arr.GetLength(1); j++){
if(arr[i,j] == 1){
boolRow[i] = true;
boolCol[j] = true;
}
}
}
//转置
for(int i = 0; i < arr.GetLength(0); i++){
for(int j = 0; j < arr.GetLength(1); j++){
if(boolRow[i] == true || boolCol[j] == true){
arr[i,j] = 1;
}
}
}
}
transArray(arr5);
Console.WriteLine("转置后的数组：");
for (int i = 0; i < arr5.GetLength(0); i++){
for (int j = 0; j < arr5.GetLength(1); j++){
Console.Write(arr5[i, j] + " ");
}
Console.WriteLine();
}
#endregion

复制代码

习题

namespace 交错数组;
class Program
{
static void Main(string[] args)
{
#region 交错数组的申明
//只申明
//变量类型[][] 交错数组名;
int[][] arr1;
//申明+初始化
//变量类型[][] 交错数组名 = new int[行数][];
int[][] arr2 = new int[3][];
//变量类型[][] 交错数组名 = new int[行数][] { 一维数组1, 一维数组2, 一维数组3 };
//注意：{一维数组的数据类型要和交错数组的类型一致}
int[][] arr3 = new int[3][] { new int[] { 1, 2 },
new int[] { 3, 4},
new int[] { 5 } };
//变量类型[][] 交错数组名 = new int[][] { 一维数组1, 一维数组2, 一维数组3 };
int[][] arr4 = new int[][] { new int[] { 1, 2 },
new int[] { 3, 4},
new int[] { 5 } };
//最常用：
//变量类型[][] 交错数组名 = { 一维数组1, 一维数组2, 一维数组3 };
int[][] arr5 = {new int[] {1, 2, 3},
new int[] {4, 5},
new int[] {6, 7, 8, 9}};
#endregion
#region 交错数组的使用
int[][] array1 = { new int[] {1, 2, 3},
new int[] {4, 5} };
//1.数组的长度
//行
//交错数组名.Length
//交错数组名.GetLength(0)
Console.WriteLine(array1.Length);
Console.WriteLine(array1.GetLength(0));
//列
//交错数组名[行].Length
//其实就是找到交错数组中的某个一维数组的长度
Console.WriteLine(array1[0].Length);
Console.WriteLine(array1[1].Length);
//2.获取交错数组的元素
//交错数组名[行][列]
Console.WriteLine(array1[0][0]);
//3.修改交错数组的元素
//交错数组名[行][列] = 值;
array1[0][0] = 10;
Console.WriteLine(array1[0][0]);
//4.遍历交错数组
//和二维数组一样，只不过是遍历每一个一维数组
for (int i = 0; i < array1.Length; i++)
{
for (int j = 0; j < array1[i].Length; j++)
{
Console.Write(array1[i][j] + " ");
}
Console.WriteLine();
}
//5.增加交错数组的元素
//6.删除交错数组的元素
//7.查找交错数组的元素
//***都和二维数组一样***
#endregion
}
}

复制代码

namespace 值类型和引用类型;
class Program
{
static void Main(string[] args)
{
//值类型
int a = 1;
//引用类型
int[] arr = new int[] {1,2,3,4 };
//赋值给另一个变量
int b = a;
int[] arr2 = arr;
Console.WriteLine("a={0},b={1}\narr[0]={2},arr2[0]={3}",a,b,arr[0],arr2[0]);
//修改新的变量
b = 2;
arr2[0] = 99;
Console.WriteLine("a={0},b={1}\narr[0]={2},arr2[0]={3}",a,b,arr[0],arr2[0]);
}
}

复制代码

#region string——特殊的引用类型
string str1 = "123";
string str2 = str1;//这一步两个变量指向的地址相同
str2 = "456";//str2重新赋值，地址改变
Console.WriteLine("str1={0},str2={1}",str1,str2);
#endregion

复制代码

递归

必须有结束掉用的条件

#region 习题
int[] arr3 = new int[]{1};
int[] arr4 = arr3;
int[] arr5 = arr3;
arr4[0] = 99;//arr4修改单个元素，地址不变
arr5 = new int[5];//arr5重新赋值，地址改变，指向新的堆内存
Console.WriteLine("arr3[0]={0},arr4[0]={1},arr5[0]={2}",arr3[0],arr4[0],arr5[0]);
#endregion

复制代码

习题

namespace 函数;
class Program
{
#region 函数的语法
// static 返回类型函数名(参数类型参数名){
// // 函数体
// return 返回值;
// }
#endregion
static void Main(string[] args)
{
}
}

复制代码

结构体

结构体相当于一个人，他的变量相当于人的各个属性，方法相当于人的各个功能函数
语法

写在namespace语句块中
关键字struct
帕斯卡命名法

namespace 函数;
class Program
{
//有参有返回值的函数
static int[] sum_avg(int a, int b)
{
int sum = a + b;
int avg = sum / 2;
// int[] result = { sum, avg };
return new int[] { sum, avg };
}
static void Main(string[] args)
{
int a = 10;
int b = 20;
int[] result = sum_avg(a, b);
Console.WriteLine("The sum is: " + result[0]);
Console.WriteLine("The average is: " + result[1]);
}
}

复制代码

访问修饰符

修饰结构体中的变量和方法是否能被外部使用

public 可以被外部访问
private 只能在内部使用

默认不写，就是private
结构体的构造函数

没有返回值
函数名和结构体名相同
必须有参数
如果申明了构造函数，那就必须在其中对所有变量数据初始化

使用

static void Say(string str){
//void也是可以写return的，return后面的语句不会执行
if(str == "Fuck") return;
Console.WriteLine(str);
}

复制代码

习题

#region 1
static int Max(int a, int b){
return (a > b)? a : b;
}
#endregion

复制代码

排序

冒泡排序

#region 2
static float[] Circle(float r){
//1
// float area = 3.14f * r * r;
// float perimeter = 2 * 3.14f * r;
// float[] result = {area, perimeter};
// return result;
//2
return new float[] { 3.14f * r * r, 2 * 3.14f * r };
}
#endregion

复制代码

选择排序

步调：

新建中间商
每轮依次比力，更新中间商
找出极值
中间商与目标位置互换位置
n轮比力

详细步调：

新建一个中间商，索引为0
中间商与数组的值比力，从索引0开始向后依次比力，每次比力后更新中间商的索引为较大值(或较小值)的索引，找到极值(MAX/min)，把极值与目标位置(arr.Length-n-1)互换位置(如果是升序分列，就把MAX放在末尾)
这样比力n轮，每轮比力完重置中间商的索引为0，再继续比力，后续每轮的比力只需i从1遍历到数组长度-n即可(第0个不需要和自己比力，末尾的已经排序完不需要再比力)

#region 3
static int[] CalculateArr(int[] arr){
if( arr.Length == 0 )
{
Console.WriteLine("数组不能为空");
return new int[0];
}
int sum = 0, max = arr[0], min = arr[0], average = 0;
for (int i = 0; i < arr.Length; i++)
{
sum += arr[i];
max = (max >= arr[i]) ? max : arr[i];
min = (min <= arr[i]) ? min : arr[i];
}
average = sum / arr.Length;
int[] result = { sum, max, min, average };
return result;
}
#endregion

复制代码

习题

#region 4
static bool IsPrime(int num){
for(int i = 2; i <= num; i++){
if(num%i == 0) return false;
}
return true;
}
#endregion

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。

欢迎光临 qidao123.com技术社区-IT企服评测·应用市场 (https://dis.qidao123.com/)