终于搞清楚了C#二进制的一些关键操作了,解决了微软面试题，求数组中两两之差绝对值最小的值O(N)最少内存限制的问题!

终于搞清楚了C#二进制的一些关键操作了,解决了微软面试题，求数组中两两之差绝对值最小的值O(N)最少内存限制的问题!

研究了好几天,写出来一个看起来象O(n)的算法,O(nlog)就不用写了.
思路是桶排序O(N)复杂度,为了节省空间,采用了Byte[]数组,1个byte代表8个数字的有无.
回头整理公布一下C#二进制运算的一些重要操作.

C# code

using System;

namespace MinABS
{
    class Program
    {
        static void Main(string[] args)
        {
            int n = 100;
            int[] a = new int
;
            Random rand = new Random();
            int min = int.MaxValue;
            int max = int.MinValue;
            Console.WriteLine("产生了" + n + "个数据的实验数组,");
            Console.WriteLine("本程序适用于int.MinValue到int.MaxValue范围，请自行修改输入的量和范围");
            for (int i = 0; i < n; i++)
            {
                //赋值并且取到最大最小值
                //a[i] = rand.Next(int.MinValue, int.MaxValue);
                 a[i] = rand.Next(-100, 100);
                if (a[i] < min) { min = a[i]; }
                if (a[i] > max) { max = a[i]; }
                 Console.Write(a[i] + " ");                
            }
             Console.WriteLine();
            Console.WriteLine("在O(n)内得到最大最小分别是：");
            Console.WriteLine(max + "和" + min);
            
            long offset = (long)max + Math.Abs((long)min);
            //规划数组的长度。每个byte有8位长
            int len = (int)(offset >> 3) +1 ;
            Byte[] B = new Byte[len];
            int kkkk = 0;
            bool IsSame = false;//是否有重合点标记
           
            //O(n)的时间内分配到了Byte[]中。
            
            for (int i = 0; i < n; i++)
            {
                offset = (long)a[i] - (long)min;
                int index = (int)(offset >> 3);
                int temp = B[index];
                //把末k位变成1
                //把右数第k位变成1 例如：(00101001->00101101,k=3)     x | (1 << (k-1))
             
                int tempOffSet = (1 << (  (int)(offset & 7) ) );
                //判断重合
                if (!IsSame)
                {
                    kkkk = temp & tempOffSet;
                    if ((temp & tempOffSet) >= 1)
                    {
                        IsSame = true;
                        //如果0算最小距离就在这里退出吧。本代码判断重合，但没把0作为结果。                        
                    }
                }
                int bbb = B[index];                
                B[index]  |=  (Byte)(tempOffSet);          
                int aaa = B[index];
  
            }
            //最小距离初始为最大。

            Console.WriteLine("在O(n)的时间内分配到了Byte[]中，正在计算最小距离，请稍候。。。。。");

            long minABS = long.MaxValue;
            long lastIndex = -1;

            //在常数范围内循环，复杂度不增加。最坏的情况是32*int.MaxValue次。

            for (int i = 0; i < B.Length; i++)
            {
                //if (B[i] == 0) { continue; }
                //在常数范围内循环，复杂度不增加。
                for (int k = 0; k < 8; k++)
                {
                    if (((B[i] >> k) & 1) == 1)
                    {
                        if (lastIndex >= 0)
                        {
                            long temp = ((long)i << 3) + k - lastIndex;
                            if (temp < minABS)
                            {
                                minABS = temp;
                               Console.WriteLine("目前得到了最小距离：" + minABS);
                            }
                        }
                        lastIndex = (i << 3) + k;                        
                    }
                }
            }
            if (IsSame)
            { Console.WriteLine("有重合点"); }
            else
            { Console.WriteLine("无重合点"); }

            Console.WriteLine("不考虑重合最小距离是：" + minABS);
            Console.WriteLine("总复杂度是：O(n)");            

            Console.ReadLine();

        }

    }
}