public static void Sort(ref int[] numbers)
        {
            int lastSwapIdx = numbers.Length;
            for(int i = 0; i < numbers.Length; i++)
            {
                int curLastSwapIdx = numbers.Length - 1 - i; // 当前轮次最后一次交换的位置，这个位置之后的位置都是排好序的
                for (int k = 0; k< lastSwapIdx && k < numbers.Length - 1 - i; k++)
                {
                    if (numbers[k] > numbers[k + 1])
                    {
                        Swap(ref numbers[k], ref numbers[k + 1]);
                        curLastSwapIdx = k;
                    }
                }
                lastSwapIdx = curLastSwapIdx;
            }
        }

        public static void Swap(ref int a, ref int b)
        {
            var temp = a;
            a = b;
            b= temp;
        }

冒泡排序优化，curLastSwapIdx 记录每个轮次最后一次交换的位置；最后一次交换说明之后的数组就是有序的了。
下次排序的时候只要排到 curLastSwapIdx 处就可以了。
例如数组 3，2，1，5，6，7
第一次交换完成后 2，1，3，5，6，7；此时 curLastSwapIdx = 2；
下一轮只要交换 2，1 就完成了；

还可以加上唐老师的方法，判断是否没有交换了

地图结构体

n个格子——数组    ①  

地图初始化构造函数       ②

画地图的方法（函数）     ③

这三点相当于——一个关于地图的“结构体”

struct Map

{

public Grid[ ]  grids;//Grid类型的数组

// 构造函数必须初始化上方的变量

//地图有多少个格子，格子的位置。

public Map(int gridNum , int x, int y )

{

grids = new Grid[ gridNum];  

random r = new random();

int randomNum;

for(int i = 0; i<num; i++)

{

randomNum = r.next(0,101);

if( randomNum<=85 || i == 0 ||i ==num -i)

        //相当于normal grid出现的概率为85%

而且第一个格子和最后一个格子一定为normal

{

grid[i].type =E_GridType.normal;

}

else if(....)

{

}

else if(.....)

{

)

else

{

}

//格子的位置

grids[i} =new vector(x,y);

//每次循环都应该按照一定规则去变化位置

二维数组？ 

}

}

绘制地图——绘制玩家

需要重复使用的代码语句块

四种格子 ——格子枚举

enum E_grid

{

normal,

boom,

pause,

tunnel

}

                     格子结构体  

int x,int y ——干脆就新申明一个结构体，来储存格子位置（int x, int y这两个变量）。

struct void vector2//int x, int y

//在unity中，位置的名称为 vector2

{

public int x, 

public int y,

public vector2(int x,int y)

{

this.x =x;

this.y =y;
}

}

//*******************************

//*******************************

//*******************************

struct void grid

{

//变量（格子的类型，格子的位置）

public  E_grid  gridtype;

public  vector2 position;

//构造函数

public grid(int x,int y,E_gridtype  type)

{

position.x = x;

positon.y =y;

this.type = type; 

}

}

不变的红墙——和提示信息

不变的信息

开始场景的逻辑实现

使用函数

开始场景的函数书写

static void beginning()

{

  while(true)

  {

  }

}

多个场景

使用枚举

基础设置

//使用函数来简化在main函数中的代码量

隐藏光标。设置窗口大小和控制台大小

需求分析

目的在于——理清项目的功能需求

整理——流程图

学习面向对象之后——还要制作UML类图

通过流程图来理清 游戏程序 的思路

 一个主循环   三个游戏场景内部的循环

开始场景

游戏场景

while循环之外

不变的基本信息——红墙，玩家形象和属性等

while循环内部 

枚举 

结束场景（和开始场景的代码逻辑相似）

公司的工作流程

对流程图，和类图的逻辑的绘制。——程序思路。

你hao

结构体中的函数不需要加static关键字

ref传入的变量必须初始化，out不用

out传入的变量必须在内部赋值，ref不用

函数写在class或struct中 

return可以提前结束函数逻辑

程序线性执行，从上到下

值类型存储在栈区--系统分配，自动回收，小而快。

应用类型 堆区 手动申请和释放 大而慢

///注释可以让人看到说明

如果是变量，就要类型强转。

一般在namespace语句块声明枚举，也有在class，struct中，不能在函数中

我自己的方法：

 for (int currentIndex = 0; currentIndex < array.Length - 1; currentIndex++)
            {
                int minIndex = currentIndex;
                for (int i = currentIndex + 1; i < array.Length; i++)
                {
                    if (array[minIndex] > array[i]) minIndex = i;
                }
                if (minIndex != currentIndex)
                {
                    int temp = array[currentIndex];
                    array[currentIndex] = array[minIndex];
                    array[minIndex] = temp;
                }
            }

练习题五:

            int[] array = new int[5];
            Random random = new Random();
            for (int i = 0; i < array.Length - 1; i++)
            {
                array[i] = random.Next(0, 101);
            }
            for (int i = 0; i < array.Length; i++)
            {
                Console.Write(array[i] + "\t");
            }
            Console.WriteLine();
            int[] newArray = new int[5];
            for (int i = 0; i < array.Length; i++)
            {
                newArray[4 - i] = array[i];
            }
            array = newArray;
            for (int i = 0; i < array.Length; i++)
            {
                Console.Write(array[i] + "\t");
            }

private：私有

public：公共

ref在函数外部必须要初始化，因为在函数内部ref不必要初始化

out必须在函数内部赋值，但不需要再外部进行初始化

值类型：存储在栈空间 —系统分配，自动回收，小而快

引用类型：存储在堆空间——手动申请和释放，大而慢