• 利用"委托"实现类的对象实例按"多字段嵌套"排序


    /* 
    利用"委托"实现对象实例按"多字段嵌套"排序 
     
    (不知道大家看懂题目了? 功能还是有点儿用的!) 
    本文实现 Person 类的实例们按 年龄、身高、体重等字段嵌套排序! 
    就像 SQL 查询的 Order By 字段1,字段2,,字段n 子句的效果一样! 
     
    */


    using System;

    class Class1 //客户程序 
    {
        
    static void Main()
        
    {
            Person[] Persons 
    =
                
    {
                    
    // 姓名、年龄、身高、体重 
                    new Person("张栢芝"7117849)
                    , 
    new Person("章子怡"2317733)
                    , 
    new Person("周  迅"7118080)
                    , 
    new Person("徐静蕾"1215070)
                    , 
    new Person("赵  薇"2316660)
                    , 
    new Person("宋丹丹"5018350)
                    , 
    new Person("翠花儿"2317734)
                    , 
    new Person("赵丽蓉"5018440)
                    , 
    new Person("郭晶晶"5018441)
                }
    ;

            
    //"BubbleSorter.CompareOp 委托" 类型数组的元素顺序,规定了嵌套排序的顺序,即: 
            
    //先按"年龄(Age)"排序,如果一样再按"身高(Height)",如果还一样再按"身高(Height)"! 
            
    //注意这只是排序的结果而以,如果要按此思路编下去,就有"递归"的意思了,然而层次却无法确定! 
            Sorter.CompareOp[] PersonCompareOp =
                
    {
                    
    // 你可以调换元素顺序,来改变排序的字段顺序 
                    new Sorter.CompareOp(Person.PrevIsOlderThanNext)
                    , 
    new Sorter.CompareOp(Person.PrevIsHigherThanNext)
                    , 
    new Sorter.CompareOp(Person.PrevIsHeavierThanNext)
                }
    ;

            
    // 转到 Person 类 和 BubbleSorter 类的实现! 
            Sorter.BubbleSort(Persons, PersonCompareOp);

            
    for (int i = 0; i < Persons.Length; i++)
                Console.WriteLine(Persons[i].ToString());

            Console.ReadLine();
        }

    }


    class Person
    {
        
    private string _name;
        
    private int _age;
        
    private int _weight;
        
    private int _height;

        
    public Person(string Name, int Age, int Height, int Weight)
        
    {
            
    this._name = Name;
            
    this._age = Age;
            
    this._height = Height;
            
    this._weight = Weight;
        }


        
    public override string ToString()
        
    {
            
    return string.Format(_name + ", {0:N}, {1:N}, {2:N}", _age, _height, _weight);
        }


        
    // 下面"额外"定义了若干与委托签名一致匹配的静态方法,供"委托调用" 
        
    // 返回值为"真"时,代表 "前一元素 <= 后一元素" ,否则为"假"! 
        
    // 只要参照这里,我们可以为类添加的排序功能并定义排序规则! 
        
    // 多么简单啊! 剩下的工作就都留给 "排序功能(工具)类" 去做吧! 
        public static bool PrevIsOlderThanNext(Person Prev, Person Next)
        
    {
            
    // 这里一定要用 "小于等于(<=)","等于"就是为了实现: 
            
    // 如果两元素前一规则(如: 年龄)排序相等,就按下一规则(如: 身高)排序 
            
    // 如果 "前一元素 <= 后一元素" ,返回"真",返回"假"! 
            return (Prev._age <= Next._age);
        }


        
    public static bool PrevIsHigherThanNext(Person Prev, Person Next)
        
    {
            
    return (Prev._height <= Next._height);
        }


        
    public static bool PrevIsHeavierThanNext(Person Prev, Person Next)
        
    {
            
    return (Prev._weight <= Next._weight);
        }

    }


    // "排序功能(工具)类" 
    class Sorter
    {
        
    // 声明委托 
        public delegate bool CompareOp(Person X, Person Y);

        
    //本排序的基本算法就是冒泡法最常见简单易懂,属于"交换"排序法的一种! 
        public static void BubbleSort(Person[] A, CompareOp[] MoreThanMethod) //MoreThanMethod 就是排序的字段顺序 
        {
            
    for (int k = 0; k < MoreThanMethod.Length; k ++// 遍历委托数组 
            {
                
    for (int i = 0; i < A.Length; i ++// 冒泡法外层循环 
                {
                    
    for (int j = i + 1; j < A.Length; j ++// 冒泡法内层循环 
                    {
                        
    bool b = true;
                        
    for (int m = 0; m <= k; m ++)
                        
    {
                            
    // 如果两元素前一规则(如: 年龄)排序相等,就按下一规则(如: 身高)排序 
                            b = b && MoreThanMethod[m](A[j], A[i]);
                        }

                        
    if (b) //冒泡法交换元素的条件 
                        {
                            
    // 冒泡法交换元素 
                            Person p = A[i];
                            A[i] 
    = A[j];
                            A[j] 
    = p;
                        }

                    }

                }

            }

        }

    }

  • 相关阅读:
    菜根谭#245
    菜根谭#244
    菜根谭#243
    菜根谭#242
    菜根谭#241
    菜根谭#240
    菜根谭#239
    菜根谭#238
    菜根谭#237
    [转载]Linux 内核list_head 学习(一)
  • 原文地址:https://www.cnblogs.com/Microshaoft/p/130511.html
Copyright © 2020-2023  润新知