C#一维空间简单操作_c# sort 容差-CSDN博客

这篇博客介绍了如何创建和操作一维空间的区间类`XRange`，包括中位数、长度、字符串表示、判断值是否在区间内等方法。此外，还提供了区间集合类`XRangeList`，支持区间合并、排序、反序等功能。同时，博客中展示了通用排序算法的帮助类`XSort`，包含了快速排序的实现。通过示例展示了如何在实际场景中应用这些类来处理区间数据。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1、第一步，创建一维空间实体类：

public class XRange
{
    public double Max;
    public double Min;

    /// <summary>
    /// 构造函数
    /// </summary>
    /// <param name="a"></param>
    /// <param name="b"></param>
    public XRange(double a, double b)
    {

        if (a < b)
        {
            this.Min = a;
            this.Max = b;
        }
        else
        {
            this.Min = b;
            this.Max = a;
        }
    }

    /// <summary>
    /// 中位数
    /// </summary>
    /// <returns></returns>
    public double Mid()
    {
        return this.Min + 0.5 * (this.Max - this.Min);
    }

    /// <summary>
    /// 长度
    /// </summary>
    /// <returns></returns>
    public double Length()
    {
        return this.Max - this.Min;
    }

    /// <summary>
    /// 字符串
    /// </summary>
    /// <returns></returns>
    public override string ToString()
    {
        return "[" + this.Min + "," + this.Max + "]";
    }
    
    /// <summary>
    /// 当前区间是否包含指定值
    /// </summary>
    /// <param name="value">目标值</param>
    /// <param name="tol">容差值</param>
    /// <returns></returns>
    public bool In(double value, double tol = 0)
    {
        if (value >= this.Min - tol && value <= this.Max + tol)
        {
            return true;
        }
        else
        {
            return false;
        }
    }

    /// <summary>
    /// 区间合并，相交区间才合并
    /// </summary>
    /// <param name="range"></param>
    /// <returns>不相交区间返回false，相交区间合并后返回true</returns>
    public bool Merge(XRange range)
    {
        if (range.Max < this.Min || range.Min > this.Max)
        {
            return false;
        }
        else
        {
            this.Min = Math.Min(this.Min, range.Min);
            this.Max = Math.Max(this.Max, range.Max);
            return true;
        }
    }

    /// <summary>
    /// 一维区间加值
    /// </summary>
    /// <param name="range"></param>
    /// <param name="a"></param>
    /// <returns></returns>
    public static XRange operator +(XRange range, double a)
    {
        XRange p = new XRange(range.Min + a, range.Max + a);
        return p;
    }

    /// <summary>
    /// 一维区间减值
    /// </summary>
    /// <param name="range"></param>
    /// <param name="a"></param>
    /// <returns></returns>
    public static XRange operator -(XRange range, double a)
    {
        XRange p = new XRange(range.Min - a, range.Max - a);
        return p;
    }

    /// <summary>
    /// 一维区间乘值
    /// </summary>
    /// <param name="range"></param>
    /// <param name="a"></param>
    /// <returns></returns>
    public static XRange operator *(XRange range, double a)
    {
        XRange p = new XRange(range.Min * a, range.Max * a);
        return p;
    }

    /// <summary>
    /// 计算跃迁值(最大间隔范围的上限值）
    /// </summary>
    /// <param name="nums"></param>
    /// <returns></returns>
    public static int GetMaxStepValue(int[] nums)
    {
        if (nums.Length > 0)
        {
            XSort.QuickSort(nums);
            int value = nums[0];
            int sect = 0;
            for (int i = 1; i < nums.Length; i++)
            {
                XRange range = new XRange(nums[i - 1], nums[i]);
                if (nums[i] - nums[i - 1] >= sect)
                {
                    sect = nums[i] - nums[i - 1];
                    value = nums[i];
                }
            }
            return value;
        }
        return int.MinValue;
    }

    /// <summary>
    /// 排序规则
    /// </summary>
    /// <param name="a">排序元素a</param>
    /// <param name="b">排序元素b</param>
    /// <returns></returns>
    public static bool CompareByMin(XRange a, XRange b)
    {
        return a.Min > b.Min;
    }
}

2、第二步，一维空间集合操作类：

public class XRangeList
{
    /// <summary>
    /// 构造函数
    /// </summary>
    public XRangeList()
    {
        _values = new List<XRange>();
    }

    private List<XRange> _values;
    /// <summary>
    /// 区间集合
    /// </summary>
    public List<XRange> List
    {
        get
        {
            return _values;
        }
        set { _values = value; }
    }

