C#算法(一)冒泡排序

最新推荐文章于 2024-10-13 16:52:53 发布
最新推荐文章于 2024-10-13 16:52:53 发布
阅读量804 收藏 2
点赞数
分类专栏： Selenium 文章标签： 算法 c# list class c path
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xuyubotest/article/details/4683943
版权


一。C#算法(一)冒泡排序

using System;

namespace BubbleSorter
{
 public class BubbleSorter
 {
  public void Sort(int [] list)
  {
   int i,j,temp;
   bool done=false;
   j=1;
   while((j<list.Length)&&(!done))
   {
    done=true;
    for(i=0;i<list.Length-j;i++)
    {
     if(list[i]>list[i+1])
     {
      done=false;
      temp=list[i];
      list[i]=list[i+1];
      list[i+1]=temp;
     }
    }
    j++;
   }

  }
 }
 public class MainClass
 {
  public static void Main()
  {
   int[] iArrary=new int[]{1,5,13,6,10,55,99,2,87,12,34,75,33,47};
   BubbleSorter sh=new BubbleSorter();
   sh.Sort(iArrary);
   for(int m=0;m<iArrary.Length;m++)
    Console.Write("{0} ",iArrary[m]);
   Console.WriteLine();
  }
 }



二。C#算法(二)选择排序
using System;

namespace SelectionSorter
{
 public class SelectionSorter
 { 
  private int min;
  public void Sort(int [] list)
  {
   for(int i=0;i<list.Length-1;i++)
   {
    min=i;
    for(int j=i+1;j<list.Length;j++)
    {
     if(list[j]<list[min])
      min=j;
    }
    int t=list[min];
    list[min]=list[i];
    list[i]=t;
   }



  }
 }
 public class MainClass
 {
  public static void Main()
  {
   int[] iArrary=new int[]{1,5,3,6,10,55,9,2,87,12,34,75,33,47};
   SelectionSorter ss=new SelectionSorter();
   ss.Sort(iArrary);
   for(int m=0;m<iArrary.Length;m++)
    Console.Write("{0}  ",iArrary[m]);
   Console.WriteLine();
  }
 }
}
 

三。C#算法(三)插入排序
using System;

namespace InsertionSorter
{
 public class InsertionSorter
 {
  public void Sort(int [] list)
  {
   for(int i=1;i<list.Length;i++)
   {
    int t=list[i];
    int j=i;
    while((j>0)&&(list[j-1]>t))
    {
     list[j]=list[j-1];
     --j;
    }
    list[j]=t;
   }



  }
 }
 public class MainClass
 {
  public static void Main()
  {
   int[] iArrary=new int[]{1,13,3,6,10,55,98,2,87,12,34,75,33,47};
   InsertionSorter ii=new InsertionSorter();
   ii.Sort(iArrary);
   for(int m=0;m<iArrary.Length;m++)
    Console.Write("{0}",iArrary[m]);
   Console.WriteLine();
  }
 }
}
 

四。C#算法(四)希尔排序
using System;

namespace ShellSorter
{
 public class ShellSorter
 {
  public void Sort(int [] list)
  {
   int inc;
   for(inc=1;inc<=list.Length/9;inc=3*inc+1);
   for(;inc>0;inc/=3)
   {
    for(int i=inc+1;i<=list.Length;i+=inc)
    {
     int t=list[i-1];
     int j=i;
     while((j>inc)&&(list[j-inc-1]>t))
     {
      list[j-1]=list[j-inc-1];
      j-=inc;
     }
     list[j-1]=t;
    }
   }
  }
 }
 public class MainClass
 {
  public static void Main()
  {
   int[] iArrary=new int[]{1,5,13,6,10,55,99,2,87,12,34,75,33,47};
   ShellSorter sh=new ShellSorter();
   sh.Sort(iArrary);
   for(int m=0;m<iArrary.Length;m++)
    Console.Write("{0} ",iArrary[m]);
   Console.WriteLine();
  }
 }
}
 
五。穷举搜索法
求解“百钱买百鸡”，公鸡每只5钱，母鸡每只3钱，小鸡每3只1钱
分析：
      x+y+z=100
      5*x+3*y+z/3=100

