几种判断整数是偶数（Even）的算法对比

一个整数能被2整除，这个数就是偶数，

如果不能被2整除【余数为1】，这个数就是奇数

列举出几种判断某数是否偶数的方式 以及执行几万次，计算其算法用时。

第一种：取余 即 num%2==0

第二种，位运算符&  即 (num&1)==0

第三种，异或运算符^ 即 (num^1) == num+1

异或^也是将数字转换成二进制运算，只要两者不同才为1，否则为0（运算规则：0^0=0; 0^1=1; 1^0=1; 1^1=0;）,011^001=010等价于十进制的2，所以为奇数，偶数运算后等于本身加1.

第四种，循环（迭代器）

     每次减去2，直到为1 或 0 为止               

第五种，递归

    return IsEven(num - 2)，直到为1 或 0 为止

新建控制台应用程序PredicateEvenAndOddDemo，

测试源程序如下：

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace PredicateEvenAndOddDemo
{
    /// <summary>
    /// 一个判断某个数是奇数(Odd) 还是 偶数(Even)的示例
    /// </summary>
    class Program
    {
        /// <summary>
        /// 最大测试数，可根据实际情况进行修改
        /// </summary>
        static int maxNumber = 90000;
        static void Main(string[] args)
        {
            Console.SetWindowSize(120, 50);
            Task taskRecursion = null;
            //考虑到递归数太大会导致堆栈溢出
            if (maxNumber <= 20000)
            { 
                taskRecursion = Task.Run(() => { AlgorithmTimespan(IsEvenByRecursion, nameof(IsEvenByRecursion)); });
            }
            Task taskIterator = Task.Run(() => { AlgorithmTimespan(IsEvenByIterator, nameof(IsEvenByIterator)); });
            Task taskRemainder = Task.Run(() => { AlgorithmTimespan(IsEvenByRemainder, nameof(IsEvenByRemainder)); });
            Task taskOperatorAnd = Task.Run(() => { AlgorithmTimespan(IsEvenByOperatorAnd, nameof(IsEvenByOperatorAnd)); });
            Task taskOperatorXOR = Task.Run(() => { AlgorithmTimespan(IsEvenByOperatorXOR, nameof(IsEvenByOperatorXOR)); });
            if (maxNumber <= 20000)
            {
                Task.WaitAll(taskRemainder, taskOperatorAnd, taskOperatorXOR, taskIterator, taskRecursion);
            }
            else
            {
                Task.WaitAll(taskRemainder, taskOperatorAnd, taskOperatorXOR, taskIterator);
            }
            Console.ReadLine();
        }

        /// <summary>
        /// 算法用时
        /// </summary>
        /// <param name="PredicateMethod">判定是否是偶数的方法</param>
        /// <param name="methodName"></param>
        static void AlgorithmTimespan(Func<int, bool> PredicateMethod, string methodName)
        {
            Stopwatch stopwatch = Stopwatch.StartNew();
            for (int number = 0; number < maxNumber; number++)
            {
                bool isEven = PredicateMethod(number);
                if (number >= maxNumber - 3)
                {
                    Console.WriteLine($"使用方法【{methodName}】，数字【{number}】是【{(isEven ? "偶数" : "奇数")}】.");
                }
            }
            Console.WriteLine($"【{methodName.PadRight(20)}】，对【{maxNumber}】个数字进行奇偶判定,用时【{stopwatch.Elapsed.TotalMilliseconds}】ms");
        }

        /// <summary>
        /// 【判断是否偶数】方法一：除以2后判断余数是否为0
        /// </summary>
        /// <param name="number"></param>
        /// <returns></returns>
        static bool IsEvenByRemainder(int number)
        {
            number = Math.Abs(number);
            return number % 2 == 0;
        }

        /// <summary>
        /// 【判断是否偶数】方法二：使用与操作符【And】
        /// </summary>
        /// <param name="number"></param>
        /// <returns></returns>
        static bool IsEvenByOperatorAnd(int number)
        {
            number = Math.Abs(number);
            return (number & 1) == 0;
        }

        /// <summary>
        /// 【判断是否偶数】方法三：使用异或操作符【XOR】
        /// 偶数转化成二进制，最低位一定为0
        /// </summary>
        /// <param name="number"></param>
        /// <returns></returns>
        static bool IsEvenByOperatorXOR(int number)
        {
            number = Math.Abs(number);
            return (number ^ 1) == number + 1;
        }

        /// <summary>
        /// 【判断是否偶数】方法四：使用迭代器【循环】,每次减少2，直到小于2为止
        /// </summary>
        /// <param name="number"></param>
        /// <returns></returns>
        static bool IsEvenByIterator(int number)
        {
            number = Math.Abs(number);
            while (number > 1)
            {
                number = number - 2;
            }
            return number == 0;
        }

        /// <summary>
        /// 【判断是否偶数】方法五：使用递归，每次减少2，直到小于2为止
        /// </summary>
        /// <param name="number"></param>
        /// <returns></returns>
        static bool IsEvenByRecursion(int number)
        {
            number = Math.Abs(number);
            if (number == 0)
            {
                return true;
            }
            else if (number == 1)
            {
                return false;
            }
            return IsEvenByRecursion(number - 2);
        }
    }
}

运行截图如下：

一般来说：

算法用时：递归 > 循环 > 四则运算 > 位运算

其中 四则运算 与 位运算 并没有很大的差别。反而循环次数的多少会严重影响算法优劣，其中递归的堆栈操作占用

【90000】个运行结果

 【20000】个运行结果