    /// <summary>
    /// 指定值是否在集合中的某个区间内
    /// </summary>
    /// <param name="value">指定值</param>
    /// <param name="tol">容差值</param>
    /// <returns></returns>
    public bool In(double value, double tol = 0)
    {
        foreach (XRange xRange in _values)
        {
            if (xRange.In(value, tol))
            {
                return true;
            }
        }
        return false;
    }

    /// <summary>
    /// 排序
    /// </summary>
    public void Sort()
    {
        XSort.Sort(_values, XRange.CompareByMin);
    }

    /// <summary>
    /// 反序
    /// </summary>
    public void Reverse()
    {
        _values.Reverse();
    }

    /// <summary>
    /// 范围合并
    /// </summary>
    /// <param name="range"></param>
    /// <returns>返回合并类型</returns>
    public int Merge(XRange range)
    {
        foreach (XRange xRange in _values)
        {
            if (xRange.Merge(range))
            {
                return 1;
            }
        }
        _values.Add(range);
        return 2;
    }

    /// <summary>
    /// 深度合并
    /// </summary>
    /// <param name="intervals">区间集合</param>
    /// <param name="tol">容差值</param>
    /// <returns></returns>
    public static List<XRange> Merge(List<XRange> intervals, double tol = 0)
    {
        if (intervals.Count <= 1)
        {
            return intervals;
        }

        //对intervals排序
        XSort.Sort(intervals, XRange.CompareByMin);

        List<XRange> resultList = new List<XRange>();
        XRange cur_interval = intervals[0];
        XRange next_interval = null;
        for (int i = 1; i < intervals.Count; i++)
        {
            next_interval = intervals[i];
            if (cur_interval.Max < next_interval.Min - tol)//增加容差
            {
                //不相交，不能合并
                resultList.Add(cur_interval);
                cur_interval = next_interval;
            }
            else if (cur_interval.Max >= next_interval.Min - tol && cur_interval.Max <= next_interval.Max)//增加容差
            {
                cur_interval.Max = next_interval.Max;
            }
        }
        resultList.Add(cur_interval);
        return resultList;
    }
}

3、第三步，通用排序算法帮助类：

public static class XSort
{
    #region 系统的快速排序
    /// <summary>
    /// 系统的快速排序算法
    /// </summary>
    /// <param name="array"></param>
    public static void QuickSortSystem(int[] array)
    {
        Array.Sort(array);
    }

    public static void QuickSort(int[] array)
    {
        QuickSort(array, 0, array.Length - 1);
    }

    public static void QuickSort(int[] array, int left, int right)
    {
        if (left < right)
        {
            int piv = Partition(array, left, right);
            QuickSort(array, left, piv - 1);
            QuickSort(array, piv + 1, right);
        }
    }

    private static int Partition(int[] array, int low, int high)
    {
        int piv = low; int pivalue = array[low]; //将第一个对象作为种子对象
        for (int i = low + 1; i <= high; i++)
        {
            if (array[i] < pivalue && ++piv != i)
                Swap(ref array[piv], ref array[i]);
        }
        Swap(ref array[low], ref array[piv]);

        return piv;
    }

    private static void Swap(ref int a, ref int b)
    {
        int c = a;
        a = b;
        b = c;
    }
    #endregion

    /// <summary>
    /// 泛型比较委托
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="t1"></param>
    /// <param name="t2"></param>
    /// <returns></returns>
    public delegate bool Compare<T>(T t1, T t2);

    /// <summary>
    /// 泛型冒泡排序
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="items"></param>
    /// <param name="compare"></param>
    public static void Sort<T>(IList<T> items, XSort.Compare<T> compare)
    {
        if (items == null)
            return;
        for (int i = 0; i < items.Count; i++)
        {
            for (int j = i + 1; j < items.Count; j++)
            {
                if (compare(items[i], items[j]))
                {
                    var temp = items[i];
                    items[i] = items[j];
                    items[j] = (T)temp;
                }
                //compare > 则顺序,<则逆序   www.Rsion.com
            }
        }
    }
}

4、第四步，简单的应用示例：

public class XLine
{
    public XPoint StartPt { get; set; }

    public XPoint EndPt { get; set; }
}

public class XPoint
{
    public double X { get; set; }

    public double Y { get; set; }
}

public class RangeTest
{
    public void Example()
    {
        List<XLine> lineList = new List<Xline>();
        //集合赋值不做展示....

        XRangeList xRangeList = new XRangeList();
        foreach (XLine xLine in lineList)
        {
            XRange xRange = new XRange(xLine.StartPt.X, xLine.EndPt.X);
            xRangeList.Merge(xRange);
        }
        xRangeList.List = XRangeList.Merge(xRangeList.List);
        xRangeList.Sort();
    }
}