C# 类 关键字 排序 方法总结

最新推荐文章于 2022-04-25 12:26:13 发布
最新推荐文章于 2022-04-25 12:26:13 发布
阅读量1k 收藏
点赞数
分类专栏： 排序 文章标签： C# 类 关键字 排序 方法总结
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013187393/article/details/48223997
版权 
代码方面：
Node.class:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace TEST_All
{
    public class Node : IComparable<Node>
    {
        public int val;
        public int index;
        public Node(int l, int i)
        {
            this.index = l;
            this.val= i;            
        }
        public int CompareTo(Node b)
        {
            if (val > b.val) return -1;    //>时,返回1(正数)按从小到大,否则-1则大到小
            else if (val == b.val) return 0;
            else return 1;
        }
        public int CompareTo(object obj)
        {
            Node p = obj as Node;
            if (val > p.val) return -1;    //>时,返回1(正数)按从小到大,否则-1则大到小
            else if (val == p.val) return 0;
            else return 1;
        }
    }
}

using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;      //
using System.Media;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace TEST_All
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }
        List<Node> []way_hash = new List<Node>[10];
        private int com(Node a, Node b)
        {
            if (a.val > b.val) return -1;    
            else if (a.val == b.val) return 0;
            else return 1;
        }
        public class Comp2 : IComparer<Node>
        {
            public int Compare(Node a, Node b)
            {
                if (a.val > b.val) return -1;
                else if (a.val == b.val) return 0;
                else return 1;
            }
        }
        
        int allused,times=0;
        private void Form1_Load(object sender, EventArgs e)
        {
            allused = times = 0;
            way_hash[0] = new List<Node>();
            for (int i = 0; i < 100000; i++)
            {
                way_hash[0].Add(new Node(1, 3));
                way_hash[0].Add(new Node(2, 2));
                way_hash[0].Add(new Node(3, 7));
                way_hash[0].Add(new Node(4, 7));
                way_hash[0].Add(new Node(5, 5));
                way_hash[0].Add(new Node(6, 1));
            }
        }
        int usetime = 0;
        private void button1_Click(object sender, EventArgs e)
        {
            //way_hash[0].Clear();
            usetime = 0;
            timer1.Enabled = true;       
            Go_AI_Thread();
        }
        string ps = "";
        private void timer1_Tick(object sender, EventArgs e)
        {
            usetime++;
            textBox1.Text = usetime.ToString();
        }
        #region 线程
        public static IntPtr main_whandle;
        public const int WATCH_FILE = 0x502;
        [DllImport("User32.dll", EntryPoint = "SendMessage")]
        private static extern int SendMessage(
        IntPtr hWnd, // handle to destination window
        int Msg, // message
        int wParam, // first message parameter
        int lParam // second message parameter
        );
        void Go_AI_Thread()
        {
            ThreadStart thradAll = new ThreadStart(Thread_AB);
            Thread TotallThread = new Thread(thradAll);
            TotallThread.IsBackground = true;
            TotallThread.Start();
        }
#endregion
        #region 已测试区  --排序方法   放到Thread_AB() 相应部分就可以排序or测试性能了，
            
            //way_hash[0].Sort(com);
            
            //way_hash[0].Sort((a, b) =>
            //{
            //    if (a.val > b.val) return -1;    //>时,返回1(正数)按从小到大,否则-1则大到小
            //    else if (a.val == b.val) return 0;
            //    else return 1;
            //});
        //way_hash[0].Sort((a, b) => a.val>b.val?-1:a.val<b.val?1:0);    //way_hash[0].Sort((a, b) => { return a.val > b.val ? -1 : a.val < b.val ? 1 : 0; });


        //IEnumerable<Node> q = way_hash[0].OrderByDescending(a => a.val).ToList();
        //IEnumerable<Node> q = way_hash[0].OrderBy(a => a.val);
        //int g = 0;
        //    foreach (Node c in q)
        //    {
        //        ps += c.val.ToString() + "\n";
        //        g++;
        //        if (g == 13) break;
        //    }

        //way_hash[0] = way_hash[0].OrderByDescending(v => v.val).ToList();

        //var ii = from aa in way_hash[0]
        //             orderby aa.val descending
        //             select aa;
        //    way_hash[0] = ii.ToList();                

        //way_hash[0].Sort(new Comp2());  

        //way_hash[0].Sort();
        //for (int i = 0; i < 13; i++) ps += way_hash[0][i].index + "       " + way_hash[0][i].val + "\n";            
            #endregion
        void Thread_AB()       
        {
            way_hash[0].Sort((a, b) => a.val>b.val?-1:1); 
            ps = "index  val   ACed\n";            
            timer1.Enabled = false;
            for (int i = 0; i < 13; i++) ps += way_hash[0][i].index + "       " + way_hash[0][i].val + "\n";            
            MessageBox.Show(ps);
        }
    }
}

