Unity 随笔： 基本算法

如果有说的不对的地方欢迎指正。

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

/// <summary>
/// 基本算法
/// </summary>

///基本的、常用的几种排序算法是我们必须了解的，面对比较复杂难解决的难题，
///我们就需要更为广阔的思路，算法在实际运用中并不是固定的，适合的才是最好的，
///我们应该随着问题环境的变化而变化，找到最佳的突破口。
///
///优秀的算法都是能找到事物特征并且利用好事物特征的算法，不同种类的算法有其自身的理念，
///混用或合用几个算法也是常有的事，理解和知晓是第一步，灵活运用真的不是一朝一夕的事。

public class PrimaryAlgorithm_ZH : MonoBehaviour
{

    //加减法方式 注意：避免两数相加，大小越界
    private void AddAndSubtract(int[] _Nums, int i, int j)
    {
        _Nums[i] += _Nums[j];
        _Nums[j] = _Nums[i] - _Nums[j];
        _Nums[i] = _Nums[i] - _Nums[j];
    }

    //数值置换方式
    private void Replacement(int[] _Nums, int i, int j)
    {
        int temp = _Nums[i];
        _Nums[i] = _Nums[j];
        _Nums[j] = temp;
    }

    //位运算交换方式 可以避免两数相加导致越界
    private void Exchange(int[] _Nums, int i, int j)
    {
        _Nums[i] ^= _Nums[j];
        _Nums[j] ^= _Nums[i];
        _Nums[i] ^= _Nums[j];
    }

    #region O（n^2）时间复杂度，直接插入排序法比冒泡和简单选择排序的性能要好一点点



    #endregion

    /// <summary>
    /// 冒泡排序
    /// </summary>
    public void BubbleSort_High(int[] _Nums)
    {
        for (int i = 0; i < _Nums.Length; i++)
        {
            for (int j = _Nums.Length - 1; j >= i + 1; j--)
            {
                if (_Nums[j - 1] > _Nums[j])
                {
                    AddAndSubtract(_Nums, j - 1, j);
                }
            }
        }
    }

    /// <summary>
    /// 简单选择排序
    /// </summary> 
    public void SelectSort(int[] _Nums)
    {
        int _Min;
        for (int i = 0; i < _Nums.Length; i++)
        {
            _Min = i; //寻找当前剩余待排序列最小的元素
            for (int j = i + 1; j < _Nums.Length; j++)
            {
                if (_Nums[_Min] > _Nums[j])
                {
                    _Min = j;
                }
            }
            //找到之后，才与初始位置上的元素进行交换
            if (_Min != i)
            {
                Exchange(_Nums, i, _Min);
            }
        }
    }


    /// <summary>
    /// 插入排序
    /// </summary> 

    public void StragihtInsertionSort(int[] _Nums)
    {
        int _Temp, j; //用来临时存放待插入元素
        for (int i = 1; i < _Nums.Length; i++)
        {
            //nums[i] 为待插入元素
            if (_Nums[i] < _Nums[i - 1])
            {
                _Temp = _Nums[i];
                //寻找待插入位置 ，j即为待插入位置
                for (j = i - 1; j >= 0 && _Nums[j] > _Temp; j--)
                {
                    _Nums[j + 1] = _Nums[j]; //将从j位置的元素开始往后移
                }
                _Nums[j + 1] = _Temp;
            }
        }
    }



    /// <summary>
    /// 二分查找
    /// </summary>
    /// <param name="_Array"></param>
    /// <param name="_Number"></param>
    /// <returns></returns>
    static int _SearchTree(int[] _Array, int _Number)
    {
        int _Min = 0;
        int _Max = _Array.Length - 1;
        int _Index = -1;
        while (_Max >= _Min)
        {
            int _Result = (_Min + _Max) / 2;
            if (_Array[_Result] == _Number)
            {
                _Index = _Result;
                break;
            }
            else if (_Array[_Result] > _Number)
            {
                _Max = _Result - 1;
            }
            else
            {
                _Min = _Result + 1;
            }
        }
        return _Index;

    }

}

就酱，与君共勉。