`

C#实现所有经典排序算法(选择排序,冒泡排序,快速排序,插入排序,希尔排序)

    博客分类:
  • c#
阅读更多

C#实现所有经典排序算法
1、选择排序

class SelectionSorter    
{    
    private int min;    
    public void Sort(int[] arr)    
    {    
        for (int i = 0; i < arr.Length - 1; ++i)    
        {    
            min = i;    
            for (int j = i + 1; j < arr.Length; ++j)    
            {    
                if (arr[j] < arr[min])    
                    min = j;    
            }    
            int t = arr[min];    
            arr[min] = arr[i];    
            arr[i] = t;    
        }    
    }    
    static void Main(string[] args)    
    {    
        int[] array = new int[] { 1, 5, 3, 6, 10, 55, 9, 2, 87, 12, 34, 75, 33, 47 };    
        SelectionSorter s = new SelectionSorter();    
        s.Sort(array);    
        foreach (int m in array)    
            Console.WriteLine("{0}", m);    
    }    
} 

 2、冒泡排序

class EbullitionSorter    
{    
    public void Sort(int[] arr)    
    {    
        int i, j, temp;    
        bool done = false;    
        j = 1;    
        while ((j < arr.Length) && (!done))//判断长度    
        {    
            done = true;    
            for (i = 0; i < arr.Length - j; i++)    
            {    
                if (arr[i] > arr[i + 1])    
                {    
                    done = false;    
                    temp = arr[i];    
                    arr[i] = arr[i + 1];//交换数据    
                    arr[i + 1] = temp;    
                }    
            }    
            j++;    
        }    
    }    
static void Main(string[] args)    
    {    
        int[] array = new int[] { 1, 5, 3, 6, 10, 55, 9, 2, 87, 12, 34, 75, 33, 47 };    
        EbullitionSorter e = new EbullitionSorter ();    
        e.Sort(array);    
        foreach (int m in array)    
            Console.WriteLine("{0}", m);    
   
    }    
} 

 

 

3、快速排序

class QuickSorter    
{    
    private void swap(ref int l, ref int r)    
    {    
        int temp;    
        temp = l;    
        l = r;    
        r = temp;    
    }    
    public void Sort(int[] list, int low, int high)    
    {    
        int pivot;//存储分支点    
        int l, r;    
        int mid;    
        if (high <= low)    
            return;    
        else if (high == low + 1)    
        {    
            if (list[low] > list[high])    
                swap(ref list[low], ref list[high]);    
            return;    
        }    
        mid = (low + high) >> 1;    
        pivot = list[mid];    
        swap(ref list[low], ref list[mid]);    
        l = low + 1;    
        r = high;    
        do   
        {    
        while (l <= r && list[l] < pivot)    
            l++;    
        while (list[r] >= pivot)    
            r--;    
            if (l < r)    
                swap(ref list[l], ref list[r]);    
        } while (l < r);    
        list[low] = list[r];    
        list[r] = pivot;    
        if (low + 1 < r)    
            Sort(list, low, r - 1);    
        if (r + 1 < high)    
            Sort(list, r + 1, high);    
    }    
   
    static void Main(string[] args)    
    {    
        int[] iArrary = new int[] { 1, 5, 3, 6, 10, 55, 9, 2, 87, 12, 34, 75, 33, 47 };    
        QuickSorter q = new QuickSorter();    
        q.Sort(iArrary, 0, 13);    
        for (int m = 0; m <= 13; m++)    
            Console.WriteLine("{0}", iArrary[m]);    
    }    
}    

 4、插入排序

public class InsertionSorter    
{    
    public void Sort(int[] arr)    
    {    
        for (int i = 1; i < arr.Length; i++)    
        {    
            int t = arr[i];    
            int j = i;    
            while ((j > 0) && (arr[j - 1] > t))    
            {    
                arr[j] = arr[j - 1];//交换顺序    
                --j;    
            }    
            arr[j] = t;    
        }    
    }    
    static void Main(string[] args)    
    {    
        int[] array = new int[] { 1, 5, 3, 6, 10, 55, 9, 2, 87, 12, 34, 75, 33, 47 };    
        InsertionSorter i = new InsertionSorter();    
        i.Sort(array);    
        foreach (int m in array)    
            Console.WriteLine("{0}", m);     
    }    
}    

 5、希尔排序

public class ShellSorter    
{    
    public void Sort(int[] arr)    
    {    
        int inc;    
        for (inc = 1; inc <= arr.Length / 9; inc = 3 * inc + 1) ;    
        for (; inc > 0; inc /= 3)    
        {    
            for (int i = inc + 1; i <= arr.Length; i += inc)    
            {    
                int t = arr[i - 1];    
                int j = i;    
                while ((j > inc) && (arr[j - inc - 1] > t))    
                {    
                    arr[j - 1] = arr[j - inc - 1];//交换数据    
                    j -= inc;    
                }    
                arr[j - 1] = t;    
            }    
        }    
    }    
   
    static void Main(string[] args)    
    {    
        int[] array = new int[] { 1, 5, 3, 6, 10, 55, 9, 2, 87, 12, 34, 75, 33, 47 };    
        ShellSorter s = new ShellSorter();    
        s.Sort(array);    
        foreach (int m in array)    
            Console.WriteLine("{0}", m);     
    }    
}   

  文章来自学IT网:http://www.xueit.com/html/2009-05/21_1771_00.html

 

 

分享到:
评论

相关推荐

    C# 排序算法大全参考资料,比较清淅的一个版本。集中介绍了C#中的冒泡算法、选择排序、插入排序、希尔排序等常用算法,并包含示例代码和注意事项等。

    本文将深入探讨C#中常见的四种排序算法:冒泡排序、选择排序、插入排序和希尔排序,以及它们的实现细节和应用场合。 首先,我们来看**冒泡排序**。冒泡排序是一种简单的交换排序方法,它通过不断比较相邻元素并交换...

    C# 常用经典算法,选择排序 冒泡排序 快速排序 插入排序 希尔排序

    根据给定的信息,本文将详细介绍五种经典的排序算法在 C# 中的应用,包括选择排序、冒泡排序、快速排序、插入排序以及希尔排序。 ### 一、选择排序 选择排序是一种简单直观的比较排序算法。它的工作原理是通过从未...

    C# 插入排序 冒泡排序 选择排序 快速排序 堆排序 归并排序 基数排序 希尔排序

    在编程领域,排序算法是数据结构与算法中的基础部分,对于C#开发者来说,理解并掌握各种排序算法的实现和性能至关重要。以下是对标题和描述中提到的几种排序算法的详细解析: 1. **插入排序**(Insertion Sort): ...

    c#实现所有经典排序算法

    根据给定的信息,本文将详细解释C#语言中几种经典的排序算法实现,包括选择排序(Selection Sort)、冒泡排序(Bubble Sort)、快速排序(Quick Sort)、插入排序(Insertion Sort)以及希尔排序(Shell Sort)。...

    C#实现所有经典排序算法

    文介绍了C#的四种排序算法:冒泡排序、选择排序、插入排序和希尔排序 冒泡排序 using System; namespace BubbleSorter { public class BubbleSorter { public void Sort(int [] list) { int i,j,temp; bool done=...

    c#的算法 选择排序 冒泡排序 快速排序 插入排序 。。。

    根据给定的信息,本文将详细解释C#中的几种基本排序算法:选择排序、冒泡排序、快速排序、插入排序、希尔排序以及归并排序的基本原理和实现方式。 ### 一、选择排序(Selection Sort) #### 算法原理 选择排序是一...

    C#四种排序算法(冒泡排序)

    在C#编程中,排序算法是数据处理和分析的基础,常见的有冒泡排序、插入排序、选择排序和希尔排序。这四种排序算法各有特点,适用不同的场景。 1. **冒泡排序**: 冒泡排序是一种简单的排序算法,通过不断交换相邻...

    C#的四种排序算法:冒泡、选择、插入和希尔

    本文将深入探讨C#中实现的四种经典排序算法:冒泡排序、选择排序、插入排序和希尔排序。每种算法都有其特定的应用场景和性能特点,理解它们的工作原理对于提升编程技能和优化代码效率至关重要。 首先,我们来看**...

    C#四种排序算法 冒泡排序、选择排序、插入排序和希尔排序

    ### C#中的四种排序算法详解 #### 一、冒泡排序 冒泡排序是一种简单的排序算法,它重复地遍历待排序的数列,依次比较相邻的两个元素,如果它们的顺序错误就把它们交换过来。遍历数列的工作是重复进行的,直到没有...

    c#排序算法 冒泡,插入,希尔,选择,堆排序

    本文将详细解析标题中提到的五种排序算法:冒泡排序、插入排序、希尔排序、选择排序以及堆排序。这五种算法在不同的场景下有着各自的应用优势,理解它们的工作原理能帮助我们更好地优化代码性能。 1. **冒泡排序**...

    经典算法的C#源码实现

    经典的排序算法C#源码,包括: 经典排序算法 - 快速排序Quick sort 经典排序算法 - 桶排序Bucket sort 经典排序算法 - 插入排序Insertion sort 经典排序算法 - 基数排序Radix sort 经典排序算法 - 鸽巢排序...

    C#排序算法冒泡 选择 插入 希尔

    本文将详细介绍四种经典的排序算法:冒泡排序、选择排序、插入排序以及希尔排序,并提供C#实现的示例代码。 1. 冒泡排序(Bubble Sort) 冒泡排序是一种简单的排序算法,通过重复遍历待排序的序列,依次比较相邻...

    C#经典排序算法集所有经典的算法

    本资源"**C#经典排序算法集**"提供了多种已实现并成功运行的经典排序算法,这将有助于学习者深入理解和应用这些算法。 首先,我们来详细了解一下几种常见的C#排序算法: 1. **冒泡排序(Bubble Sort)**: 冒泡...

    c#实现各种排序算法动态演示

    本文将深入探讨C#实现的排序算法及其动态演示,主要关注以下几个方面:快速排序、冒泡排序、选择排序、插入排序、归并排序以及希尔排序。 1. **快速排序**:快速排序是一种非常高效的排序算法,由英国计算机科学家C...

    C#常用排序算法

    以下是四种常见的C#排序算法:冒泡排序、选择排序、插入排序和希尔排序的详细解释。 1. **冒泡排序**: 冒泡排序是一种简单的交换排序,通过重复遍历数组,比较相邻元素并根据需要交换它们的位置来完成排序。每一...

    c#实现基本排序算法

    本文将详细探讨C#语言中实现的几种基本排序算法,包括冒泡排序、鸡尾酒排序(双向冒泡)、选择排序、插入排序、希尔排序、堆排序和归并排序。 首先,我们来看**冒泡排序**,它是最简单的排序算法之一。通过不断交换...

    c#实现几种排序算法,并输出关键字比较次数和交换次数

    在C#中实现这些排序算法,并统计关键字比较次数和交换次数,有助于程序员更好地评估算法效率,选择最合适的排序方法。同时,这也是学习数据结构和算法的重要实践环节,能提升编程技能和解决问题的能力。在实际项目中...

    用C#实现的排序算法

    根据提供的文件信息,我们可以深入探讨在C#中实现的不同...以上就是C#中实现的选择排序、冒泡排序、快速排序、插入排序以及希尔排序的详细介绍。这些算法各有优缺点,在实际应用中可以根据具体情况选择合适的排序方法。

    C# 各种排序算法实现与对比

    在编程领域,排序算法是数据结构与算法课程中的核心部分,尤其在C#这样的面向对象编程语言中,理解和掌握各种排序算法的实现及其性能特点至关重要。本文将详细讲解C#中实现的几种常见排序算法,并对它们的执行效率...

    排序算法C#源码

    在这个"排序算法C#源码"的压缩包中,你可能会找到多种经典的排序算法实现,例如冒泡排序、插入排序、选择排序、快速排序、归并排序、堆排序等。 1. **冒泡排序**:这是一种简单的排序算法,通过不断交换相邻的不...

Global site tag (gtag.js) - Google Analytics