个人保留总结方面，比较随意（因为自己看得懂，简而行之）：

C# 如C++结构体 排序大法+list遍历方法：
  (1).1新鲜： List<Node> dist = new List<Node>();
            dist.Add(new Node(1.2, 0));(这个add是结合构造函数用的)           
dist[1].index = 88;		dist = dist.OrderBy(i => i.index).ToList();
            dist = dist.OrderByDescending(i => i.index).ToList();
  (1).2-> var sortedWords =
                words.OrderBy(a => a.Length)
                     .ThenBy(a => a, new comp_cl());
  public class comp_cl : IComparer<string>      {
            public int Compare(string x, string y)
            { return string.Compare(x, y, StringComparison.OrdinalIgnoreCase);    }
   } 
    IEnumerable<string> q = words.OrderBy(a => a.Length);  words.OrderBy(a => a.Length).ToList();才能看到线程开动的计时器,无.tolist()则textbox里不显时间,,//用这个 IEnumerable能看到排序结果foreach (string c in q(我错了，也可以sortedWords )) ss += c.ToString() + "\n";
    (2)intList.Add(2);       intList.Sort(); 小到大   或者(2).2对数组Array.Sort(nums);
   (3)找到了习惯用的排序自定义法 dist.Sort(Compare_func);  
	private int Compare_func(Node a, Node b)	if (a.index > b.index) return -111;    //>时，返回1(正数)按从小到大,否则-1则大到小
   (3).2 ->这个新鲜(使用Comparison<T>委托)：  //way_hash[0].Sort((a, b) =>
            //{   if (a.val > b.val) return -1;   
            //    else if (a.val == b.val) return 0;
            //    else return 1;
            //});
        //way_hash[0].Sort((a, b) => a.val>b.val?-1:a.val<b.val?1:0);    //way_hash[0].Sort((a, b) => { return a.val > b.val ? -1 : a.val < b.val ? 1 : 0; }); 这两一样
   (3).3应该等价于(3).2 way_hash[0].Sort((a, b) => a.val>b.val?-1:a.val<b.val?1:0);
  (4).1 public class Node : IComparable<Node>
  这样就可以像C++的bool operation<(a,b){}一样把排序方法写在类中了public int CompareTo(Node b) {return b.CompareTo(b); 看起来递归似的}    List1.Sort();
  (4).2-> public class Node : IComparable{ public int CompareTo(object obj) { Person p = obj as Person;  ...}}
Array.Sort(node);(node-->只可以一维数组，，醉了)     也可以 List1.sort();
   IComparable 和 CompareTo 这两名词不可变 CompareTo同时也是比较函数..这也行..
  (4).3 -> 使用IComparer<T>接口: public class Comp : IComparer<Node>
   {
            Compare(Node a,Node b) {}
        }
 调用：L.Sort(new Comp()); 或者 Array.Sort(L, new Comp()); L又是只可以一维数组..
  就如类中的排序方式写到类外..
  Comp 名词可改  Compare不可改
   (4).4->private int com(Node a, Node b) {}   way_hash[0].Sort(com);    
   (5)新鲜排序方法:var ii = from aa in L
                     orderby aa.n descending
                     select aa;
            L = ii.ToList();	//启动排序
   descending不写就默认ascending
   (6)关键字 串 限制:
  class Item
        {
            public string key;// { get; set; }   int c;
    }
   items.Add(new Item { key = "3311" });
   items.Sort((i1, i2) => String.CompareOrdinal(i1.key,i2.key));//按串从小到大排