  1.void main()
    {
       int x,y,z;
       for (x=0;x<=100;x++)
         for(y=0;y<=100;y++)
           for(z=0;z<=100;z++)
             if(x+y+z=100 &&  5*x+3*y+z/3=100)
               printf("%d%d%d/n",x,y,z)
  }

  2.void main()
    {
       int x,y,z;
       for (x=0;x<=20;x++)
         for(y=0;y<=33;y++)
          {  z=100-x-y;
             if(z%3=0 &&  5*x+3*y+z/3=100)
               printf("%d%d%d/n",x,y,z)
          }
  }


六。递归法
汉诺塔问题
（n阶汉诺塔问题）假设有三个分别命名为A，B和C的塔座，在塔座A上插有n个直径大小各不相同，按小到大编号为1，2，。。。，n的圆盘。现要求将A轴上的n个圆盘移至C上并按同样顺序叠排，圆盘移动时必须遵循下列规则：
   1）每次只能移动一个圆盘；
   2）圆盘可以插在A，B和C中的任一塔座上；
   3）任何时刻都不能将一个较大的圆盘压在较小的圆盘之上。


#include <studio.h>
void move(int n,char a,char c)
{
  static int step=1;
  printf("step %2d: disk %d %c-------> %c/n",step,n,a,c)
  step++;
}
void Hanoi(int n,char a,char b,char c)
{
  if(n>1)
   {
      Hanoi(n-1,a,c,b);   //先将前n-1个盘子从a通过c搬到b
      move(n,a,c);        //将第n个盘子从a搬到c
      Hanoi(n-1,b,a,c);  //再将这前n-1个盘子从b通过a搬到c
   }
  else
   {
     move(n,a,c);       //将这1个盘子从a搬到c
   } 
}

void main()
{Hanoi(3,'A','B','C');}

七。回溯法
求解迷宫问题。迷宫用一个二维数组表示，其元素值有两个：0和1，0表示通路，1表示阻塞，数组左上房[0][0]元素为迷宫入口，右下房[m-1][n-1]元素为迷宫的出口，现在寻找一条从入口到出口的通路（并不一定是最短的）。

#include <studio.h>
#define M 12
#define N 15
void maze(int p[][],int m,int n)
{
  int is[8]={0,1,1,1,0,-1,-1,-1};   //行前进方向：右，右下，下，左下，左，左上，上，右上
  int js[8]={1,1,0,-1,-1,-1,0,-1};  //列前进方向：右，右下，下，左下，左，左上，上，右上
  int stack[3*M*N],*top;
  int i,j,v,g,h,jt;
  top=stack;
  i=j=v=0;
  if(p[0][0]!=0)         //入口无路可走，提示无路，返回；
   {
    p[0][0]=4;printf("no path!/n";return;)
   }
   while(top!=stack || v!=7)
    {
       g=i+is[v];
       h=j+js[v];jt=0;
       if(g>-1 && g<m && h>-1 && h<n)
         { if(g= =m-1 && h= =n-1 && p[m-1][n-1]= =0)
             {
                p[i][j]=8;p[g][h]=8;
                return;                //找到路径，停止返回；
              }
             if (p[g][h]= =0)
             {
                p[g][h]=4;
                p[i][j]=8;             //前一步位置上置8
                top+=3;
                top[0]=i;top[1]=j;top[2]=v;  //入栈，记录下前一步
                i=g;j=h;v=0;jt=1;
             }
        }
      if(jt= =0)
      {
         if(v<7) v++;       //换一个方向
         else
           {
              while(top!stack && top[2]= =7)
              {
                 p[top[0]][top[1]]=4;  //无路，栈中元素置为4，并弹栈
                 top-=3;
               }
             if(top!=stack)
              {
                 i=top[0];j=top[1];v=top[2];   //回溯，弹栈
                 p[i][j]=4;top-=3;
              }
            }

      }
    }
printf("no path!/n");    //无路可走，提示无路，返回
return;
}

void main()
{
  int i,j;
  int p[M][N]={
                        {0,1,0,0,0,1,1,0,0,0,1,1,1,1,1} 
                        {1,0,0,0,1,1,0,1,1,1,0,0,1,1,1}                     
                        {0,1,1,0,0,0,0,1,1,1,1,0,0,1,1}  
                        {1,1,0,1,1,1,1,0,1,1,0,1,1,0,0}
                        {1,1,0,1,1,1,1,0,1,1,0,1,1,0,0}
                        {1,1,0,1,0,0,1,0,1,1,1,1,1,1,1}
                        {0,0,1,1,0,1,1,1,0,1,0,0,1,1,1} 
                        {0,1,1,1,1,0,0,1,1,1,1,1,1,1,1}                     
                        {0,0,1,1,0,1,1,0,1,1,1,1,1,0,1}  
                        {1,1,0,0,0,1,1,0,1,1,0,0,0,0,0}
                        {0,0,1,1,1,1,1,0,0,0,1,1,1,1,0}
                        {0,1,0,0,1,1,1,1,1,0,1,1,1,1,0}       
                    }
maze(p,12,15)

}

结果：

