/// <summary>
/// 构造函数
/// </summary>
/// <param name="needtoexcute">把已经转化成数组形式的数据源传入执行条件筛选形成key数组</param>
/// <param name="keyselector">条件筛选方法</param>
/// <param name="next">比较器的下一个引用</param>
/// <param name="comparer">这个sorter的比较器</param>
public MyOrderThenBySorter(TMySource[] needtoexcute, 内置委托.Func <TMySource, TMyKey> keyselector, MyOrderThenBySorter <TMySource, TMyKey> next, 系统内置接口.IComparer <TMyKey> comparer)
{
this.needtoexcute = needtoexcute;
this.keyselector = keyselector;
this.next = next;
this.comparer = comparer;
}
/// <summary>
/// 快速排序
/// </summary>
/// <param name="_array">私有数组</param>
/// <param name="start">开始位置</param>
/// <param name="last">结束位置</param>
/// <param name="comparer">比较器</param>
public void QuickSort(T[] _array, int start, int last, 系统内置接口.IComparer <T> comparer)
{
//如果用户没有传入比较器，则调用默认的比较器
if (comparer == null)
{
comparer = defaultComparer <T> .CreateComparer();
}
if (start < last)
{
int indexer = Devide(_array, start, last, comparer);
QuickSort(_array, start, indexer - 1, comparer);
QuickSort(_array, indexer + 1, last, comparer);
}
}
/// <summary>
/// 分治法===以第一个元素作为比较标准
/// </summary>
/// <param name="_array">数组</param>
/// <param name="start">开始位置</param>
/// <param name="last">结束位置</param>
/// <param name="comparer">比较器</param>
/// <returns></returns>
private int Devide(T[] _array, int start, int last, 系统内置接口.IComparer <T> comparer)
{
T _temp = default(T);
T standard = _array[start]; //比较标准--以数组的第一个元素作为标准
int left = start + 1; //左侧开始位置
int right = last; //右侧开始位置
while (left < right)
{
//从右侧往左开始寻找小于标准数的元素
while (left < right && comparer.Compare(_array[right], standard) == 1)
{
right--;
}
//从左侧开始往右开始寻找大于标准数的元素
while (left < right && comparer.Compare(_array[left], standard) == -1)
{
left++;
}
//交换元素的位置
if (left < right)
{
Swap(_array, left, right);
//_temp = _array[left];
//_array[left] = _array[right];
_array[right] = _temp;
}
}
//从左右两侧比较之后指向同一个元素
_temp = standard;
if (comparer.Compare(_temp, _array[left]) == -1)
{
Swap(_array, start, left - 1);
//_array[start] = _array[left - 1];
//_array[left - 1] = _temp;
return(left - 1);
}
else
{
//else if (comparer.Compare(_temp, _array[left]) > 0)
Swap(_array, start, left);
//_array[start] = _array[left];
//_array[left] = _temp;
return(left);
}
}
/// <summary>
/// 构造函数
/// </summary>
/// <param name="source"></param>
/// <param name="keyselector"></param>
public OrderThenBySequence(数据结构.IEnumerable <TSource> source, 内置委托.Func <TSource, TKey> keyselector, 系统内置接口.IComparer <TKey> comparer)
{
if (source == null)
{
throw new Exception("需要排序的数据源不能为空");
}
if (keyselector == null)
{
throw new Exception("需要排序的字段不能为空");
}
this.comparer = comparer;
this.source = source;
this.keyselector = keyselector;
this.parent = null;//如果是orderby那么就说明只需要创建一个序列，也就没有了父级序列
//如果用户没有定义默认的比较器就使用系统默认的比较器
if (this.comparer == null)
{
数据结构.Comparer <TKey> comparerclass = new Comparer <TKey>();
this.comparer = comparerclass.Default;
}
}
public void Sort(int start, int last, 系统内置接口.IComparer <T> comparer)
{
SortHelper <T> sort = new SortHelper <T>(this._array);
sort.QuickSort(_array, start, last, comparer);
}
public void Sort(系统内置接口.IComparer <T> comparer)
{
this.Sort(0, this.Count - 1, comparer);
}
/// <summary>
///当OrderBy之后进行ThenBy的序列的创建的时候调用的方法,接受必须进行OrderBy之后的参数(IOrderThenBy类型的参数)
/// </summary>
/// <param name="afterorderbysource">IOrderThenBy的数据类型</param>
/// <param name="thenbyKeySelector">ThenBy需要执行的方法</param>
/// <returns></returns>
public 数据结构.OrderThenBySequence <TSource, TKey> CreateForThenBy(内置委托.Func <TSource, TKey> thenbyKeySelector, 系统内置接口.IComparer <TKey> comparer)
{
数据结构.OrderThenBySequence <TSource, TKey> thenbysource = new OrderThenBySequence <TSource, TKey>(source, thenbyKeySelector, comparer);
thenbysource.parent = this;//this表示的当前的类，某个类的实例的对象.方法,那么在这个方法中的this就是这个 实例对象
return(thenbysource);
}
