精华内容
下载资源
问答
  • C#直接选择排序

    千次阅读 2019-01-20 20:18:00
    数组用直接选择法进行大到小排序 开发工具与技术:工具:Visual Studio/c#,技术:C# 作者:刘胜 撰写时间:2019-01-20 一、直接选择排序的基本思想 基本思想:直接选择排序的基本思想是将指定排序位置...

    数组用直接选择法进行大到小排序

    开发工具与技术:工具:Visual Studio/c#,技术:C#
    作者:刘胜
    撰写时间:2019-01-20


    一、直接选择排序的基本思想

    基本思想:直接选择排序的基本思想是将指定排序位置与其他数组元素分别对比,如果满足条件就交换元素值,注意这里区别冒泡排序,不是交换相邻元素,而是把满足条件的元素与指定的排序位置交换(如从最后一个元素开始排序),这样排序好的位置逐渐扩大,最后整个数组都成为已排序好的格式。
    直接选择排序方法属于选择排序的一种,它的排序速度要比冒泡排序快一些,也是常用的排序算法。(补充)

    二、算法示例
    每一趟从待排序的数据元素中选择最大(或最小)的一个元素,顺序地放在已排好序的数列的最后,直到全部待排序的数据元素排完。
    列如:
    初始数组资源【100, 23, 11, 2, 5】
    第一趟排序后【100, 23, 11, 5】2
    第二趟排序后【100, 23, 11】2,5
    第三趟排序后【100, 23】2,5,11
    第四趟排序后【100】2,5,11,23

    三、算法实现

     static void Main(string[] args) 
     {
         sort();//调用sort();
     }   
     static void sort(){
    
       int[] array = { 100, 23, 11, 2, 5 };//初始数组
    
       for (int i = 0; i < array.Length; i++){
       
       int index = i;
       
       for (int j = 1 + i; j < array.Length; j++){
          if (array[j] > array[index])
             {
                  index = j;//比较最大的值之后,把索引赋给index,作为下一次比较
             }
          }
           int temp = array[i];//存放临时变量
           array[i] = array[index];
           array[index] = temp;
       }
       var t = from i in array where i > 10 select i;//Linq语句
       Console.Write("first Num is:{0} ", array[0]);//输出数组中的最大值
    
       Console.WriteLine("\n\tarray.TypeName is: {0} \n\t t.TypeName is: {1} ", array.GetType().Name, t.GetType().Name);//打印数组类型
       string arrayloop = "";
       
       do
         {
              string tm = showArray(array);
              Console.WriteLine("\nDo you console array[yes][no]");
              arrayloop = Console.ReadLine();
              Console.WriteLine();
          } while (arrayloop.ToLower() == "yes");
      }
     static string showArray(int[] array)//打印数组顺序
     {
        string str = "";
        for (int i = 0; i < array.Length; i++)
        {
            Console.Write("{0}> ", array[i]);
        }
        str = Console.ReadLine();
        return str;
     }

    四、运行结果
    在这里插入图片描述

    展开全文
  • 直接插入排序 冒泡排序 快速排序 直接选择排序排序 二路归并排序 C#源代码 使用C#实现的数据结构中的排序算法
  • //C# 快速排序 #region 快速排序 static void QuickSort(int[] array, int left,int right) { if (left < right) { int x = array[left]; ...
          //C#  快速排序
      #region  快速排序
            static void QuickSort(int[] array, int left,int right) 
            {
                if (left < right) 
                {
                    int x = array[left];
                    int i = left;
                    int j = right;
    
                    while (i < j) 
                    {
                        while (i < j)
                        {
                            if (x < array[j])
                            {
                                j--;
                            }
                            else
                            {
                                array[i] = array[j];
                                break;
                            }
                        }
    
                        while (i < j)
                        {
                            if (x > array[i])
                            {
                                i++;
                            }
                            else
                            {
                                array[j] = array[i];
                                break;
                            }
                        }
                    }
                    array[i] = x;
                    QuickSort(array,left,i-1);
                    QuickSort(array,i+1,right);
                }
            }
            #endregion
    
    
    
    //直接插入排序
    
    #region 直接排序
            static void InsertSort(int[] array)
            {
                for (int i = 1; i < array.Length; i++)
                {
                    int iVaule = array[i];
                    bool isInsert = false; //是否插入
                    for (int j = i - 1; j >= 0; j--)
                    {
                        if (array[j] > iVaule)
                        {
                            array[j + 1] = array[j];
                        }
                        else
                        {
                            array[j+1] = iVaule;
                            isInsert = true;
                            break;
                        }
                    }
                    if (isInsert == false)
                    {
                        array[0] = iVaule; //array[i]比前面都小,插入第一个
                    }
                }
            }
            #endregion
    
    //选择排序
    //选取一个数组中最小的值,与数组第一个值比较,
    //然后从不包括第一个位置的值中选取最小值,与与数组第2个值比较,以此类推
    //直到序列只剩下一个值为止
    #region 选择排序
            static void SelectSort(int[] array)
            {
                for (int i = 0; i < array.Length - 1; i++)
                {
                    int min = array[i];// 最小数
                    int index = i;//记录最小数的下标
                    for (int j = i+1; j < array.Length; j++)
                    {                    if (array[j] < min)
                        {
                            min = array[j];
                            index = j;
                        }
                    }
                    if (min != array[i])
                    {
                        int temp = array[i];
                        array[i] = array[index];
                        array[index] = temp;
                    }
                }
            }
            #endregion
    

     

    展开全文
  • 直接排序结果 " );  outlist(arr);  Console.WriteLine( " 本次排序交换{0}次,循环{1}次n " , change, loop);  }   public   void  StraightSort( int [] arr)  // 直接插入排序  {   int  i, j,temp;...
    using System;
    using System.Collections.Generic;
    using System.Text;

    namespace Sorts
    {
        
    class Sort
        {
            
    public void swap(ref int x, ref int y)
            {
                
    int temp;
                temp 
    = x;
                x 
    = y;
                y 
    = temp;
            }

            
    public void outlist(int[] arr)
            {
                
    foreach (int x in arr) //输出
                {
                    Console.Write(
    "{0}t", x);
                }
            }

            
    public void BubbleSort(int[] arr)  //冒泡排序
            {
                
    int i, j, change=0,loop=0;
                
    bool exchange;
                
    for (i = 0 ; i &lt; arr.Length ; i++)  //最多做R.Length-1次排序
                {
                    exchange 
    = false;
                    
    // ***从大到小排列***
                    
    //for (j = arr.Length - 2; j &gt;= i; j--)
                    
    //{

                    
    //    if (arr[ j + 1 ] &gt; arr[ j ])
                    
    //    {
                    
    //        swap(ref arr[j], ref arr[j + 1]);
                    
    //        exchange = true;
                    
    //    }

                    
    //***从小到大排列***
                    for (j = 0; j &lt; arr.Length - 1; j++)
                    {

                        
    if (arr[j] &gt; arr[j + 1])
                        {
                            swap(
    ref arr[j], ref arr[j + 1]);
                            change
    ++;
                            exchange 
    = true;
                        }
                       
                    }
                    
    if (!exchange) //本次未发生排序,提前终止算法
                    { break; }
                    loop
    ++;
                }
                Console.WriteLine(
    "冒泡排序结果:");
                outlist(arr);
                Console.WriteLine(
    "本次排序交换{0}次,循环{1}次n",change,loop);
            }

            
    public void SelectSort(int[] arr)  //直接选择排序
            {
                
    int i,j,min,change=0,loop=0;
                
    for ( i = 0; i &lt; arr.Length-1; i++)
                {
                    min 
    = i;
                    
    for ( j = i+1; j &lt; arr.Length; j++)
                    {
                        
    if (arr[j] &lt; arr[min])     //此处改为"&gt;"则从大到小排列
                            min = j;                    
                    }
                    swap(
    ref arr[min], ref arr[i]);
                    change
    ++;
                    loop
    ++;
                    
                }
                Console.WriteLine(
    "直接排序结果");
                outlist(arr);
                Console.WriteLine(
    "本次排序交换{0}次,循环{1}次n", change, loop);
            }

            
    public void StraightSort(int[] arr)       //直接插入排序
            {
                
    int i, j,temp;
                
    for (i = 1; i &lt; arr.Length; i++)
                {
                    j 
    = i ;
                    temp 
    = arr[i];
                    
    while ((j &gt; 0&amp;&amp; (arr[j-1&gt;= temp))
                    {
                        arr[j] 
    = arr[j - 1];  
                        j
    --;
                    }
                    arr[j] 
    = temp;
                }
                Console.WriteLine(
    "直接插入结果");
                outlist(arr);
            }



            
    static void Main()
            {
                Sort obj 
    = new Sort();
                
    int[] myarr = new int[10] ;
                Random rand 
    = new Random();
                
    for (int i = 0; i &lt; 10; i++)
                {
                    myarr[i] 
    = rand.Next(0100);
                }
                Console.WriteLine(
    "随机数组是:");
                
    foreach (int x in myarr)  //输出
                {
                    Console.Write(
    "{0}t", x);
                }
                Console.WriteLine();
                obj.BubbleSort(myarr);
                obj.SelectSort(myarr);
                obj.StraightSort(myarr);
              
            }
        }
    }
     
    展开全文
  • C#选择排序交错数组

    2018-09-13 11:32:01
    C#中,我们应该怎么对C#中的交错数组进行排序呢? 话不多说,直接上代码:

    在C#中,我们应该怎么对C#中的交错数组进行排序呢?
    话不多说,直接上代码:

     

    展开全文
  • 用Visual c# 2015,文本框输入10个数,C#实现选择和插入排序
  • 排序直接选择排序

    千次阅读 热门讨论 2016-10-23 19:03:56
    直接选择排序
  • C#版冒泡排序优化

    千次阅读 2015-02-05 21:25:05
    C#版冒泡排序优化。
  • 直接插入排序(Straight Insertion Sort) 直接插入排序是一种最简单的排序方法,其基本操作是将一条记录插入到已排好的有序表中,从而得到一个新的、记录数量增1的有序表。 示例: public class Program { ...
  • 排序是在编程过程中会经常遇到,并且十分重要,在了解排序算法前,先了解下排序的基本概念 排序项:作为排序依据的数据称为排序项,也称为记录的关键码(Keyword) * 关键码(关键码分为两种) * 主关键码 (Primary ...
  • 选择排序: public void Sort(int[] list) { int min; for (int i = 0; i ; ++i) { min = i; for (int j = i + 1; j ; ++j) { if (list[j] [min]) min = j;// min就是剩下元素中最小的那个的索引值 } ...
  • 直接插入排序法,假设数组arr[n],先选取arr[1],将arr[1]保存为temp,再将arr[1]与arr[0]比较,如果arr[1]小于它前面的arr[0],则将arr[0]的值右移至arr[1]的位置,即把arr[i]与arr[i-1]作比较,如果arr[i]小于arr[i-1...
  • 算法 - 插入排序C#

    万次阅读 多人点赞 2019-02-01 10:58:01
    * 直接插入排序(straight insertion sort)的做法是: * 每次从无序表中取出第一个元素,把它插入到有序表的合适位置使有序表仍然有序,直至无序表中所有元素插入完为止。 * 第一趟扫描前两个数,然后把第二个数...
  • C# 插入排序

    2021-01-08 14:45:03
    C#插入排序 建议新人不要直接复制,最好手打,最好看过一遍之后根据自己的记忆和理解码出来。 不用有太大压力,就两个for循环,最好不要背,靠理解,否则直接背过没有任何帮助。 using System; namespace ...
  • 直接插入排序是一种简单直观的排序算法。工作原理:①、将数组分成两部分,一部分为以排序数组,一部分为待排序数组。②、将待排序数组的第一个元素与以排序数组的最后一个元素进行比较,若待排序数组的第一个元素比...
  • C# ObservableCollection集合排序

    千次阅读 2018-10-24 16:57:03
    注意:ObservableCollection集合 直接使用OrderBy 等函数排序,有问题的,排序不改变,可以转成List在进行排序 命名空间:System.Collections.ObjectModle 在WPF中,绑定列表List,数据更新后不会通知界面更新,要...
  • C# 数组排序

    2015-07-27 12:05:16
    如果要直接调用C#数组的Sort()方法对数组进行排序(如:Array.Short();list.Short().....),则必须要存储在数组中的对象实现IComparable或IComparable接口,并实现CompareTo方法来指定用于排序的字段。比如实现了...
  • C# 经典排序算法大全

    千次阅读 2014-10-22 16:56:29
    C# 经典排序算法大全 选择排序 using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace sorter { public class SelectionSorter { private int min; pub
  • #region 希尔排序 ... /// 组内进行直接插入排序;然后取d2<d1, /// 重复上述分组和排序操作;直至di=1,即所有记录放进一个组中排序为止 /// </summary> /// <param name="a">.
  • C#实现冒泡排序

    2014-03-07 14:26:43
    感谢 morewindows,这里用C# 实现3种冒泡排序方法。 运算复杂度,很显然是O(n^2) using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace 排序 { /// /// 冒泡排序...
  • C#中DataTable排序和检索

    千次阅读 2016-11-04 15:06:30
    一、排序 1.获取DataTable的默认视图 2.对视图设置排序表达式 3.用排序后的视图导出的新DataTable替换就DataTable(Asc升序可省略,多列排序用","隔开) 1)、重生法 ...2)、直接法 dv = New DataV
  • c# 插入排序

    2017-09-04 12:30:54
    public void InsertSortMin(int[] array) { for (int i = 1; i ; i++)// { int temp = array[i];//记录进行排序的值,并空出i的位置 for (int j =
  • C#常用的排序方法

    千次阅读 2019-06-01 11:36:22
    快速排序由于排序效率综合来说你几种排序方法中效率较高,因此经常被采用,再加上快速排序思想----分治法也确实实用.快速排序是C.R.A.Hoare于1962年提出的一种划分交换排序。它采用了一种分治的策略,通常称其为分治...
  • c#文件排序和文件夹排序

    千次阅读 2016-02-02 11:23:24
    一、C#文件排序  1、按名称顺序排列  ///  /// C#按文件名排序(顺序)  ///  /// 待排序数组  private void SortAsFileName(ref FileInfo[] arrFi)  {  Array.Sort(arrFi, delegate...
  • 直接插入排序:这个算法起源将一个数据插入到一个有序的数列中。从后往前一个一个比较,当找到插入点时,直接插入,不影响有序性。对于一个乱序的数列,将该算法重复使用,先排序前两个,再排序前三个…直到排到最后...
  • DataGirdView实现排序功能有两种方式 1.绑定到List,然后通过列表头双击事件来对数据排序,然后再重新绑定到DataGridView,此方式列表头上面不会出现向上向下箭头 2 绑定到DataTable,此方式会自动可以通过双击列...
  • C#快速排序算法

    千次阅读 2018-09-13 16:28:44
    今天重温了下排序算法,包括冒泡排序法和直接排序法,这些都比较简单,只是快速排序法比较难,于是重点研究了下。  先说一说原理:快速排序法是采用递归的方式对待排序的数列进行若干次的操作,每次操作使得被操作...
  • 直接插入排序,简单点说就是是指在已排序好的序列中相应的位置插入需要排序的元素。 比如某个有序序列为:{1,4,5,7},现在需要将3插入到序列中,我们只需要从序列的末尾(升序中最大的元素)开始寻找正确的插入...
  • C#Sort排序

    千次阅读 2017-09-26 14:34:01
    本文转载自http://blog.csdn.net/zhulongxi/article/details/51457891 同时也加入了自己制作的一个例子供大家学习参考,以便更好的理解这个排序

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 41,553
精华内容 16,621
关键字:

c#直接选择排序

c# 订阅