                        {8,1,0,0,0,1,1,4,4,4,1,1,1,1,1} 
                        {1,8,8,8,1,1,4,1,1,1,4,4,1,1,1}                     
                        {0,1,1,8,8,4,4,1,1,1,1,4,4,1,1}  
                        {1,1,8,1,1,1,1,4,1,1,4,1,1,4,4}
                        {1,1,8,1,1,1,1,4,1,1,4,1,1,4,4}
                        {1,1,8,1,0,0,1,4,1,1,1,1,1,1,1}
                        {0,8,1,1,1,1,1,1,4,1,0,0,1,1,1} 
                        {8,1,1,1,1,8,8,1,1,1,1,1,1,1,1}                     
                        {0,8,1,1,8,1,1,8,1,1,1,1,1,0,1}  
                        {1,1,8,8,8,1,1,8,1,1,8,8,8,8,8}
                        {0,0,1,1,1,1,1,0,8,8,1,1,1,1,8}
                        {0,1,0,0,1,1,1,1,1,4,1,1,1,1,8}    




二阶Fibonacci数列的递归算法 

 int f(int n)  
  {  
     if(n<0)  
        {return 0};  
     else
     {  
       if(n==1 || n==2)  
         {return 1; } 
       else  
        {return(f(n-2)+f(n-1));}
    }   
  }  
   
  void  main()  
  {  
  int i;  
  do  
  {  
     cout<<"enter   a   number:"<<endl;  
     cin>>i;  
     cout<<"Fibonacci数列:f("<<i<<")="<<f(i)<<endl;  
  }while(i>0);  
   
  }  



二阶Fibonacci数列的迭代算法

 int f(int n)
{
  if (n<0)
    return 0;
  else
    if(n==1 || n==2)
      return 1;
    else
      int a=1;
      int b=0;
      int s=0;
      for (int i=3;i<n;i++)
      {
        s=a+b;
        b=s;
        a=b;

      }
      return s
}  

   
  void  main()  
  {  
  int i;  
  do  
  {  
     cout<<"enter   a   number:"<<endl;  
     cin>>i;  
     cout<<"Fibonacci数列:f("<<i<<")="<<f(i)<<endl;  
  }while(i>0);  
   
  } 

}



