数据结构与GDI+的碰撞(C# VS 2008)之Bag

2014年4月27日星期日

最近学习数据结构和GDI+，试着将两者结合在一起做练习，希望能够将数据结构图形化。

1.      编写基本的数据结构类文件DataStructure_Bag.cs，使用数组来实现，可以进行增、删、查、统计、排序等操作。

//FILE://DataStructure_Bag.cs
// CLASS IMPLMENT: class Bag
//
// CONSTRUCTORS for classBag
// Bag():
//   Postcondition: default constructor, generatean instance of the bag class
//   and the capacity of the bag class is 30
//
// Bag(bag_size size):
//   Postcondition: generate an instance of thebag class, and the capacity is
//   decided by the parameter users provide
//
// MODIFICATION MEMBERMETHODS for class Bag
// bool insert(bag_typemember):
//   Precondition: it's not beyond the capacityof the bag
//   Postcondition: if insert successfully returntrue, otherwise false
//
// bool erase(bag_type member):
//   Postcondition: if erase successfully returntrue, otherwise false
//
// int search(bag_typetarget):
//   Postcondition: if find return the index,otherwise NOT_FOUND(equal -1)
//
// CONST MEMBER METHOD forbag class (not const now)
// void travel():
//   Postcondition: travel the bag
//
// int count(bag_typetarget):
//   Postcondition: return how many times thetarget has been found, if
//   not found, return 0
//
// uint getCapacity():
//   Postcondition: return the capacity of thebag
//
// int getUsed():
//   Postcondition: return room has been used
//
// bag_type getByIndex(intindex):
//   Postcondition: return the item by the indexuser provides
//
// ArrayListgetAllFoundIndex():
//   Postcondition: return all the indexs havebeen found
//   during the search operation or countoperation
//
// void sort():
//   Postcondition: sort all the items in the bag

using System;
using System.Collections.Generic;
using System.Collections;
using System.Linq;
using System.Text;
using System.Diagnostics;
// Alias the data type withmy own type
using bag_size = System.UInt32;
using bag_type = System.Int32;
namespace DataStructure_Bag
{
   public classBag
   {
       private readonly bag_size BAG_CAPACITY;
       private const             bag_typeNOT_FOUND = -1;
       private bag_type[]        bagContainer;
       private bag_type          used;
       private ArrayList         theAllFoundIndex;

       // CONSTRUCTORS
       public Bag()
       {
            BAG_CAPACITY= 30;
            bagContainer= new bag_type[BAG_CAPACITY];
            used= 0;
            theAllFoundIndex= new ArrayList();
       }
       public Bag(bag_size size)
       {
            if(size > 0)
            {
                BAG_CAPACITY= size;
                bagContainer= new bag_type[BAG_CAPACITY];
                used= 0;
                theAllFoundIndex= new ArrayList();
            }
            else
                thrownew Exception("the capacity of a bag can't be zero.");
       }
       // MODIFICATION MEMBER METHODS
       public bool insert(bag_type member)
       {
            theAllFoundIndex.Clear();
            if(used >= BAG_CAPACITY)
            {
                thrownew OverflowException("the bag has no capacity to insert one itemanymore.");
            }
            else
            {
                bagContainer[used++] = member;
            }
            returntrue;
       }
       public bool erase(bag_type member)
       {
            inttheIndex = search(member);
            theAllFoundIndex.Clear();
            if(NOT_FOUND == theIndex)
                returnfalse;
            else
                bagContainer[theIndex] = bagContainer[--used];
            returntrue;
       }
       public intsearch(bag_typetarget)
       {
            theAllFoundIndex.Clear();
            for(int i = 0; i < used; ++i)
            {
                if(bagContainer[i]== target)
                {
                    theAllFoundIndex.Add(i);
                    returni;
                }
            }
            returnNOT_FOUND;
       }
       // CONST MEMBER METHODS
       public intcount(bag_type target)
       {
            theAllFoundIndex.Clear();
            for(int i = 0; i < used; ++i)
            {
                if(bagContainer[i]== target)
                {
                    theAllFoundIndex.Add(i);
                }
            }
            returntheAllFoundIndex.Count;
       }
       public uint getCapacity() { return BAG_CAPACITY; }
       public int getUsed() { return used; }
       public bag_type getByIndex(int index)
       {
            if(index < 0 || index>= used)
                thrownew Exception("Illegal index");
            returnbagContainer[index];
       }
       public ArrayList getAllFoundIndex() { return theAllFoundIndex; }
       public voidtravel()
       {
            for(int i = 0; i < used; ++i)
            {
                Console.WriteLine(bagContainer[i]);
            }
       }
       public void sort()
       {
            theAllFoundIndex.Clear();
            for(int i = 0; i < used -1; ++i)
            {
                for(int j = i + 1; j < used; ++j)
                {
                    if(bagContainer[i]> bagContainer[j])
                    {
                        bag_type temp = bagContainer[j];
                        bagContainer[j] = bagContainer[i];
                        bagContainer[i] = temp;
                    }
                }
            }
       }
   }
}

2.      设计数据结构的图形接口IShape

// File://Shape.cs
// INTERFACE FOR ALL SHAPES:Shape interface
//
// GENERAL METHODS for classimplementing the interface Shape
// Point getLocation():
//    Postcondition: get the position of theshape where the shape locates
//
// Color getOutlineColor():
//    Postcondition: get the outline color of theshape 
//
// void draw():
//    Postconditon: draw the shape on thegraphics
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Drawing;
namespace DataStructure_Shape
{
   public interface IShape
   {
       // GENERAL METHODS for interface shape
       Point getLocation();
       Color getOutlineColor();
       void draw(Graphicsgraphics);
   }
}

3.      实现Bag类的图形类BagShape，实现IShape接口，用于绘制Bag数据结构

// FILE://BagShape.cs
// CLASS IMPLEMENT: theinterface Shape
//
// CONSTRUCTORS for classBagShape
// BagShape():
//     Postcondition: initial the location,outlineColor and name with default value
//
// BagShape(Bag bag):
//     Postcondition: initial the bag instance,others keep default value
//
// BagShape(Point location,Color outlineColor):
//     Postcondition: initial the BagShape objectwith the provided value
//
// MEMBER METHODS forimplementing the interface IShape
// Point getLocation():
//     Postcondition: get the location of theshape
// Color getOutlineColor():
//     Postcondition: get the outline color ofthe shape
// void draw(Graphicsgraphics):
//     Postcondition: draw the data structure andall items in it on the graphics
using System;
using System.Collections.Generic;
using System.Collections;
using System.Linq;
using System.Text;
using System.Drawing;
using DataStructure_Bag;
using Common;

namespace DataStructure_Shape
{
   public class BagShape : IShape
   {
       // VARIABLES for the interface Shape
       private Point  location;                     //the start point of the bag
       private stringname;                          // the name of the bag
       private Color  outlineColor;                 //the outline color of the bag
       private float  outlineWidth;                 //the width of the outline
       private Size   size;                         // the size of the bag
       private Bag    bag;
       public BagBagContainer
       {
            get{ return bag;}
       }

       public stringName
       {
            get{ return name;}
       }

       // CONSTRUCTORS for the class BagShape
       public BagShape()
       {
            this.location = new Point(0, 0);
            this.name = "Bag";
            this.outlineColor = Color.Black;
            this.outlineWidth = 2;
            this.size = new Size(100, 100);
            this.bag  = new Bag();
       }

       public BagShape(Bag bag)
       {
            this.location = new Point(0, 0);
            this.name = "Bag";
            this.outlineColor = Color.Black;
            this.outlineWidth = 2;
            this.size = new Size(100, 100);
            this.bag = bag;
       }

       public BagShape(Point location,Color outlineColor,float outlineWidth,Size size,Bag bag)
       {
            this.location = location;
            this.name = "Bag";
            this.outlineColor = outlineColor;
            this.outlineWidth = outlineWidth;
            this.size = size;
            this.bag = bag;
       }

       // MEMBER METHODS for the class BagShape
       public Point getLocation()     { return this.location; }
       public Color getOutlineColor() { return this.outlineColor;}
       public void draw(Graphics graphics)
       {
            stringcapacityString = "容量："+ bag.getCapacity();
            stringusedString     = "已用："+ bag.getUsed();
            Font   arial10        = new Font("Arial",10);

            SizeF  capacitySizeF  = graphics.MeasureString(capacityString,arial10);
            SizeF  usedSizeF      = graphics.MeasureString(usedString,arial10);

            // 绘制文字和容器
            graphics.DrawString(capacityString,arial10,
                newSolidBrush(Color.Blue), new PointF(location.X, location.Y - capacitySizeF.Height));
            graphics.DrawString(usedString,arial10,
                newSolidBrush(Color.Blue), new PointF(location.X + size.Width - usedSizeF.Width, location.Y - capacitySizeF.Height));
            graphics.DrawRectangle(new Pen(outlineColor,outlineWidth), newRectangle(location,size));

            // 绘制元素
            PointitemLocation = newPoint(location.X, location.Y + size.Height);
            for(int i = 0; i < bag.getUsed(); ++i)
            {
                stringitemString = "<" + bag.getByIndex(i) + " >";
                SizeFitemSizeF = graphics.MeasureString(itemString,arial10);
                if(itemLocation.X+ itemSizeF.Width> location.X+ size.Width)
                {
                    itemLocation.Y -= (int)itemSizeF.Height;
                    itemLocation.X = location.X;
                }

                if(bag.getAllFoundIndex().Contains(i))
                {
                    graphics.DrawString(itemString,arial10,
                    newSolidBrush(Color.Red), new PointF(itemLocation.X, itemLocation.Y - itemSizeF.Height));
                    graphics.DrawRectangle(new Pen(Color.Red, 2),
                        new Rectangle(itemLocation.X,itemLocation.Y- (int)itemSizeF.Height, (int)itemSizeF.Width,(int)itemSizeF.Height));
                }
                else
                {
                    graphics.DrawString(itemString,arial10,
                    newSolidBrush(Color.Blue), new PointF(itemLocation.X, itemLocation.Y - itemSizeF.Height));
                    graphics.DrawRectangle(new Pen(Color.Blue, 2),
                        new Rectangle(itemLocation.X,itemLocation.Y- (int)itemSizeF.Height, (int)itemSizeF.Width,(int)itemSizeF.Height));
                }

                itemLocation.X += (int)itemSizeF.Width;
            }
            // 资源清理
            arial10.Dispose();
            graphics.Dispose();
       }
   }
}

4.      设计逻辑控制类GraphicsToDraw，决定该绘制哪种数据结构；

// FILE:GraphicsToDraw.cs
// Note: decide which kinddata structure should be drawn
//
// STATIC METHOD for theGraphicsToDraw
// static void draw(Graphicsgraph, DATASTRUCTURETYPES dataStructureToDraw, IShape shape)
//     Postcondition: according to thedataStructureToDraw, decide which kind of data structure
//     should be drawn
// static voiddrawBag(Graphics graph, BagShape bagShape):
//     Postcondition: draw the data structure bag
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using DataStructure_Bag;
using DataStructure_Shape;
using System.Drawing;
namespace DataStructureToSee
{
   public class GraphicsToDraw
   {
       static Graphicsgraphics;
       public static  void draw(Graphics graph, DATASTRUCTURETYPES dataStructureToDraw, IShape shape)
       {
            graphics= graph;
            switch(dataStructureToDraw)
            {
                caseDATASTRUCTURETYPES.BAG:
                    drawBag(graphics, (BagShape)shape);
                    break;
                caseDATASTRUCTURETYPES.QUEUE:
                    //drawQueue();
                    break;
                default:
                    break;
            }
       }

       private static void drawBag(Graphics graph,BagShape bagShape)
       {
            bagShape.draw(graph);
       }
       //private static void drawQueue()
       //{ }
   }
}

5.      设计展示界面

其实现逻辑如下：

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using DataStructure_Shape;
using DataStructure_Bag;
namespace DataStructureToSee
{
   // 命名空间一级的枚举，表示数据结构类型
   public enum DATASTRUCTURETYPES
   {
       NONE,
       BAG,
       QUEUE
   }
   public partial class DataStructureVisiable: Form
   {
       Graphics graphics;                    //作图用的画布
       BagShape bagShape;                    //要绘制的数据结构图形
       DATASTRUCTURETYPES theDataStructure; // 将要选择的数据结构类型

       public DataStructureVisiable()
       {
            InitializeComponent();
            btnInsert.Enabled = false;
            btnDelete.Enabled = false;
            btnSearch.Enabled = false;
            btnCount.Enabled  = false;
            btnSort.Enabled = false;
       }
       ///<summary>
       ///点击运行按钮，初始化数据结构
       ///</summary>
       ///<param name="sender"></param>
       ///<param name="e"></param>
       private void btnApply_Click(object sender, EventArgs e)
       {
            if(string.IsNullOrEmpty(cbDataStructureType.Text))
                MessageBox.Show("请先选择数据结构类型！");
            else
            {
                switch(cbDataStructureType.Text.ToString())
                {
                    #region 数据结构---包
                    case"包":
                        try
                        {
                            theDataStructure = DATASTRUCTURETYPES.BAG;
                            if (string.IsNullOrEmpty(tbCapacity.Text))
                            {
                                operateEnabled();
                                Size bagSize = new Size(200,200);
                                bagShape = new BagShape(new Point(plGraphics.Width / 2 - bagSize.Width / 2, plGraphics.Height / 2 - bagSize.Height / 2),
                                    Color.Blue, 2, bagSize, new Bag());
                                draw();
                            }
                            else
                            {
                                uint theBagSize;
                                if (uint.TryParse(tbCapacity.Text, out theBagSize))
                                {
                                    operateEnabled();
                                    Size bagSize = new Size(200,200);
                                    bagShape = new BagShape(new Point(plGraphics.Width / 2 - bagSize.Width / 2, plGraphics.Height / 2 - bagSize.Height / 2),
                                        Color.Blue, 2, bagSize, new Bag(theBagSize));
                                    GraphicsToDraw.draw(graphics, theDataStructure,bagShape);
                                }
                                else
                                    MessageBox.Show("请输入有效的容量值！");
                            }
                        }
                        catch (Exception ex)
                        {
                            MessageBox.Show("异常：创建包异常，" + ex.Message);
                        }
                        break;
                    #endregion
                    case"队列":
                        theDataStructure = DATASTRUCTURETYPES.QUEUE;
                        break;
                    default:
                        theDataStructure = DATASTRUCTURETYPES.NONE;
                        break;
                }

            }

       }
       private void operateEnabled()
       {
            btnInsert.Enabled = true;
            btnDelete.Enabled = true;
            btnSearch.Enabled = true;
            btnCount.Enabled = true;
            btnSort.Enabled = true;
       }
       ///<summary>
       ///根据数据结构执行插入操作
       ///</summary>
       ///<param name="sender"></param>
       ///<param name="e"></param>
       private void btnInsert_Click(object sender, EventArgs e)
       {
            try
            {
                switch(cbDataStructureType.Text.ToString())
                {
                    case"包":
                        int insertValue;
                        if (int.TryParse(tbInsertValue.Text,out insertValue))
                        {
                            bagShape.BagContainer.insert(insertValue);
                            draw();
                        }
                        else
                            MessageBox.Show("请输入合法的插入值");
                        break;
                }
            }
            catch(Exception ex)
            {
                MessageBox.Show("异常：插入异常，"+ ex.Message);
            }
       }
       ///<summary>
       ///根据数据结构执行删除操作
       ///</summary>
       ///<param name="sender"></param>
       ///<param name="e"></param>
       private void btnDelete_Click(object sender, EventArgs e)
       {
            try
            {
                switch(cbDataStructureType.Text.ToString())
                {
                    case"包":
                        int deleteValue;
                        if (int.TryParse(tbDeleteValue.Text,out deleteValue))
                        {
                            if (bagShape.BagContainer.erase(deleteValue))
                            {
                                draw();
                            }
                            else
                                MessageBox.Show("没有可以删除的元素！");
                        }
                        else
                            MessageBox.Show("请输入合法的删除值");
                        break;
                }
            }
            catch(Exception ex)
            {
                MessageBox.Show("异常：删除异常，"+ ex.Message);
            }
       }
       ///<summary>
       ///根据数据结构执行查找操作
       ///</summary>
       ///<param name="sender"></param>
       ///<param name="e"></param>
       private void btnSearch_Click(object sender, EventArgs e)
       {
            try
            {
                switch(cbDataStructureType.Text.ToString())
                {
                    case"包":
                        int searchValue;
                        if (int.TryParse(tbSearchValue.Text,out searchValue))
                        {
                            if (bagShape.BagContainer.search(searchValue) >= 0)
                            {
                                draw();
                                MessageBox.Show("已找到元素");
                            }
                            else
                                MessageBox.Show("没有可以找到任何元素！");
                        }
                        else
                            MessageBox.Show("请输入合法的查找值");
                        break;
                }
            }
            catch(Exception ex)
            {
                MessageBox.Show("异常：查找异常，"+ ex.Message);
            }
       }
       ///<summary>
       ///根据数据结构执行统计操作
       ///</summary>
       ///<param name="sender"></param>
       ///<param name="e"></param>
       private void btnCount_Click(object sender, EventArgs e)
       {
            try
            {
                switch(cbDataStructureType.Text.ToString())
                {
                    case"包":
                        int countValue;
                        if (int.TryParse(tbCountValue.Text,out countValue))
                        {
                            if (bagShape.BagContainer.count(countValue) > 0)
                            {
                                draw();
                                MessageBox.Show("总共找到元素个数：" + bagShape.BagContainer.count(countValue));
                            }
                            else
                                MessageBox.Show("没有可以找到任何元素！");
                        }
                        else
                            MessageBox.Show("请输入合法的统计值");
                        break;
                }
            }
            catch(Exception ex)
            {
                MessageBox.Show("异常：统计异常，"+ ex.Message);
            }
       }
       ///<summary>
       ///根据数据结构执行排序操作
       ///</summary>
       ///<param name="sender"></param>
       ///<param name="e"></param>
       private void btnSort_Click(object sender, EventArgs e)
       {
            switch(cbDataStructureType.Text.ToString())
           {
                    case"包":
                        bagShape.BagContainer.sort();
                        draw();
                    break;
           }
       }
       private void draw()
       {
            graphics= plGraphics.CreateGraphics();
            graphics.Clear(this.BackColor);
            GraphicsToDraw.draw(graphics, theDataStructure, bagShape);
       }
   }
}

6.      运行效果如下：

1）  初始化一个Bag：

2）  插入：

3）  删除：

4）  查找：

5）  统计：

6）  排序：