Unity基础之C#基础篇笔记7:冒泡排序,选择排序

本文详细介绍了在Unity开发中使用C#实现冒泡排序和选择排序的基础概念、原理,包括优化策略,并提供实战练习题。通过实例演示了如何对随机生成数组进行排序,适用于初学者理解这两种排序算法。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

冒泡排序

1.排序的基本概念

排序是计算机内经常进行的一种操作,其目的是将一组“无序”"的记录序列调整为“有序”"的记录序列
常用的排序例子
20 40 30 10 60 50
把上面的这个无序序列变为有序(升序或降序)序列的过程
10 20 30 40 50 60 (升序)
60 50 40 30 20 10 (降序)

在程序中序列一般存储在数组当中
所以排序往往是对数组进行排序
int[] arr = new int[] { 20,40,30,10,60,50,}:
把数组里面的内容变为有序的

2.冒泡排序的基本原理

20  40  30  10  60  50 
两两相邻,不停比较,不停交换,比较n轮

在这里插入图片描述

3.代码实现

第一步如何比较数组中两两相邻的数
20  40  30  10  60  50 
从头开始
第n个数和第n+1个数比较
            int[] arr = new int[] { 20, 40, 30, 10, 60, 50, };
            //有几个数,比较几轮
            for (int i = 0; i < arr.Length; i++)
            {
                for (int n = 0; n < arr.Length - 1; n++)
                {
                    //如果第n个数比第n+1个数大他们就要交换位置
                    if (arr[n] > arr[n + 1])
                    {
                        //交换位置
                        int temp = arr[n];
                        arr[n] = arr[n + 1];
                        arr[n + 1] = temp;

                    }
                }
            }
            for (int i = 0; i < arr.Length; i++)
            {
                Console.WriteLine(arr[i]);
            }
优化1
1.确定位置的数字不用比较了
确定了一轮后极值(最大或者最小)已经放到了对应的位置(往后放)
所以没完成n轮后面位置的数就不用再参与比较了
            int[] arr = new int[] { 20, 40, 30, 10, 60, 50, };
            //有几个数,比较几轮
            for (int i = 0; i < arr.Length; i++)
            {
                for (int n = 0; n < arr.Length - 1 - i; n++)
                {
                    //如果第n个数比第n+1个数大他们就要交换位置
                    if (arr[n] > arr[n + 1])
                    {
                        //交换位置
                        int temp = arr[n];
                        arr[n] = arr[n + 1];
                        arr[n + 1] = temp;

                    }
                }
            }
            for (int i = 0; i < arr.Length; i++)
            {
                Console.WriteLine(arr[i]);
            }
优化2
2.特殊情况优化
前几轮就排好了
            int[] arr = new int[] { 20, 40, 30, 10, 60, 50, };
            //外面申明一个标识来表示该轮是否进行了交换
            bool isSort = false;
            //有几个数,比较几轮
            for (int i = 0; i < arr.Length; i++)
            {
                isSort = false;
                for (int n = 0; n < arr.Length - 1-i; n++)
                {
                    //如果第n个数比第n+1个数大他们就要交换位置
                    if (arr[n] > arr[n + 1])
                    {
                        isSort = true;
                        //交换位置
                        int temp = arr[n];
                        arr[n] = arr[n + 1];
                        arr[n + 1] = temp;
                    }
                }
                //当一轮结束过后如果isSort这个标识还是false
                //那就意味着已经是最终的序列了不需要再判断交换了
                if (!isSort)
                {
                    break;
                }
            }
            for (int i = 0; i < arr.Length; i++)
            {
                Console.WriteLine(arr[i]);
            }

4.练习题

练习题1

定义一个数组,长度为20,每个元素值随机0~100的数
使用冒泡排序进行升序排序并打印
使用冒泡排序进行降序排序并打印
            int[] arr = new int[20];
            Random r = new Random();
            bool isSort = false;
            for (int i = 0; i < arr.Length; i++)
            {
                arr[i] = r.Next(0, 101);
                Console.Write(arr[i] +" ");
            }

            for (int i = 0; i < arr.Length; i++)
            {
                isSort = false;
                for (int j= 0; j < arr.Length-i-1; j++)
                {
                    if(arr[j]>arr[j+1])
                    {
                        isSort = true;
                        int temp = arr[j];
                        arr[j] = arr[j + 1];
                        arr[j + 1] = temp;
                    }
                }
                if(!isSort)
                {
                    break;
                }
            }
            Console.WriteLine();
            Console.WriteLine("^^^^^^升序^^^^^^");
            for (int i = 0; i < arr.Length; i++)
            {
                Console.Write(arr[i] + " ");
            }

            for (int i = 0; i < arr.Length; i++)
            {
                isSort = false;
                for (int j = 0; j < arr.Length - i - 1; j++)
                {
                    if (arr[j] < arr[j + 1])
                    {
                        isSort = true;
                        int temp = arr[j];
                        arr[j] = arr[j + 1];
                        arr[j + 1] = temp;
                    }
                }
                if (!isSort)
                {
                    break;
                }
            }
            Console.WriteLine();
            Console.WriteLine("^^^^^^降序^^^^^^");
            for (int i = 0; i < arr.Length; i++)
            {
                Console.Write(arr[i] + " ");
            }

