使用画图方法显示排序算法，使用策略模式

using System;
using System.Collections.Generic;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace AnimatorPatterm
{
static class StartSetGenerator
{
private static List<int> myList;
public static IEnumerable<int> GetStartSet()
{
const int n = 200; //how many values to generate
if (myList == null)
{
List<int> list = new List<int>();
Random rnd = new Random();

List<int> range = new List<int>();
for (int i = 0; i < n; i++)
range.Add(i);

while (range.Count > 0)
{
int item = range[rnd.Next(range.Count )];
list.Add(item);
range.Remove(item);
}
myList = list;
}
return myList;
}
}

class StrategyView<T> : Form where T : IComparable<T>
{
PictureBox pb;
Func<IEnumerable<T>> Generator;

public StrategyView(Func<IEnumerable<T>> generator)
{
this.Generator = generator;
this.Text = "Sort Comparer";
this.pb = new PictureBox();
pb.Dock = DockStyle.Fill;
pb.BackColor = Color.White;
pb.BorderStyle = BorderStyle.Fixed3D;
this.Controls.Add(pb);

TableLayoutPanel p = new TableLayoutPanel();
p.RowCount = 1;
p.ColumnCount = 3;
p.Dock = DockStyle.Top;
this.Controls.Add(p);

Button b = new Button();
b.Name = "LargeItems";
b.Click += new EventHandler(ButtonClick);
b.Text = "Objects";
p.Controls.Add(b);

b = new Button();
b.Name = "SmallItems";
b.Click += new EventHandler(ButtonClick);
b.Text = "Primitive";
p.Controls.Add(b);

b = new Button();
b.Name = "ReversedList";
b.Click += new EventHandler(ButtonClick);
b.Text = "Reversed";
p.Controls.Add(b);

p.Height = b.Height + 4;
this.DoubleBuffered = true;
this.ResumeLayout(true);
}

public void DrawGraph(IEnumerable<T> list)
{
if (pb.Image == null)
pb.Image = new Bitmap(pb.Width, pb.Height);
Graphics g = Graphics.FromImage(pb.Image);
g.Clear(Color.White);
g.DrawRectangle(Pens.Blue, 19, 19, 202, 202);
g.Dispose();
Bitmap b = pb.Image as Bitmap;

int listSize = list.Count();
int x = 0;
foreach (T item in list)
{
int? val = item as int?;
if (!val.HasValue)
val = 0;

b.SetPixel(x + 20, 20 + 200 - ((int)val), Color.Black);
x++;
}
this.Refresh();
Thread.Sleep(100);
Application.DoEvents();
}

void ButtonClick(object sender, EventArgs e)
{
Button control = sender as Button;
ISortStrategy<T> strategy = null;

strategy = SelectStrategy(control.Name, strategy);

IEnumerable<T> newList = Generator();
DrawGraph(newList);
if (strategy == null)
return;

strategy.UpdatedUI += new Action<IEnumerable<T>>(DrawGraph);
strategy.Sort(newList);
}

private static ISortStrategy<T> SelectStrategy(string name, ISortStrategy<T> strategy)
{
switch (name)
{
case "LargeItems":
strategy = new MergeSorter<T>();
break;
case "SmallItems":
strategy = new QuickSorter<T>();
break;
case "ReversedList":
strategy = new MergeSorter<T>();
break;
}
return strategy;
}
}

interface ISortStrategy<T> where T : IComparable<T>
{
event Action<IEnumerable<T>> UpdatedUI;
void Sort(IEnumerable<T> input);
}

class MergeSorter<T> : ISortStrategy<T> where T : IComparable<T>
{
public event Action<IEnumerable<T>> UpdatedUI;
List<T> aux;
int opCount = 0;

public void Sort(IEnumerable<T> input)
{
UpdatedUI(input);
opCount++;
List<T> sorteditems = new List<T>(input);
aux = new List<T>(sorteditems.Count);
for (int i = 0; i < sorteditems.Count; i++)
aux.Add(default(T));
MergeSort(ref sorteditems, 0, sorteditems.Count - 1);
UpdatedUI(sorteditems);
}

private void Merge(ref List<T> a, int l, int m, int r)
{
int i;
int j;
for (i = m + 1; i > l; i--)
{
aux[i - 1] = a[i - 1];
opCount++;
}
for (j = m; j < r; j++)
{
aux[r + m - j] = a[j + 1];
opCount++;
}

for (int k = l; k <= r; k++)
{
if (aux[j].CompareTo(aux[i]) == -1)
a[k] = aux[j--];
else
a[k] = aux[i++];
opCount++;
}
}

private void MergeSort(ref List<T> a, int l, int r)
{
if (r <= l) return;
int m = (r + l) / 2;
MergeSort(ref a, l, m);

if (opCount > 50)
{
UpdatedUI(a);
opCount -= 50;
}

MergeSort(ref a, m+1, r);
if (opCount > 50)
{
UpdatedUI(a);
opCount -= 50;
}

Merge(ref a , l,m,r);
if (opCount > 50)
{
UpdatedUI(a);
opCount -= 50;
}
}

}

class QuickSorter<T> : ISortStrategy<T>
where T : IComparable<T>
{
public event Action<IEnumerable<T>> UpdatedUI;

int opCount = 0;
public void Sort(IEnumerable<T> input)
{
UpdatedUI(input);
opCount++;
List<T> sorteditems = new List<T>(input);

QuickSort(ref sorteditems, 0, sorteditems.Count - 1);
UpdatedUI(sorteditems);
}

private int Partition(ref List<T> a, int l, int r)
{
T tmp;
int i = l - 1;
int j = r;
T v = a[r];
for (; ; )
{
while (a[++i].CompareTo(v) == -1)
{
opCount++;
}
while (j>=2 && v.CompareTo(a[--j]) == -1)
{
opCount++;
//if(j==1)break ;//bug，因为恰当j=1，进入while循环时，就会出错！
}
if (i >= j) break;

tmp = a[i];
a[i] = a[j];
a[j] = tmp;

opCount++;
}
a[r] = a[i];
a[i] = v;

if (opCount > 50)
{
UpdatedUI(a);
opCount -= 50;
}
return i;
}

private void QuickSort(ref List<T> a, int l, int r)
{
opCount++;
if (r <= l) return;
int i = Partition(ref a, l, r);
QuickSort(ref a, l, i - 1);
QuickSort(ref a, i + 1, r);
}
}

class Program
{
static void Main(string[] args)
{
//Application.EnableVisualStyles();
//Application.SetCompatibleTextRenderingDefault(false);
Application.Run(new StrategyView<int>(StartSetGenerator.GetStartSet));
}
}
}