我使用多普达钻石按照上面的设置已经成功上网。其中稍微注意一下的地方如下：
1.钻石网卡的名称于S1一致。
2.IP设置的时候可以只设置首选DNS IP自动获取。
3.DNS的值设置为连接到的无线路由的网关，比如我设置的就是192.168.0.1

class BmpAdjuster
    {
        public delegate ColorPalette PaletteAdjustEvent(ColorPalette plt);
        public unsafe delegate void ConvertScanLineEvent(IntPtr srcLine, IntPtr dstLine, int width, int srcPixBit, int dstPixBit, Bitmap srcBmp, Bitmap dstBmp);

        public static void AdjustColor(ref Bitmap bmp, PixelFormat format, PaletteAdjustEvent PalleteAdjust, ConvertScanLineEvent ConvertScanLine)
        {
            Rectangle rect = new Rectangle(0, 0, bmp.Width, bmp.Height);
            Bitmap bmpOut = new Bitmap(bmp.Width, bmp.Height, format);
            Graphics g=Graphics.FromImage(bmp);
            bmpOut.SetResolution(g.DpiX, g.DpiY);
            g.Dispose();
            bmpOut.Palette = PalleteAdjust(bmpOut.Palette);

            PixelFormat srcFmt = bmp.PixelFormat;
            PixelFormat dstFmt = bmpOut.PixelFormat;
            int srcPixBit = GetPixelSize(srcFmt);
            int dstPixBit = GetPixelSize(dstFmt);

            BitmapData srcData = null;
            BitmapData dstData = null;
            try
            {
                srcData = bmp.LockBits(rect, ImageLockMode.ReadOnly, srcFmt);
                dstData = bmpOut.LockBits(rect, ImageLockMode.WriteOnly, dstFmt);

                unsafe
                {
                    byte* srcLine = (byte*)srcData.Scan0.ToPointer();
                    byte* dstLine = (byte*)dstData.Scan0.ToPointer();
                    for (int L = 0; L < srcData.Height; L++)
                    {
                        ConvertScanLine((IntPtr)srcLine, (IntPtr)dstLine, srcData.Width, srcPixBit, dstPixBit, bmp, bmpOut);

                        srcLine += srcData.Stride;
                        dstLine += dstData.Stride;
                    }
                }
            }
            finally
            {
                bmp.UnlockBits(srcData);
                bmpOut.UnlockBits(dstData);
            }

            bmp = bmpOut;
        }

        internal static int GetPixelSize(PixelFormat format)
        {
            switch (format)
            {
                case PixelFormat.Format16bppRgb555: return 16;
                case PixelFormat.Format16bppRgb565: return 16;
                case PixelFormat.Format24bppRgb: return 24;
                case PixelFormat.Format32bppRgb: return 32;
                case PixelFormat.Format1bppIndexed: return 1;
                case PixelFormat.Format4bppIndexed: return 4;
                case PixelFormat.Format8bppIndexed: return 8;
                case PixelFormat.Format16bppArgb1555: return 16;
                case PixelFormat.Format32bppPArgb: return 32;
                case PixelFormat.Format16bppGrayScale: return 16;
                case PixelFormat.Format48bppRgb: return 48;
                case PixelFormat.Format64bppPArgb: return 64;
                case PixelFormat.Canonical: return 32;
                case PixelFormat.Format32bppArgb: return 32;
                case PixelFormat.Format64bppArgb: return 64;
            }
            return 0;
        }

        public unsafe static void Monochrome(ref Bitmap bmp)
        {
            AdjustColor(ref bmp, PixelFormat.Format1bppIndexed,
                new PaletteAdjustEvent(SetBlackWhitePallete),
                new ConvertScanLineEvent(ConvertBlackWhiteScanLine));
        }

        static ColorPalette SetBlackWhitePallete(ColorPalette plt)
        {
            plt.Entries[0] = Color.Black;
            plt.Entries[1] = Color.White;
            return plt;
        }

        unsafe static void ConvertBlackWhiteScanLine(IntPtr srcLine, IntPtr dstLine, int width, int srcPixBit, int dstPixBit, Bitmap srcBmp, Bitmap dstBmp)
        {
            byte* src = (byte*)srcLine.ToPointer();
            byte* dst = (byte*)dstLine.ToPointer();
            int srcPixByte = srcPixBit / 8;
            int x, t = 0;
            //int v = 0;
            //int middle=200 * 256;
            for (x = 0; x < width; x++)
            {               
                t = (t << 1) | (src[0] == 0 ? 0 : 1);
                //v = 28 * src[0] + 151 * src[1] + 77 * src[2];
                //t = (t << 1) | (v > middle ? 1 : 0);
                src += srcPixByte;

                if (x % 8 == 7)
                {
                    *dst = (byte)t;
                    dst++;
                    t = 0;
                }
            }

            if ((x %= 8) != 7)
            {
                t <<= 8 - x;
                *dst = (byte)t;
            }
        }

        public static void Gray(ref Bitmap bmp)
        {
            AdjustColor(ref bmp, PixelFormat.Format8bppIndexed,
                new PaletteAdjustEvent(SetGrayPallete),
                new ConvertScanLineEvent(ConvertGaryScanLine));
        }

        static ColorPalette SetGrayPallete(ColorPalette plt)
        {
            for (int i = plt.Entries.Length - 1; i >= 0; i--)
                plt.Entries[i] = Color.FromArgb(i, i, i);
            return plt;
        }

        unsafe static void ConvertGaryScanLine(IntPtr srcLine, IntPtr dstLine, int width, int srcPixBit, int dstPixBit, Bitmap srcBmp, Bitmap dstBmp)
        {
            byte* src = (byte*)srcLine.ToPointer();
            byte* dst = (byte*)dstLine.ToPointer();
            int srcPixByte = srcPixBit / 8;

            for (int x = 0; x < width; x++)
            {
                *dst = (byte)((28 * src[0] + 151 * src[1] + 77 * src[2]) >> 8);
                src += srcPixByte;
                dst++;
            }
        }

    }

        private void PaintBlocks(Graphics g)
        {
            for (int y = ZERO; y < _height; y++)
            {
                for (int x = ZERO; x < _width; x++)
                {
                    _blocks[y, x].Paint(null, g);
                }
            }
        }

        private void GameFrame_MouseClick(object sender, MouseEventArgs e)
        {
            if (GameState == GameState.Ready)
            {
                GameStart();
            }
            else
            {
                if (GameState != GameState.Started)
                {
                    return;
                }
            }

            int x = e.X / Block.Width;
            int y = e.Y / Block.Width;
            Block block = _blocks[y, x];

            if (block.Bounds.Contains(e.Location))
            {
                if (e.Button == MouseButtons.Right)
                {
                    if (block.State != Block.BlockState.Open)
                    {
                        block.FlagBlock();
                        if (block.State == Block.BlockState.Flag)
                        {
                            _flagNum++;
                            if (block.Bomb)
                            {
                                RightFlagNum++;
                            }
                        }
                        else
                        {
                            _flagNum--;
                            if (block.Bomb)
                            {
                                RightFlagNum--;
                            }
                        }
                    }
                }

                if (e.Button == MouseButtons.Left)
                {
                    if (block.State == Block.BlockState.Close)
                    {
                        OpenBlock(x, y);
                    }
                }
            }

            if (OnGamingClick != null)
            {
                OnGamingClick(this, new EventArgs());
            }
        }

        private void OpenBlock(int x, int y)
        {
            if (x < ZERO || y < ZERO || x >= _width || y >= _height)
            {
                return;
            }
           
            Block block = _blocks[y, x];

            if (block.State != Block.BlockState.Close)
            {
                return;
            }

            block.OpenBlock();

            if (block.Bomb)
            {
                GameEnd();
                return;
            }
            OpenedBlockNum++;
            if (block.Num == ZERO)
            {
                OpenBlock(x - 1, y - 1);
                OpenBlock(x, y - 1);
                OpenBlock(x + 1, y - 1);
                OpenBlock(x - 1, y);
                OpenBlock(x + 1, y);
                OpenBlock(x - 1, y + 1);
                OpenBlock(x, y + 1);
                OpenBlock(x + 1, y + 1);
            }
        }

        public void Showbomb()
        {
            for (int y = ZERO; y < _height; y++)
            {
                for (int x = ZERO; x < _width; x++)
                {
                    Block block = _blocks[y, x];
                    if (block.Bomb && block.State!=Block.BlockState.Flag)
                    {
                        block.OpenBlock();
                    }
                }
            }
            return;
        }

        private bool _clickDown = false;
        private Point _lastLocation = new Point();
        private void GameFrame_MouseDown(object sender, MouseEventArgs e)
        {
            if (GameState != GameState.Ready && GameState != GameState.Started)
            {
                return;
            }
            _clickDown = true;
            int x = e.X / Block.Width;
            int y = e.Y / Block.Width;
            if (x < ZERO || y < ZERO || x >= _width || y >= _height)
            {
                return;
            }
            _lastLocation = new Point(x, y);
            Block block = _blocks[y, x];
            block.OnBlockClickDown();
        }

        private void GameFrame_MouseMove(object sender, MouseEventArgs e)
        {
            if (GameState != GameState.Ready && GameState != GameState.Started)
            {
                return;
            }
            if (_clickDown)
            {
                int x = e.X / Block.Width;
                int y = e.Y / Block.Width;               
               
                if (!_lastLocation.Equals(e.Location))
                {
                    Block b = _blocks[_lastLocation.Y, _lastLocation.X];
                    b.OnBlockClickUp();
                    if (e.X < ZERO || e.Y < ZERO || x < ZERO || y < ZERO || x >= _width || y >= _height)
                    {
                        return;
                    }
                    Block block = _blocks[y, x];
                    _lastLocation = new Point(x, y);
                    block.OnBlockClickDown();
                }
            }
        }

        private void GameFrame_MouseUp(object sender, MouseEventArgs e)
        {
            if (GameState != GameState.Ready && GameState != GameState.Started)
            {
                return;
            }
            _clickDown = false;
        }
    }