练习题2

写一个函数,实现一个数组的排序,并返回结果。可以根据参数决定是升序还是降序
        static int[] Sort (int[] array,bool isAscendingOrder)
        {
            bool order;
            int temp;
            bool isSort;
            for (int i = 0; i < array.Length; i++)
            {
                isSort = false;
                for (int j = 0; j < array.Length-1-i; j++)
                {
                    // 根据传入的升序降序类型决定使用什么规则然后返回给一个bool值
                    order = isAscendingOrder ? array[j] > array[j + 1] : array[j] < array[j + 1];
                    if (order)
                    {
                        isSort = true;
                        temp = array[j];
                        array[j] = array[j + 1];
                        array[j + 1] = temp;
                    }
                }
                if (!isSort)
                {
                    break;
                }
            }
            return array;
        }
        
 		static void Main(string[] args)
        {
            Console.WriteLine();
            int[] arr2 = { 3, 7, 5, 6, 9, 11, 56, 2, 3, 1, 4, 15 };
            Sort(arr2, true);
            for (int i = 0; i < arr2.Length; i++)
            {
                Console.Write(arr2[i] + " ");
            }
            Console.WriteLine();
            Sort(arr2, false);
            for (int i = 0; i < arr2.Length; i++)
            {
                Console.Write(arr2[i] + " ");
            }
            
        }


选择排序

1.选择排序的基本原理

8  7  1  5  4  2  6  3  9
新建中间商
依次比较
找出极值(最大或最小)
放入目标位置
比较n轮

2.代码实现

实现升序把大的放在最后面
  int[] arr = new int[] { 8, 7, 1, 5, 4, 2, 6, 3, 9 };

            //第五步 比较m轮
            for (int m = 0; m < arr.Length; m++)
            {
                //第一步申明一个中间商来记录索引
                //每一轮开始默认第一个都是极值
                int index = 0;
                //第2步
                //依次比较
                //-m的目的是排除上一轮已经放好位置的数
                for (int n = 1; n < arr.Length-m; n++)
                {
                    //第三步
                    //找出极值(最大值)
                    if (arr[index] < arr[n])
                    {
                        index = n;
                    }
                }
                //第四步
                //放入目标位置  length-1-轮数  
                //如果当前极值所在位置就是日标位置那就没必要交换了
                if (index != arr.Length - 1 - m)
                {
                    int temp = arr[index];
                    arr[index] = arr[arr.Length - 1 - m];
                    arr[arr.Length - 1 - m] = temp;
                }
            }

3.练习题

1.练习题1

定义一个数组,长度为20,每个元素值随机0~100的数
使用选择排序进行升序排序并打印
使用选择排序进行降序排序并打印
            int[] array = new int[20];
            Random r = new Random();
            for (int i = 0; i < array.Length; i++)
            {
                array[i] = r.Next(0, 101);
                Console.Write(array[i]+" ");
            }
            Console.WriteLine();

            for (int i = 0; i < array.Length; i++)
            {
                int index = 0;
                for (int j = 1; j < array.Length  - i; j++)
                {
                    if (array[index]<array[j])
                    {
                        index = j;
                    }
                }
                if (index != array.Length - 1 - i)
                {
                    int temp = array[index];
                    array[index] = array[array.Length - 1 - i];
                    array[array.Length - 1 - i] = temp;
                }
            }
            Console.WriteLine("^^^^升序^^^^^^");
            for (int i = 0; i < array.Length; i++)
            {
                Console.Write(array[i] + " ");
            }

            for (int i = 0; i < array.Length; i++)
            {
                int index = 0;
                for (int j = 1; j < array.Length - i; j++)
                {
                    if (array[index] > array[j])
                    {
                        index = j;
                    }
                }
                if (index != array.Length - 1 - i)
                {
                    int temp = array[index];
                    array[index] = array[array.Length - 1 - i];
                    array[array.Length - 1 - i] = temp;
                }
            }
            Console.WriteLine();
            Console.WriteLine("^^^^降序^^^^^^");
            for (int i = 0; i < array.Length; i++)
            {
                Console.Write(array[i] + " ");
            }
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

四月的白羊座

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值