排序笔记

最新推荐文章于 2023-07-01 12:43:50 发布

yuuuuuuukko

最新推荐文章于 2023-07-01 12:43:50 发布

阅读量133

点赞数

分类专栏： Unity

本文链接：https://blog.csdn.net/qq_34343249/article/details/105172444

版权

Unity 专栏收录该内容

14 篇文章 1 订阅

订阅专栏

在这里插入图片描述

选择排序

            for (int currentIndex = 0; currentIndex < array.Length - 1; currentIndex++)
            {
                int MinIndex = currentIndex;//记录位置
                for (int j = currentIndex + 1; j < array.Length; j++)
                {
                    if (array[MinIndex] >= array[j])
                    {
                        MinIndex = j;
                    }
                }
                if (MinIndex != currentIndex)
                {
                int tem = array[currentIndex];
                array[currentIndex] = array[MinIndex];
                array[MinIndex] = tem;
                }
            }

冒泡排序

            for (int currentIndex = 0; currentIndex < array.Length - 1; currentIndex++)
            {
                for (int j = currentIndex + 1; j < array.Length; j++)
                {
                    if (array[currentIndex] >= array[j])
                    {
                    int tem = array[currentIndex];
                    array[currentIndex] = array[currentIndex];
                    array[currentIndex] = tem;
                    }
                }
            }

在这里插入图片描述
二维数组从上往下，从左往右开始数
GetLength() 带参数，0为行数，1为列数

        private static void PrintDoubleArray(Array array)
        {
            for (int row = 0; row < array.GetLength(0); row++)
            {
                for (int column = 0; column < array.GetLength(1); column++)
                {
                    Console.Write(array.GetValue(row, column) + " ");
                }
                Console.WriteLine();
            }
        }
        //private static void 
        /// <summary>
        /// 清零
        /// </summary>
        /// <param name="array"></param>
        /// <returns></returns>

        private static int[] RemoveZero(int[] array)
        {
            //2002
            int[] newArray = new int[array.Length]; //创建一个新数组
            int index = 0;
            for (int i = 0; i < array.Length; i++)
            {
                if (array[i] != 0)
                {
                    newArray[index] = array[i];
                    index++;
                }
            }
            return newArray;

        }
        /// <summary>
        /// 合并元素
        /// </summary>
        /// <param name="array"></param>
        /// <returns></returns>
        public static int[] Merge(int[] array)
        {
            array = RemoveZero(array);
            //for (int column = 0; column < 4; column++)
            //{
            //    Console.Write(array.GetValue(column) + " ");
            //}
            for (int i = 0; i < array.Length - 1; i++) //合并
            {
                if (array[i] != 0 && array[i] == array[i + 1])
                {
                    array[i] += array[i + 1]; //合并
                    array[i + 1] = 0;
                }
            }
            array = RemoveZero(array);
            //for (int column = 0; column < 4; column++)
            //{
            //    Console.Write(array.GetValue(column) + " ");
            //}
            return array;
        }
        private static int[,] MoveLeft(int[,] map) //row 行 column 列
        {
            int[] newArray = new int[map.GetLength(0)];
            for (int row = 0; row < map.GetLength(0); row++)
            {
                for (int column = 0; column < map.GetLength(1); column++)
                {
                    newArray[column] = map[row, column];
                }
                newArray = Merge(newArray);
                for (int column = 0; column < map.GetLength(1); column++)
                {
                    map[row, column] = newArray[column];
                }
            }

            return map;
        }
        private static  int[,] MoveRight(int[,] map)
        {
            int[] newArray = new int[map.GetLength(0)];//创建新数组记录

            for (int row = 0; row < map.GetLength(0); row++)
            {
                for(int column = map.GetLength(1)-1; column >= 0; column--)
                {
                    newArray[3-column] = map[row, column];
                }
                newArray = Merge(newArray);
                for (int column = map.GetLength(1)-1; column >= 0; column--)
                {
                   map[row, column] = newArray[3-column];
                }
            }
            return map;
        }
        private static int[,] MoveUp(int[,] map)
        {
            //从上往下数据
            int[] mergeArray = new int[map.GetLength(0)];
            for (int column = 0; column < map.GetLength(1); column++)
            {
                for (int row = 0; row < map.GetLength(0); row++)
                {
                    mergeArray[row] = map[row, column];
                }
                mergeArray = Merge(mergeArray); //做合并的操作
                for (int row = 0; row < map.GetLength(0); row++)
                {
                    map[row, column] = mergeArray[row];
                }
            }
            return map;
        }
        private static int[,] MoveDown(int[,] map)
        {
            //从下到上拿数据
            int[] mergeArray = new int[map.GetLength(0)];
            for (int column = 0; column < map.GetLength(1); column++)
            {
                for (int row = map.GetLength(0) - 1; row >= 0; row--)
                {
                    mergeArray[3 - row] = map[row, column];
                }
                mergeArray = Merge(mergeArray);
                for (int row = map.GetLength(0) - 1; row >= 0; row--)
                {
                    map[row, column] = mergeArray[3 - row];
                }
            }
            return map;
        }

在这里插入图片描述
将值类型传递给值类型的时候，直接拷贝数据
将值类型传递给引用类型的时候，会在堆中开辟额外的空间，在将引用类型的引用指向堆中的空间
注意：在堆中会开辟三块空间

