asp.net c#冒泡排序算法实现代码

1、用第三个变量值交换

int a = 1;
int b = 2;
int c = a;
a = b;
b = c;
2、用加减法交换

a = a + b;
b = a - b;
a = a - b;

a = a - b;
b = a + b;
a = b - a;3、用异或(XOR)法交换

 a = a ^ b;
 b = a ^ b;
 a = a ^ b;详细可看codeproject上一篇文章 <<神奇的异或 The Magical Exclusive OR (XOR)>>下面我们要在冒泡排序算法中测试一下这三种交换方法的效率

 代码如下 复制代码

  public enum EChangeType
    {
        /// <summary>
        /// 用第三方变量temp进行前后值交换
        /// </summary>
        ThridVar,
        /// <summary>
        /// 用a=a+b;b=a-b;a=a-b 计算方法进行前后值交换
        /// </summary>
        Js,
        /// <summary>
        /// 用a=a^b;b=a^b;a=a^b 计算方法进行前后值交换
        /// </summary>
        XOR
    }/// <summary>
    /// 冒泡排序算法:
    /// a、首先将所有待排序的数字放入工作列表中
    /// b、从列表的第一个数字到倒数第二个数字,逐个检查:若某一位上的数字大于他的下一位,则将它与它的下一位交换
    /// c、重复2号步骤,直至再也不能交换
    /// </summary>
    public class BubbleSort
    {
        public void Sort(int[] arrInt, EChangeType type)
        {
            System.Diagnostics.Stopwatch st = new System.Diagnostics.Stopwatch();
            st.Start();
            int count = 0;
            int temp;
            bool hasExchangeAction; //记录此次大循环中相邻的两个数是否发生过互换(如果没有互换,则数组已经是有序的)

            for (int i = 0; i < arrInt.Length - 1; i++)
            {
                count++;
                hasExchangeAction = false;  //每次大循环都假设数组有序

                for (int j = i + 1; j < arrInt.Length; j++)
                {
                    count++;
                    if (arrInt[i] > arrInt[j])
                    {
                        switch (type)
                        {
                            case EChangeType.ThridVar:
                                temp = arrInt[i];
                                arrInt[i] = arrInt[i + 1];
                                arrInt[i + 1] = temp;
                                break;
                            case EChangeType.Js:
                                arrInt[i] = arrInt[i] + arrInt[j];
                                arrInt[j] = arrInt[i] - arrInt[j];
                                arrInt[i] = arrInt[i] - arrInt[j];
                                break;
                            case EChangeType.XOR:
                                arrInt[i] = arrInt[i] ^ arrInt[j];
                                arrInt[j] = arrInt[i] ^ arrInt[j];
                                arrInt[i] = arrInt[i] ^ arrInt[j];
                                break;
                            default:
                                break;
                        }
                        hasExchangeAction = true;   //发生过互换
                    }
                }

                if (!hasExchangeAction) //如果没有发生过互换,则数组已经是有序的了,跳出循环
                {
                    break;
                }
            }
            st.Stop();
            switch (type)
            {
                case EChangeType.ThridVar:
                    Console.WriteLine("用第三方变量temp进行前后值交换:");
                    break;
                case EChangeType.Js:
                    Console.WriteLine("用a = a + b; b = a - b; a = a - b;(或a = a - b; b = a + b; a = b - a;) n计算方法进行前后值交换:");
                    break;
                case EChangeType.XOR:
                    Console.WriteLine("用a = a ^ b; b = a ^ b; a = a ^ b; 计算方法进行前后值交换:");
                    break;
                default:
                    break;
            }
            Console.WriteLine("循环总数:{0} 排序耗时:{1}{2}", count, st.ElapsedMilliseconds,Environment.NewLine);
        }
    }

static void Main(string[] args)
        {
            List<int> list = new List<int>();
            for (int i = 100 * 100; i >= 0; i--)
            {
                list.Add(i);
            }
            Console.WriteLine("对100 * 100个数字进行冒泡排序{0}", Environment.NewLine);
       
            new BubbleSort().Sort(list.ToArray(), EChangeType.ThridVar);
        
            new BubbleSort().Sort(list.ToArray(), EChangeType.Js);         
      
            new BubbleSort().Sort(list.ToArray(), EChangeType.XOR);
       
            Console.ReadLine();
        }结果

 

人生无处不PK

时间: 2024-10-02 14:52:44

asp.net c#冒泡排序算法实现代码的相关文章

Java实现冒泡排序与双向冒泡排序算法的代码示例_java

冒泡排序:就是按索引逐次比较相邻的两个元素,如果大于/小于(取决于需要升序排还是降序排),则置换,否则不做改变 这样一轮下来,比较了n-1次,n等于元素的个数:n-2, n-3 ... 一直到最后一轮,比较了1次 所以比较次数为递减:从n-1 到 1 那么总的比较次数为:1+2+3+...+(n-1),  以等差公式计算:(1+n-1)/2*(n-1) ==> n/2*(n-1) ==> (n^2-n) * 0.5 用大O表示算法的时间复杂度:O(n^2) ,  忽略了系数0.5和常数-n p

