[Unity基础]一些算法

1.矩形碰撞检测

假如用左下点与右上点这两个点表示一个矩形，那么现在有两个矩形：

{(minX1,minY1),(maxX1,maxY1)}

{(minX2,minY2),(maxX2,maxY2)}

如果两个矩形相交，则：

minX = max(minX1,minX2)

minY = max(minY1,minY2)

maxX = min(maxX1,maxX2)

maxY = min(maxY1,maxY2)

相交的矩形坐标为：

{(minX,minY),(maxX,maxY)}

如果计算的矩形不相交，则满足：

minX > maxX 或者 minY > maxY

2.洗牌算法与排序

Random.Next()  返回一个非负随机整数。

public virtual int Next()

Random.Next(Int32)  返回一个小于所指定最大值的非负随机整数。

public virtual int Next(
	int maxValue
)

Random.Next(Int32,Int32)  返回在指定范围内的任意整数(可以取下限值但不可以取上限值)。

public virtual int Next(
	int minValue,
	int maxValue
)

int.Parse(string)

using System;
using System.Collections.Generic;
using System.Text;

namespace ConsoleApplication2
{
    class Program
    {
        public static void Main()
        {
            Convert("  179  ");
            Convert(" -204 ");
            Convert(" +809 ");
            Convert("  178.3");
            Console.ReadLine();
        }

        private static void Convert(string value)
        {
            try
            {
                int number = int.Parse(value);//将数字的字符串表示形式转换为它的等效 32 位有符号整数。
                Console.WriteLine("Converted '{0}' to {1}.", value, number);
            }
            catch (FormatException)
            {
                Console.WriteLine("Unable to convert '{0}'.", value);
            }
        }

        // This example displays the following output to the console:
        //       Converted '  179  ' to 179.
        //       Converted ' -204 ' to -204.
        //       Converted ' +809 ' to 809.
        //       Unable to convert '  178.3'.
    }
}

int.CompareTo(int)

using System;
using System.Collections.Generic;
using System.Text;

namespace ConsoleApplication3
{
    class Program
    {
        static void Main(string[] args)
        {
            int a = 10;
            int b = 8;
            int c = 10;
            int d = 12;

            Console.WriteLine(a.CompareTo(b));//大于 返回1
            Console.WriteLine(a.CompareTo(c));//等于 返回0
            Console.WriteLine(a.CompareTo(d));//小于 返回-1
            Console.ReadLine();
        }
    }
}

List.Sort()  

(这里为什么int.CompareTo能起到排序的作用呢？int.CompareTo返回-1,0,1这三种值，通过对List进行遍历，前后元素进行比较，如果返回0，则前后位置不变，如果返回-1或者1则位置调换，从而起到排序的作用，类似于冒泡算法)

using System;
using System.Collections.Generic;
using System.Text;

namespace ConsoleApplication4
{
    class Program
    {
        static void Main(string[] args)
        {
            List<int> list = new List<int>();
            list.Add(-2);
            list.Add(10);
            list.Add(8);
            list.Add(6);
            list.Add(4);

            //1
            list.Sort();
            Print(list);//输出-2，4，6，8，10 从小到大排序

            //2
            list.Sort
            (
                delegate(int a, int b)
                {
                    return a.CompareTo(b);
                }
            );
            Print(list);//输出-2，4，6，8，10 从小到大排序

            //3
            list.Sort((a, b) => b.CompareTo(a));
            Print(list);//输出10，8，6，4，-2 从大到小排序

            Console.ReadLine();
        }

        static void Print(List<int> list)
        {
            for (int i = 0; i < list.Count; i++)
                Console.WriteLine("{0}",list[i]);
            Console.WriteLine();
        }
    }
}

//

洗牌算法一：使用数组

using System;
using System.Collections.Generic;
using System.Text;

namespace ConsoleApplication5
{
    class Program
    {
        static void Main(string[] args)
        {
            int[] array = new int[10];
            for (int i = 0; i < array.Length; i++)
            {
                array[i] = i + 1;
            }

            Random random = new Random();
            for (int i = 0; i < array.Length; i++)//打乱的次数
            {
                int randomIndex = random.Next(0, array.Length);//Next(int,int)只能取下限不能取上限

                int temp = array[i];
                array[i] = array[randomIndex];
                array[randomIndex] = temp;
            }

            foreach (int a in array)
            {
                Console.WriteLine(a);
            }
            Console.ReadLine();
        }
    }
}

洗牌算法二：使用list

using System;
using System.Collections.Generic;
using System.Text;

namespace ConsoleApplication6
{
    class Program
    {
        static void Main(string[] args)
        {
            List<int> originList = new List<int>();
            List<int> reshuffleList = new List<int>();
            for (int i = 0; i < 10; i++)
            {
                originList.Add(i + 1);
            }

            Random random = new Random();
            int count = originList.Count;
            for (int i = 0; i < count; i++)
            {
                int randomIndex = random.Next(0,originList.Count);
                reshuffleList.Add(originList[randomIndex]);
                originList.RemoveAt(randomIndex);
            }

            for (int i = 0; i < reshuffleList.Count; i++)
            {
                Console.WriteLine(reshuffleList[i]);
            }
            Console.ReadLine();
        }
    }
}

排序

reshuffleList.Sort();//从小到大排序

reshuffleList.Sort
            (
                (a,b) => b.CompareTo(a)
            );//从大到小排序

以上的是int类型的排序，如果是string类型的排序呢：

1.如果string是数字转换过来的，则用int.Parse(string)结合List.Sort()

2.将List转换为Array，然后Array.Sort()