C#基础语法——冒泡排序 选择排序 二分查找 二维数组 foreach

最新推荐文章于 2022-09-08 19:16:50 发布
最新推荐文章于 2022-09-08 19:16:50 发布
阅读量566 收藏 6
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CDSN2017/article/details/81809592
版权 
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 复习4
{
    class Program
    {
        static void Main(string[] args)
        {
            /********冒泡排序*******/
            //冒泡排序涉及到双循环，外层循环控制趟数，内层循环控制比较次数
            //冒泡排序算法的运作如下：
            //比较相邻的元素。如果第一个比第二个大，就交换他们两个。
            //对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。因此，最后的元素应该会是最大的数。
            //针对所有的元素重复以上的步骤，除了最后一个。
            //持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

            int[] num = new int[] { 1, 4, 5, 2, 3, 4, };
            for (int i = 0; i < num.Length - 1; i++)
            {
                for (int j = 0; j < num.Length - 1 - i; j++)
                {
                    if (num[j] > num[j+1])
                    {
                        int temp = num[j];
                        num[j] = num[j + 1];
                        num[j + 1] = temp;
                    }
                }
            }

            for (int i = 0; i < num.Length; i++)
            {
                Console.Write("{0}"+" ",num[i]);
            }

            Console.WriteLine();
            /********选择排序*******/

            /*
              选择排序过程：

             （1）首先通过n-1次比较，从n个数中找出最小的， 
                     将它与第一个数交换—第一趟选择排序，
                     结果最小的数被安置在第一个元素位置上

             （2）再通过n-2次比较，从剩余的n-1个数中找出关键字次小的记录,
                     将它与第二个数交换—第二趟选择排序

             （3）重复上述过程，共经过n-1趟排序后，排序结束
               */

            int[] array = new int[5] { 4, 5, 7, 3, 2 };
            int minIndex, tempo;
            for (int i = 0; i < array.Length; i++)
            {
                minIndex = i;
                for (int j = i + 1; j < array.Length; j++)
                {
                    if (array[minIndex] > array[j])
                    {
                        minIndex = j;
                    }
                    if (minIndex != i)
                    {
                        tempo = array[minIndex];
                        array[minIndex] = array[i];
                        array[i] = tempo;
                    }
                }
            }

            for (int i = 0; i < array.Length; i++)
            {
                Console.Write("{0}" + " ", array[i]);
            }

            /*
             二分查找：
             1、首先必须确保要查找的数组是有序的
             2、数组的元素个数是奇数或偶数不重要
             3、当低位小于等于高位时，才会查找，否则结束查找
             */

            //整型数组
            int[] numbers =new int[6] { 3, 6, 8, 9, 11, 17 };
            //低位下标
            int low = 0;
            //高位下标
            int high = numbers.Length - 1;
            //要查找的元素
            int key = 11;
            //开始查找
            while (true)
            {
                //取中间元素的下标
                int mid = (low + high) / 2;
                //拿中间下标所对应的元素和目标元素进行对比
                if (numbers[mid] == key)
                {
                    Console.WriteLine("找到{0}，在{1}下标处", key, mid);
                    break;
                }
                else if (numbers[mid] > key)
                {
                    high = mid - 1;
                }
                else if (numbers[mid] < key)
                {
                    low = mid + 1;
                }

                //如果低位大于高位
                if (low > high)
                {
                    Console.WriteLine("查找的{0}不存在",key);
                    break;
                }
            }

            //随机输入10个数字，用选择排序，升序一次，降序一次，然后用二分查找找到一个输入的值
            int[] member = new int[7];

            for (int i = 0; i < member.Length; i++)
            {
                member[i] = int.Parse(Console.ReadLine());
            }

            int min;

            for (int i = 0; i < member.Length; i++)
            {
                min = i;
                for (int j = i + 1; j < member.Length; j++)
                {
                    if (member[min] > member[j])
                    {
                        min = j;
                    }
                    if (min != i)
                    {
                        int temp = member[min];
                        member[min] = member[i];
                        member[i] = temp;
                    }
                }
            }

            for (int i = 0; i < member.Length; i++)
            {
                min = i;
                for (int j = i +1; j < member.Length; j++)
                {
                    if (member[min] < member[j])
                    {
                        min = j;
                    }
                    if (min != i)
                    {
                        int temp = member[min];
                        member[min] = member[i];
                        member[i] = temp;
                    }
                }
            }

            int lowIndex = 0;

            int highIndex = member.Length - 1;

            int keyNumber = int.Parse(Console.ReadLine());
            while (true)
            {
                int mid = (lowIndex + highIndex) / 2;
                if (keyNumber == member[mid])
                {
                    Console.WriteLine("已找到KeyNumber");
                    break;
                }
                else if (keyNumber > member[mid])
                {
                    low = mid + 1;
                }
                else if (keyNumber < member[mid])
                {
                    high = mid - 1;
                }
                if (low > high)
                {
                    Console.WriteLine("KeyNumber不存在于该数组");
                    break;
                }
            }

            /********二维数组*******/
            //有两个下标的数组称之为二维数组
            //格式：
            //类型名[,] 数组名 = new [常量1, 常量2]; //常量1代表行数，常量2代表列数
            //注意：当给定行和列的值时，可以不用赋值
            //当赋值后，可以不用给行列
            //给定行列后，赋值一定要严格按照行列走
            //数组名.GetLength(0) 获取行数
            //数组名.GetLength(1) 获取列数

            //定义一个两行三列的整型二维数组
            int[,] d2array = new int[2,3];
            int[,] d3array = new int [,] { { 1, 2, 3 }, { 4, 5, 6 } };

            //二维数组的访问方式
            Console.WriteLine(d2array[1, 0]);

            //二维数组的遍历

            //遍历行
            for (int i = 0; i < d2array.GetLength(0); i++)
            {
                //遍历列
                for (int j = 0; j < d2array.GetLength(1); j++)
                {
                    Console.Write("{0}", d2array[i, j]);
                }
                Console.WriteLine();
            }

            /**********foreach**********/
            /*
            
            foreach(数组元素类型名 变量名 in 数组名)
            {
                操作语句;
            }

             */

            //快速遍历
            int[] array2 = new int[] { 1, 2, 3, 4, 5, 6 };
            foreach (int item in array2)
            {
                Console.Write("{0} ", item);
            }

            //练习：“hello lanou”里面有几个l？
            string str = "hello lanou";
            char[] chars = str.ToCharArray();//将字符串转换为字符数组ToCharArray()
            int count = 0;//定义l的个数
            foreach (char item in chars)//foreach遍历
            {
                if (item == 'l')
                {
                    count++;
                }
            }
            Console.WriteLine("一共有{0}个l", count);

            //练习：3行4列的整型数组，找出最大值，并打印行列
            int[,] array3 = new int[3, 4] { { 4, 6, 2, 7 }, { 1, 5, 2, 4 }, { 5, 6, 4, 2 } };
            int tempr = array3[0, 0];
            int Line1 = 0, Line2 = 0;
            for (int i = 0; i < array3.GetLength(0); i++)
            {
                for (int j = 0; j < array3.GetLength(1); j++)
                {
                    if (tempr < array3[i,j])
                    {
                        tempr = array3[i, j];
                        Line1 = i;
                        Line2 = j;
                    }
                }
            }
            Console.WriteLine("数组中最大值为" + temp);
            Console.WriteLine("{0},{1}", Line1, Line1);

            //练习：将3行4列的整型数组，行和列交换。并打印
            int[,] array34 = new int[3, 4] { { 1, 2, 3, 4 }, { 5, 6, 7, 8 }, { 9, 10, 11, 12 } };
            int[,] array43 = new int[4, 3];

            for (int i = 0; i < array34.GetLength(0); i++)
            {
                for (int j = 0; j < array34.GetLength(1); j++)
                {
                    array43[j, i] = array34[i, j];
                }
            }

            for (int i = 0; i < array43.GetLength(0); i++)
            {
                for (int j = 0; j < array43.GetLength(1); j++)
                {
                    Console.Write(array43[i, j]);
                }
                Console.WriteLine();
            }
        }
    }
}

 