额外福利测试：

性能测试(List<Node>)：
1.way_hash.Add(new Node(1, 3));平均稍微比way_hash.Add(new Node { index = 1, val = 3 });快，但都不稳定，相同环境条件下有时候相同循环次数用时相差大。
2.600W长度的排序耗时:
  (4).1->way_hash[0].Sort();              2.4 s
  (4).2->way_hash[0].Sort();              4.4 s
  (4).3->way_hash[0].Sort(new Comp2());     2.4 s
  (4).4->way_hash[0].Sort(com);          2.8 s
  (3).2->way_hash[0].Sort((a, b) =>{})           2.8~2.9
  (3).3  2.9s    //扩大数据后比较测三元运算符速度
  (5)  2.4s
  (1).1  2.3~2.5s
  (1).2 几乎仅次于最快的 常用的内排 (4).1  貌似还快-就是坑爹的看不到线程测出的时间--又或者是因为显示不出或者什么的所以貌似快了点

nodes.ForEach((c)又比foreach快多了
foreach (0.45s) 貌似快过for(0.6s).. while和 do-while最慢 ((0.7s))
(3).2测试发现：三元快过if el , 嵌套三元快过if elif el


MFLC
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
多关键字排序（C语言）
03-17
利用多关键字排序进行高考分数处理，除了需对总分进行排序外，不同的专业对单科分数的要求不同，因此在总分相同的情况下，按用户提出的单科分数的次序要求排出考生录取的次序。 假设待排序的记录数不超过1000，表中记录的关键字数不超过5，各个关键字的范围均为0至100。按用户给定的进行排序的关键字的优先关系，输出排序结果。
C#的四中排序方法
jelink的专栏
08-31 1029
所谓排序，就是要整理文件中的记录，使之按关键字递增(或递减)次序排列起来。其确切定义如下：　　输入：n个记录R1，R2，…，Rn，其相应的关键字分别为K1，K2，…，Kn。　　输出：Ril，Ri2，…，Rin，使得Ki1≤Ki2≤…≤Kin。(或Ki1≥Ki2≥…≥Kin)。主要介绍的是冒泡排序,选择排序,插入排序,希尔排序 1.冒泡排序     也叫气泡排序,排序的过程:首先将第1个数与第2个数
C#排序归纳
chao的博客
03-18 312
【冒泡排序】（逐个比较将大的往后放） int []hight=new int[10]; for(int i=0;i<10;i++){ hight[i]=int.Parse(Console.ReadLine()); } for (int i=0;i<hight.Length-1;i++){ f...
【C#自学记录】C#类中不同的关键字初始化语句及其执行顺序
m0_67249647的博客
04-25 154
自学过程中对C#类中的初始化顺序有一些探索兴趣，记录到本文的当中
C# List OrderBy 动态多字段排序
07-01
C# 使用orderby 多字段 动态排序
C#简单的排序算法可视化程序
04-28
在本文中，我们将深入探讨C#编程语言中的几种基本排序算法——冒泡排序、插入排序以及快速排序，并结合“C#简单的排序算法可视化程序”这一主题，了解如何将这些算法进行可视化展示。在这个Windows Forms应用程序中...
C#多线程排序例子
12-11
在排序场景中，`ParallelEnumerable`类的`OrderBy`方法可用于并行排序，简化了多线程实现。 6. **异步编程与Task**：C# 5.0及以后版本引入了异步编程模型，通过`async`和`await`关键字，可以编写更简洁、更易于理解...
C#中的匿名方法实例解析
09-04
匿名方法是C#编程语言中的一种特性，首次在C#2.0版本中引入，它允许程序员在不定义单独的命名方法的情况下创建和使用方法。匿名方法的主要目的是简化代码，特别是当需要一个简短的、一次性使用的功能时，它可以作为...
解析C#的扩展方法
09-01
1. **Enumerable类**：提供了大量操作集合的方法，如`Range()`用于创建一个包含指定范围整数的序列，`Select()`用于映射每个元素，`Where()`用于过滤元素，`OrderBy()`用于排序等。这些方法都接受`IEnumerable<T>`...
c#对list排序示例
09-04
总结来说，C#提供了多种对List进行排序的方法，包括`OrderBy`（升序）和`OrderByDescending`（降序）方法，以及Linq查询语法。这些方法都基于Lambda表达式或匿名函数，使得排序操作变得简单易懂。在实际开发中，根据...
C#提取内容最多的关键词排序，华人CMS首发
10-19
txt文本，提取内容最多的关键词排序，类似新浪博客提取关键词。
指定TreeNode排序
rell336的专栏
08-10 1740
button1.Click调用： My_SortTreeNode(treeView1.SelectedNode);  //选定的节点，右键可以添加排序弹出菜单         public int TreeNodeCompare(TreeNode x, TreeNode y)         {             TreeNode tx = x as TreeNode;
INTEL 编译器 序列号更新
qq_42271796的博客
11-01 1万+
编译时因证书过期出现如下问题 Error: Product support for your (Comp-CL) license has expired. License file(s) used were (in this order): 1. Trusted Storage ** 2. /opt/inter/compilers_and_libraries_2017.4.196/l...
各种排序算法汇总
weixin_34126557的博客
03-04 320
目录 简介 交换排序 冒泡排序 快速排序 插入排序 直接插入排序 希尔排序 选择排序 简单选择排序 堆排序 归并排序 基数排序 总结 简介 排序是计算机内经常进行的一种操作，其目的是将一组“无序”的记录序列调整为“有序”的记录序列。分内部排序和外部排序。若整个排序过程不需要访问外存便能完成，则称此类排序问题为内部排序。反之，若参加排序的记录数量很大，整个序列的排序...
C# 数组排序方法
21号先锋者
02-13 6194
using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; namespace _1209_数组排序方法 { class Program { //在C#中常用的数组排序的方法有：选择排序法、冒...
C#中常见排序方法
无限代码路
06-26 999
C#中常见排序方法快速排序、堆排序、C#的list自带Sort方法排序、Linq、List自带OrderBy排序 快速排序 堆排序 C#的list自带Sort方法排序 Linq List自带OrderBy排序
C# abstract抽象类的定义，作用（使用场景）
热门推荐
lizhenxiqnmlgb的博客
09-03 4万+
关于C#中抽象类的一些感想 写代码已经有很长一段时间， 但感觉成长很少，基本是为了功能开发而开发，我相信80%的程序员都一样，基本都是拿网上的开源项目改改改后实现功能就行， 很少会去深入，去思考为什么要这么来实现，所以有了今天的文章，我作为程序员小白鼠把C#中的抽象类学习中的感想跟大家分享一下： 什么是抽象类 抽象类的应用场景 实例代码 1.什么是抽象类 我先来个百度百科的词条...
C#中Abstract 、Virtual和Override的使用
xinxijike的博客
06-10 113
转载自：https://www.cnblogs.com/akwwl/archive/2012/08/03/2622026.html abstract 修饰符指示所修饰的内容缺少实现或未完全实现。 abstract 修饰符可用于类、方法、属性、索引器和事件。在类声明中使用abstract修饰符以指示某个类只能是其他类的基类。标记为抽象或包含在抽象类中的成员必须通过从抽象类派生的类来实现。 (1)抽象类具有以下特性： 抽象类不能实例化。 抽象类可以包含抽象方法和抽象访问器。 不能用 sealed
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值