终于完了

    public partial class GameFrame : UserControl
    {
        private Color _defBackColor = Color.FromArgb(0x80, 0x80, 0x80);
        //private const int SPACE_WIDTH = ZERO;
        private const int ZERO = 0;
        private const int ONE_SEC = 1000;

        public EventHandler OnGameInitialized = null;
        public EventHandler OnGemeStart = null;
        public EventHandler OnGameEnd = null;
        public EventHandler OnGameVictory = null;
        public EventHandler OnGamingClick = null;
        public EventHandler OnGameTick = null;

        private Block[,] _blocks = null;
        private int _width = ZERO;
        private int _height = ZERO;

        private GameState _gameState = GameState.Ready;

        internal GameState GameState
        {
            get { return _gameState; }
            set
            {
                _gameState = value;
                switch (_gameState)
                {
                    case GameState.Ready:
                        _timer.Enabled = false;
                        break;
                    case GameState.Started:
                        _timer.Enabled = true;
                        break;
                    case GameState.Victory:
                        _timer.Enabled = false;
                        break;
                    case GameState.Failed:
                        _timer.Enabled = false;
                        break;
                }
            }
        }

        private int _bombNum = ZERO;

        public int BombNum
        {
            get { return _bombNum; }
            set { _bombNum = value; }
        }

        private int _rightFlagNum = ZERO;

        public int RightFlagNum
        {
            get { return _rightFlagNum; }
            set
            {
                _rightFlagNum = value;
                if (_rightFlagNum == BombNum)
                {
                    GameVictory();
                }
            }
        }

        private int _openedBlockNum = ZERO;

        public int OpenedBlockNum
        {
            get { return _openedBlockNum; }
            set
            {
                _openedBlockNum = value;
                if (_openedBlockNum == _width * _height - _bombNum)
                {
                    GameVictory();
                }
            }
        }

        private int _flagNum = ZERO;

        public int FlagNum
        {
            get { return _flagNum; }
            set { _flagNum = value; }
        }

        private Timer _timer = new Timer();
        private int _sec = ZERO;

        public int Sec
        {
            get { return _sec; }
            set { _sec = value; }
        }

        private void timer_Tick(object sender, EventArgs e)
        {
            _sec++;
            if (OnGameTick != null)
            {
                OnGameTick(this, new EventArgs());
            }
        }

        public GameFrame()
        {
            InitializeComponent();

            this.BackColor = _defBackColor;
           
            this.BorderStyle = BorderStyle.FixedSingle;
            Block.Owner = this;
            Block.BtImg = Image.FromFile("blockClosed.gif");
            Block.FlagImg = Image.FromFile("flag.gif");
            Block.BombImg = Image.FromFile("bomb.gif");
            Block.BackGroundImg = Image.FromFile("backGround.gif");

            _timer.Interval = ONE_SEC;
            _timer.Tick += new EventHandler(timer_Tick);
        }

        public GameFrame(int blockWidth)
        {
            InitializeComponent();
            Block.Owner = this;
            Block.Width = blockWidth;
        }

        public void InitGame(int width, int height, int bombNum)
        {
            if (bombNum >= (width * height))
            {
                throw new Exception("要厚道!不能设置太多的地雷!");
            }

            this._bombNum = bombNum;
            this.Width = width * Block.Width ;
            this.Height = height * Block.Width;
            this._blocks = new Block[height, width];
            this._width = width;
            this._height = height;
            this.FormatBlocks(_blocks);

            GameState = GameState.Ready;

            this.Sec = ZERO;
            this.OpenedBlockNum = ZERO;
            this.FlagNum = ZERO;
            this.RightFlagNum = ZERO;

            this.Refresh();

            if (OnGameInitialized != null)
            {
                OnGameInitialized(this, new EventArgs());
            }
        }

        public void GameStart()
        {
            if (OnGemeStart != null)
            {
                OnGemeStart(this, new EventArgs());
            }
            GameState = GameState.Started;
        }

        private void GameVictory()
        {
            GameState = GameState.Victory;
            if (OnGameVictory != null)
            {
                OnGameVictory(this, new EventArgs());
            }
        }

        public void GameEnd()
        {
            GameState = GameState.Failed;
            Showbomb();
            if (OnGameEnd != null)
            {
                OnGameEnd(this, new EventArgs());
            }           
        }

        private void FormatBlocks(Block[,] blocks)
        {
            for (int y = ZERO; y < _height; y++)
            {
                for (int x = ZERO; x < _width; x++)
                {
                    blocks[y, x] = new Block(x * Block.Width , y * Block.Width, false);                   
                }
            }

            BombSetup(blocks, _bombNum);
            BlockNumSetup(blocks);
        }

        private void BombSetup(Block[,] blocks,int bombNum)
        {
            Random rd = new Random((int)DateTime.Now.Ticks);
            int num = ZERO;
            while (num != bombNum)
            {
                int x = rd.Next(ZERO, _width);
                int y = rd.Next(ZERO, _height);
                Block block = _blocks[y, x];
                if (!block.Bomb)
                {
                    block.Bomb = true;
                    num++;
                }
            }
        }

        private void BlockNumSetup(Block[,] blocks)
        {
            for (int y = ZERO; y < _height; y++)
            {
                for (int x = ZERO; x < _width; x++)
                {
                    Block block = _blocks[y, x];
                    if (!block.Bomb)
                    {
                        SetBlockNum(x, y);
                    }
                }
            }
        }

        private void SetBlockNum(int x,int y)
        {
            Block block = _blocks[y, x];
            int num = ZERO;
            if (GetBlockHasBomb(x - 1, y - 1))
            {
                num++;
            }
            if (GetBlockHasBomb(x, y - 1))
            {
                num++;
            }
            if (GetBlockHasBomb(x + 1, y - 1))
            {
                num++;
            }
            if (GetBlockHasBomb(x - 1, y))
            {
                num++;
            }
            if (GetBlockHasBomb(x + 1, y))
            {
                num++;
            }
            if (GetBlockHasBomb(x - 1, y + 1))
            {
                num++;
            }
            if (GetBlockHasBomb(x, y + 1))
            {
                num++;
            }
            if (GetBlockHasBomb(x + 1, y + 1))
            {
                num++;
            }
            block.Num = num;
        }

        private bool GetBlockHasBomb(int x,int y)
        {
            if (x < ZERO || y < ZERO || x >= _width || y >= _height)
            {
                return false;
            }
           
            Block block = _blocks[y, x];
            return block.Bomb;
        }

还放不下..

程序主要是一个Block类和一个GameFrame类 界面窗体只需要做初始化和响应事件就可以了 还没有做双键按下的效果 比较原始

class Block
    {
        private const int WIDTH_DEF = 16;
        private Color[] _numColors = new Color[] {Color.Blue,Color.Green,Color.DarkRed,Color.DeepSkyBlue,Color.DimGray,Color.DarkOrange,Color.Brown,Color.Black };

        private Color _defColor = Color.White;
        private Color _defBackColor = Color.FromArgb(0xC0, 0xC0, 0xC0);

        private static Image _btImg = null;

        public static Image BtImg
        {
            get { return Block._btImg; }
            set { Block._btImg = value; }
        }

        private static Image _bombImg = null;

        public static Image BombImg
        {
            get { return Block._bombImg; }
            set { Block._bombImg = value; }
        }

        private static Image _flagImg = null;

        public static Image FlagImg
        {
            get { return Block._flagImg; }
            set { Block._flagImg = value; }
        }

        private static Image _backGroundImg = null;

        public static Image BackGroundImg
        {
            get { return Block._backGroundImg; }
            set { Block._backGroundImg = value; }
        }

        public enum BlockState
        {
            Close,
            Open,
            Flag
        };

        private BlockState _state = BlockState.Close;

        public BlockState State
        {
            get { return _state; }
            set { _state = value; }
        }

        private Rectangle _rct;

        public Rectangle Bounds
        {
            get { return _rct; }
            set { _rct = value; }
        }

        private bool _bomb = false;

        public bool Bomb
        {
            get { return _bomb; }
            set { _bomb = value; }
        }
       
        private int _num = 0;

        public int Num
        {
            get { return _num; }
            set
            {
                if (!_bomb)
                { _num = value; }
            }
        }

        private static int _width = WIDTH_DEF;

        public static int Width
        {
            get { return _width; }
            set { _width = value; }
        }

        //public Block() { }
        private static GameFrame _owner = null;

        public static GameFrame Owner
        {
            get { return Block._owner; }
            set { Block._owner = value; }
        }

        public Block(int x,int y,bool bomb)
        {
            _rct.X = x;
            _rct.Y = y;
            _rct.Width = _width;
            _rct.Height = _width;
            _bomb = bomb;
        }

        public Block(int x, int y, int num)
        {
            _rct.X = x;
            _rct.Y = y;
            _rct.Width = _width;
            _rct.Height = _width;
            _bomb = false;
            _num = num;
        }

        public void Paint(object sender, Graphics g)
        {
            g.DrawImage(_backGroundImg, this.Bounds.Location);
            switch (_state)
            {
                case BlockState.Close:
                    g.DrawImage(_btImg, this.Bounds.Location);
                    break;
                case BlockState.Flag:
                    g.DrawImage(_flagImg, this.Bounds.Location);
                    break;
                case BlockState.Open:
                    switch(_bomb)
                    {
                        case false:
                            if (_num != 0)
                            {
                                Point p=this.Bounds.Location;
                                p.X+=1;
                                g.DrawString(_num.ToString(), new Font("宋体", 12, FontStyle.Bold), new SolidBrush(_numColors[Num - 1]), p);
                            }
                            else
                            {
                                g.DrawImage(_backGroundImg, this.Bounds.Location);
                            }
                            break;
                        case true:
                            g.DrawImage(_bombImg, this.Bounds.Location);
                            break;
                    }
                    break;
            }           
        }

        public void OnBlockClickDown()
        {
            Graphics g = Block.Owner.CreateGraphics();
            if (State == BlockState.Close)
            {
                g.DrawImage(_backGroundImg, this.Bounds.Location);
            }
        }

        public void OnBlockClickUp()
        {
            Graphics g = Block.Owner.CreateGraphics();
            if (State == BlockState.Close)
            {
                g.DrawImage(_btImg, this.Bounds.Location);
            }
        }

        public void Refresh()
        {
            Graphics g = Block.Owner.CreateGraphics();
            Paint(null, g);
        }

        public void OpenBlock()
        {
            this.State = BlockState.Open;
            this.Refresh();
        }

        public void FlagBlock()
        {
            this.State = this.State == BlockState.Flag ? BlockState.Close : BlockState.Flag;
            this.Refresh();
        }
    }

放不下了...

    class Cysf
    {
        private int _max = 0;

        private int _n = 0;

        public Cysf(int max,int n)
        {
            _max = max;
            _n = n;
        }

        public int GetLast()
        {
            int m = 0;
            ArrayList list = new ArrayList();
            InitList(ref list, _max);
            while (list.Count > 1)
            {
                for (int i = 0; i < list.Count;)
                {
                    if (++m % _n == 0)
                    {
                        Console.WriteLine(Convert.ToInt32(list[i]));
                        list.RemoveAt(i);
                    }
                    else
                    {
                        ++i;
                    }
                }
            }
            return Convert.ToInt32(list[0]);
        }

        private void InitList(ref ArrayList list, int max)
        {
            for (int i = 1; i <= max; i++)
            {
                list.Add(i);
            }
        }
    }

BitTree CreateBiTree(void)
{
BitTree bt;
TElemType x;
scanf("%d", &x);
if(x == -1)
{
bt = NULL;
}
else
{
bt = (BitTree)malloc(sizeof(BitNode));
bt-> data = x;
bt-> lchild = CreateBiTree();
bt-> rchild = CreateBiTree();
}

return bt;
}

下面是我的分析:

输入1
建立节点A
此时执行节点A的bt-> lchild = CreateBiTree();
输入2
建立节点B
执行节点B的bt-> lchild = CreateBiTree();
输入3
建立C
执行节点C的bt-> lchild = CreateBiTree();
输入-1
f(x == -1)
{
bt = NULL;
}
return bt;

返回空 即节点C完成左子树
节点C的bt-> lchild = CreateBiTree(); 该句执行完毕 返回为空
此时执行节点C的bt-> rchild = CreateBiTree(); 建立右子树
输入-1
返回 节点C完成右子树
此时
bt-> lchild = CreateBiTree();   ↓
bt-> rchild = CreateBiTree();   ↓
}                                               ↓
return bt;                                 ↓
}
返回完整节点C
此时节点C完成 也就是节点B的左子树完成 开始构造节点B的右子树
节点B的bt-> lchild = CreateBiTree(); 完成
执行节点B的bt-> rchild = CreateBiTree();
输入4
构造节点D
输入 -1
返回 完成节点D左子树
输入 -1
返回 完成节点D右子树
此时节点B完成
也就是节点A的左子树完成
开始构造节点A的右子树
如此这般。。。。

                                A1
                B2                               E5
         C3         D4                  F6          G7
    空      空 空     空          空     空    空     空