I_Shap
关注
【C#_For循环_二重循环_数组和排序等_二分搜索_第二篇】
暴走约伯的博客
06-21 147
冒泡排序概念：通过重复遍历要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。遍历数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。冒泡排序过程：每一轮遍历都会将最大的元素“冒泡”到它应该在的位置，即数组的末尾。算法步骤从数组的第一个元素开始，比较相邻的两个元素，如果前一个比后一个大，则交换它们。对每一对相邻元素做同样的工作，从开始第一元素到倒数第二个元素。重复以上的步骤，直到最后一次交换发生在数组的最后一个元素，这时数组已经排序完成。优化。
C#实现对二维数组排序的方法
09-03
主要介绍了C#实现对二维数组排序的方法,实例分析了C#数组遍历与排序的相关技巧,需要的朋友可以参考下
二维数组如何进行冒泡排序
07-18
思路以及注意点、说明我都加在了代码旁边的注释里，好好悟悟！
c# 冒泡，插入，快速排序，和二分查找
乱世的博客
12-02 240
c# 冒泡，插入，快速排序，和二分查找 class Program { static void Main(string[] args) { int[] array = { 8, 5, 45, 56, 65, 55, 494, 5, 53, 78, 47 }; //MaoPaoSort(array); ...
C# 二维数组排序
yan_yu_lv_ji的博客
11-06 2306
//定义一个2维数组 int[][] array = { new[] { 3, 1 }, new[] { 1, 3 }, new[] { 4, 2 } }; //按数组的第2个数排序 Array.Sort(array, (a, b) => a[1].CompareTo(b[1]));
C#基础、数组、foreach、冒泡排序
qq_41261286的博客
09-09 1528
一、数组 数组是用于储存多个相同类型数据的集合 数据类型[ ] 数组名称=new 数据类型[ 数组长度]                                                 ---------------如int[ ]  a=new int[5]  默认长度==直接插入值（由初始化的值决定数组长度） 数据类型[ ] 数组名称={ 值1，值2，值3}；   ...
C#编程基础——数组与排序
qq_44959992的博客
07-21 332
数组 什么是数组？ 数组是用来将相同数据类型存储在存储单元里组成的构造类型。数组的每个成员称为一个数组元素。 一维数组定义及初始化 定义：数据类型[]数组名（int []ages） 初始化： 动态初始化： 数据类型[]数组名=new 数据类型[数组长度]; 例：int[] intArray=new int[6];【数组元素为默认值】 数据类型[]数组名=数据类型[数组长度]{元素1，元素2}； 例：int[] intArray=new int[3]{1,2,3}; 或 int[] intArray=new
冒泡排序（c#基础）
weixin_57762552的博客
06-09 1738
什么是冒泡排序 冒泡排序是将一个数组中的元素按照从大到小或者从小到大的顺序进行排列 在讲冒泡排序之前，先来复习一下什么是for循环和if判断。 for循环：这类循环可以执行指定的次数，并维护它自己的计数器。要定义for循环，需要下列信息： 例如，如果要在循环中，使计数器从1递增到10，递增量为1，则起始值为1，条件使计数器小于或等于10，在每次循环的最后，要执行的操作是给计数器加1。 这些信息必须放在for循环的结构中，如下所示：
c#产生随机数并冒泡排序
01-10
本文介绍了C#中生成随机数的方法、数组的基本操作以及冒泡排序算法的具体实现。通过这个示例程序，读者可以了解到如何在实际编程中应用这些概念。值得注意的是，虽然冒泡排序易于理解和实现，但在大数据量的情况下...
c# 如何对一个坐标数组进行冒泡排序，并输出对应最小X的Y值
最新发布
09-24
在C#中，你可以创建一个二维坐标数组，然后通过冒泡排序算法对其进行排序。这里是一个简单的步骤： 1. 定义一个名为`Coord`的结构体，表示坐标，包含X和Y两个属性： ```csharp public struct Coord { public int X...
二维排序算法 选择排序 C#二维数组实现
11-29
看了看好像没有二维的排序算法，自己感兴趣做了个。大家随便看看，提提意见~
java Eclipse 冒泡排序的编程语法
11-29
冒泡排序flash.java Eclipse 冒泡排序的编程语法
C#使用Array.Sort对二维数组排序
Morris-w的专栏
04-06 2071
二维数组需要这样定义 int[][] nums= new int[][] { new int[]{ 1, 2 }, new int[]{ 3, 4 } }; 有这几种方式，表示拿每个一维数组的第二个元素比较 Array.Sort(nums, (x, y) => x[1].CompareTo(y[1])); Array.Sort(nums, (a, b) => a[1] - b[1]); Array.Sort(nums, (a, b) => { return p1[1] - p2
冒泡排序语法树
Jesse0124的博客
11-05 146
转载于:https://www.cnblogs.com/Rick00/p/4940914.html
冒泡排序，并二分查找
jiewaikexue的博客
10-31 292
个人练习，主要是冒泡和二分查找的逻辑。比较简单，就不多写说明了 #include<stdio.h>/////冒泡排序二分查找结合！ #include<Windows.h> #include<math.h> #include<string.h> #include<time.h> #pragma warning(disable:4996) #...
C#:实现二维数组的排序算法(附完整源码)
希望我的博客，能帮上你解决学习中工作中所遇到的问题
09-08 703
C#:实现二维数组的排序算法(附完整源码)
C#学习教程：掌握循环与数组，实现冒泡排序
"本章是C#学习教程的第二章，主要目标是掌握C#中的循环语句、调试方法以及一维数组的使用，特别是通过二重循环实现冒泡排序。章节内容包括复习switch语句的正确用法，了解C#的循环结构，如do...while、while、for和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值