C#实现冒泡排序算法的代码示例_C#教程

1.原理:从数组的第一个位置开始两两比较array[index]和array[index+1],如果array[index]大于array[index+1]则交换array[index]和array[index+1]的位置,止到数组结束; 从数组的第一个位置开始,重复上面的动作,止到数组长度减一个位置结束; 从数组的第一个位置开始,重复上面的动作,止到数组长度减二个位置结束; ....2.时间复杂度:O(N²),进行了(n-1)*(n-2)....=n*(n-1)/2次比较和约比较次数一半的交换

经典排序算法之冒泡排序(Bubble sort)代码_C#教程

经典排序算法 - 冒泡排序Bubble sort 原理是临近的数字两两进行比较,按照从小到大或者从大到小的顺序进行交换, 这样一趟过去后,最大或最小的数字被交换到了最后一位, 然后再从头开始进行两两比较交换,直到倒数第二位时结束,其余类似看例子 例子为从小到大排序, 原始待排序数组| 6 | 2 | 4 | 1 | 5 | 9 | 第一趟排序(外循环) 第一次两两比较6 > 2交换(内循环) 交换前状态| 6 | 2 | 4 | 1 | 5 | 9 | 交换后状态| 2 | 6 | 4 | 1

C#冒泡排序算法,调试不通过,求大神

问题描述 C#冒泡排序算法,调试不通过,求大神 今天老师布置个冒泡排序法的作业,用C#做.弄了很久,就是不能实现如下结果.求求大神棒棒我,帮我调好代码,今天就要交作业,痛苦啊.可以打开下面地址直接调制代码: http://www.manonggu.com/biancheng/12 调试好了,可以保存,然后分享地址小窗口发给我,必有重谢!! 我这边继续做下一个作业.帮帮我啊 解决方案 前面那位仁兄的代码我改了一下,这样应该能过了 public void BubbleSort() { int tem

又一个PHP实现的冒泡排序算法分享_php实例

经典的冒泡排序法一直是许多程序沿用的其中一种排序法,话说冒泡排序法在效率上比PHP系统函数sort更高效.本章不讨论性能,所以就不拿它来跟系统性能做对比了. 冒泡排序大概的意思是依次比较相邻的两个数,然后根据大小做出排序,直至最后两位数.由于在排序过程中总是小数往前放,大数往后放,相当于气泡往上升,所以称作冒泡排序.但其实在实际过程中也可以根据自己需要反过来用,大树往前放,小数往后放. <?php /** * PHP中的冒泡排序法使用 */ // 预先声明一个数组 $arr = array (1

c语言中的冒泡排序算法

问题描述 c语言中的冒泡排序算法 直接上代码,图: #include #include #include typedef struct{ int*pt; int cur; int len; }intArr; void bubblesort(intArr*ia){ int i,j,t,n=ia->cur; for(i=n;i>2;i--) for(j=1;j if(ia->pt[j]>ia->pt[j-1]){ t=ia->pt[j-1]; ia->pt[j-1]=

Java实现冒泡排序算法及对其的简单优化示例_java

原理 冒泡排序大概是所有程序员都会用的算法,也是最熟悉的算法之一. 它的思路并不复杂: 设现在要给数组arr[]排序,它有n个元素. 1.如果n=1:显然不用排了.(实际上这个讨论似乎没什么必要) 2.如果n>1: (1)我们从第一个元素开始,把每两个相邻元素进行比较,如果前面的元素比后面的大,那么在最后的结果里面前者肯定排在后面.所以,我们把这两个元素交换.然后进行下两个相邻的元素的比较.如此直到最后一对元素比较完毕,则第一轮排序完成.可以肯定,最后一个元素一定是数组中最大的(因为每次都把相对

C语言冒泡排序算实现代码_C 语言

冒泡排序是排序算法的一种,思路清晰,代码简洁,常被用在大学生计算机课程中. "冒泡"这个名字的由来是因为越大的元素会经由交换慢慢"浮"到数列的顶端,故名. 这里以从小到大排序为例进行讲解. 基本思想及举例说明 冒泡排序的基本思想就是不断比较相邻的两个数,让较大的元素不断地往后移.经过一轮比较,就选出最大的数:经过第2轮比较,就选出次大的数,以此类推. 下面以对 3  2  4  1 进行冒泡排序说明. 第一轮 排序过程3  2  4  1    (最初) 2  3 

Java实现的各种排序算法(插入排序、选择排序算法、冒泡排序算法)_java

一.插入排序算法实现java版本 public static int[] insert_sort(int[] a) { for (int i = 0; i < a.length; i++) { for(int j=i+1;j>0&&j<a.length;j--) { if(a[j]<a[j-1]) { int tmp = a[j]; //这样定义初始化逻辑上是可以的,j变量,每次tmp的值变化的 a[j] = a[j-1]; a[j-1] = tmp; } } }