星火测吧
关注
专栏目录
c#算法（1）—冒泡排序
qq_34059233的博客
03-01 2919
前言： 冒泡排序的原理是（以升序为例））： 第一步、假如一共有N个数，从左边第一个数开始，从左到右把相邻的两个元素进行比较，如果右边的比左边的小，则调换两个元素位置，倒数第二个和倒数第一个元素比较完以后，最大的数此时已经在最右边了； 第二步、由于最右边的数已经是最大值了，所以再从左边第一个数开始和右边的数比较，一直比较到倒数第三个数和倒数第二个数； 第三步、以此类推，一直比较到第一个数和第二个数，比较的次数是N-1次。 1、升序 public List<int> BubbleSort_Ascen
（入门）C#中的常用排序算法——冒泡排序（其一）
LBCLBC666的博客
08-03 2202
劲爆！！！劲爆！！！（入门级）C#中的冒泡排序解读及讲解，附带可以Ctrl+C与Ctrl+V的代码
c#的 排序算法--冒泡排序，快速排序
yuanyuanluoluo的博客
02-25 565
交换排序： 包括冒泡排序，快速排序。 选择排序： 包括直接选择排序，堆排序。 插入排序： 包括直接插入排序，希尔排序。 合并排序： 合并排序。 冒泡排序：比较第一个和第二个，后者小于前者两者交换，第二个比较第三个，第三个比较第四个，直到最后，然后重复该过程 9 8 7 6 8 9 7 6 8 7 9 6 8 7 6 9 7 8 6 9 7 6 8 9 6...
（C#）冒泡排序
weixin_30263277的博客
08-09 63
//冒泡排序 public static int[] Bubbling(int[] s) { int a; for (int i = 0; i < s.Length-1; i++) { for (int j =i+ 1; j < s.Length; j++) ...
C# 冒泡排序法示例代码(包含泛型方法)
张庆（网眼）
05-31 5186
using System;using System.Collections.Generic;using System.Text;namespace bleb_sort{    class Program    {        public class SwapObj        {            public static void swap(ref T a, ref T b)  
C#冒泡法对数组进行排序
有你的未来
11-06 1388
从textbox2.读取字符串，然后利用string.split把字符串分割为一个字符数组，再转化成int数组。winform下例程如下 private void button3_Click(object sender, EventArgs e) { string[] s = textBox2.Text.Trim().Split(',');
c# 使用“冒泡”法对数组元素进行排序
#7的博客
04-14 3261
结果如图所示代码如下：using System;using System.Collections.Generic;using System.Linq;using System.Text;using System.Threading.Tasks;namespace ConsoleApp3__冒泡_法排序_数组_{    class Program    {        static void Ma...
C#算法之冒泡排序算法
weixin_50236846的博客
04-22 343
冒泡排序：是一种简单的排序算法，它重复地遍历要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。此外，冒泡排序是稳定的排序算法，这意味着相等的元素在排序后会保持它们原始的顺序。冒泡排序可以通过记录最后一次交换的位置来优化，因为在这个位置之后的元素已经在前面的迭代中被排序好了，所以不需要再次检查。这样可以减少不必要的比较，从而提高效率。创作灵感：数据处理过程中，最常见的就是排序问题，排序的方式由很多种，我会同各位朋友进行逐一的探讨，首先从比较简单的冒泡排序算法说起。
一、C#冒泡排序算法
一个默默的游戏制作者......
03-14 949
冒泡排序的名称来源于元素比较过程中，较大的元素会逐渐向右“冒泡”到正确的位置上。它的时间复杂度为O(n^2)，在实际应用中适用于数据规模较小的情况。在实际应用中，我们需要根据具体情况选择合适的实现方式来平衡代码的可读性和排序效率。同时，如果对排序算法的效率要求较高，可以考虑使用其他更高效的排序算法，如快速排序或归并排序。未完待续。。。。。。。。。。。。。。
C#排序算法一 冒泡排序
weixin_43941291的博客
08-26 1084
// 冒泡排序 public static void BubbleSort<T, C>(T[] array, C comparer) where C : IComparer<T> { int length = array.Length; for (int i = 0; i <= length - 2; i++) { //Console.Write("{0}: ", i + 1); for (int j = length
C#实现冒泡排序算法的代码示例
09-02
冒泡排序是一种基础的排序算法，它通过重复遍历待排序的序列，比较相邻元素并交换位置，使得每个元素都能找到其正确的位置。在C#中实现冒泡排序，我们可以创建一个类`SumSort`，并在其中定义一个方法`PopSort`来完成...
C#-基于C#实现的冒泡排序算法-Bubble-Sort.zip
03-09
冒泡排序是一种基础且历史悠久的排序算法，它通过重复遍历待排序的序列，比较相邻元素并根据需要交换它们的位置，来逐步将序列中的大值“冒”到序列的末尾。在C#中实现冒泡排序，可以深入了解C#的基础语法、控制流...
c#冒泡排序算法示例
09-04
C# 冒泡排序算法示例 冒泡排序算法是一种简单的排序算法，通过不断地比较相邻元素，并交换他们的位置来达到排序的目的。下面是 C# 冒泡排序算法示例的详细解释： 冒泡排序算法的原理 冒泡排序算法的主要思路是，...
打卡第四天 P1081 [NOIP2012 提高组] 开车旅行
hjxxlsx的博客
10-06 486
【代码】打卡第四天 P1081 [NOIP2012 提高组] 开车旅行。
代码随想录算法训练营Day28 | 39. 组合总和、40.组合总和Ⅱ、131.分割回文串
jiabao0520的博客
10-08 1335
训练营第28天：39. 组合总和、40.组合总和Ⅱ、131.分割回文串
在顺序结构和链式结构的线性表上实现顺序检索算法
最新发布
m0_56332819的博客
10-13 93
在顺序结构和链式结构的线性表上实现顺序检索算法，C语言
数组综合应用（下标计数）C++
hjxxlsx的博客
10-08 981
HJ小学信息学社团每个同学都有且仅有一个数字编号（1~1000），现在帅气的吴老师准备举办n个学习项目，信息学社团的每个同学都参加项目且可以参加多个项目。,9共 9个数分成三组，分别组成三个三位数，且使这三个三位数的比例是 A:B:C，试求出所有满足条件的三个三位数，若无解，输出。n，表示参战的士兵数，1<=n<=1000000，第二行为n个整数，表示每位士兵的战功值（战功值<=1000000）。50、80、50、30分，则80分的士兵为第一名，50分的两名士兵均为第二名，30分的士兵为第四名。
力扣10.13
qq_40052678的博客
10-13 246
如果鸡蛋碎了，你就不能再次使用它。如果某枚鸡蛋扔下后没有摔碎，则可以在之后的操作中 重复使用 这枚鸡蛋。每次操作，你可以取一枚 没有碎 的鸡蛋并把它从任一楼层。，以此类推，因此只需要判断最后的层数是否超过建筑高即可。楼层或比它低 的楼层落下的鸡蛋都 不会碎。函数传入操作次数k，可以发现，最优情况一定先在。确切的值 的 最小操作次数 是多少？的楼层落下的鸡蛋都 会碎 ，从。枚相同 的鸡蛋，和一栋从第。请你计算并返回要确定。
c语言练习题2(字符串和函数的使用)
m0_74859128的博客
10-10 345
回文函数用于判断一个给定的字符串是否为回文。输入是一个字符数组（字符串），输出是一个布尔值，表示该字符串是否为回文。编写一个 C 语言程序，计算两个整数在二进制表示中有多少位不同。2. 比较这两个整数在二进制表示中的每一位（共32位）是否不同。1. 提示用户输入两个整数。3. 统计不同的位的数量。4. 输出不同的位数。
C#排序算法实现：冒泡排序与选择排序
"C#排序算法大全，包括冒泡排序和选择排序的实现代码" 在编程领域，排序算法是数据处理的基础，它对于理解和优化程序性能至关重要。C#作为一款广泛使用的面向对象编程语言，提供了丰富的工具和库来实现各种排序算法...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值