对字符串每次修改，都会在内存中开辟新的空间，替换栈中的引用

**ToLower()：**得到字符串的小写形式。
**ToUpper()：**得到字符串的大写形式；
**Trim()：**去掉字符串两端的空白。
s1.Equals(s2, StringComparison.OrdinalIgnoreCase)：
两个字符串进行比较不区分大小写的比较。
Split(params char[] separator)：将字符串按照指定的分割符分割为字符串数组；
Split(char[] separator, StringSplitOptions options)):
将字符串按照指定的char分割符分割为字符串数组（ options 取RemoveEmptyEntries的时候移除结果中的空白字符串）；

字符串替换：
string Replace(string oldValue, string newValue) 将字符串中的出现oldValue的地方替换为newValue。
取子字符串：
string Substring(int startIndex):
取从位置startIndex开始一直到最后的子字符串；
string Substring(int startIndex, int length):
取从位置startIndex开始长度为length的子字符串，如果子字符串的长度不足length则报错。
bool Contains(string value)
判断字符串中是否含有子串value
*bool StartsWith(string value)
判断字符串是否以子串value开始；
bool EndsWith (string value)
判断字符串是否以子串value结束；
int IndexOf(string value)：
取子串value第一次出现的位置。
Int IndexOf(string value,int startIndex)
在这里插入图片描述
帧数就是在1秒钟时间里传输的图片的帧数
记住：值类型的数据会跟声明的地方在一起，声明在栈中，数据就存储在栈中，声明在堆中，数据就存储在堆中
声明某个类型，意味着会开辟空间，值类型空间开辟在栈中，数据跟着一起；
引用类型空间开辟在堆中，如果这个引用类型内部存储的是值类型，那么，数据也会跟着在堆中
比如数组 Int [] array = new Int[1]{ 1 }; 内部存储的是Int类型的值
String 数组就不一样了，String 是一个引用类型，所以即使空间也开辟在堆中，但是里面存储的数据并不会跟着开辟的空间，
开辟的那个空间里存储的依然是一个引用，真正的数据是在堆中再开辟一片空间而进行存储的
在这里插入图片描述

枚举值：值类型

在这里插入图片描述
如果要使枚举值多选，就需要将枚举值进行改变，然后再加上【Flags】特性修饰符，表示可以多选
在使用的时候要使用“ | ”按位或，判断的时候要使用 " & "按位与

这样就可以多选，但是因为按位运算符运算之后数字改变了，就需要在判断的时候也改变

            GetInfo(PersonStyle.handsome | PersonStyle.beauty);
           if((style & PersonStyle.beauty) != 0)
            {
                Console.WriteLine("美丽");
            }
           if((style & PersonStyle.handsome) == PersonStyle.handsome)
            {
                Console.WriteLine("帅");
            }
            //枚举类型进行转换
            int num = (int)PersonStyle.beauty;
            string str = PersonStyle.beauty.ToString();
            PersonStyle s1 = (PersonStyle)Enum.Parse(typeof(PersonStyle), "hh");

在这里插入图片描述
构造函数

通过在重载的构造函数中写：this() // 或者：this(name) 可以调用其它构造函数
这样做可以节省代码量
普通属性就是两个方法

引用类型 声明是在栈中开辟一个空间存储引用
new 是在堆中开一一个空间存储数据
一个对象可以使用什么成员，主要看它的类型，声明时的类型决定它能使用什么成员
在这里插入图片描述
加入as Teacher 后程序不会抛出异常，可以进行转换，但是执行 teacher02.Salary = 100 的时候会抛出空指针的异常
因为转换之后的 tercher02 不指向堆中的任何地方

实例方法在被调用时，首先会拿到一个调用者的引用，再去访问这个引用里面的属性，字段等。
而对于静态方法，它拿不到引用，因为它创建的时候可能连对象都没有，所以它只能使用类名来调用，于是，静态方法只能访问静态成员，即已经存在的成员
在这里插入图片描述
注意：第三句，指的是 静态类 不可以被继承，但是不属于 静态类 中的 静态方法 ，静态属性 可以被继承

优点：存对象里面，那么每个对象都有一份，如果存静态域区里，就大家都只有一份，则节省了空间；可以让多个对象维护同一份数据；调用方便；
缺点：同一份数据，多个对象一起访问就会出现并发，
工具类：比如 Math，提供了大量使用的方法，但是不可以创建对象
在这里插入图片描述
小型相关变量：数量小，这样可以节省内存空间，因为是值类型的
但如果数据多，就不要使用结构存储，因为创建一个结构，会在栈中开辟空间，如果数据多，那么New一个结构的时候就会在栈中开辟大量的空间
适用性：当一个数据需要进行多次修改，如果使用类存储，那么每次修改就会在堆中创建新的空间，产生大量垃圾，用结构的话，修改的时候就会直接修改值，不会带来垃圾
结构跟类的区别：

在这里插入图片描述

yuuuuuuukko

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
排序笔记

选择排序 for (int currentIndex = 0; currentIndex < array.Length - 1; currentIndex++) { int MinIndex = currentIndex;//记录位置 for (int j = currentIn...
复制链接

扫一扫