冒泡排序法,二分法,拉格朗日法,快速排序法

最新推荐文章于 2022-12-23 21:26:04 发布
最新推荐文章于 2022-12-23 21:26:04 发布
阅读量445 收藏
点赞数
分类专栏： unity笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/luxifa1/article/details/83505417
版权

十大排序法

冒泡排序法

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;


namespace ConsoleApplication1
{
    class Program
    {
        static void Main()
        {


            Sort(7, 3, 8, 2,9,1);
        }
        //params 是C#的关键字， params主要是在声明方法时参数类型或者个数不确定时使用
        private static void Sort(params int[] array)
        {
            int temp = 0;//定义一个中间变量
            for (int i = 0; i < array.Length - 1; i++)//保证每个元素遍历
            {
                for (int j = 0; j < array.Length - 1 - i; j++)//把最大的数换至最后一位并减去这一位的索引
                {
                    if (array[j] > array[j + 1])//若前一位大于后一位
                    {
                        temp = array[j];//前一位赋值给中间变量
                        array[j] = array[j + 1];//后一位赋值给前一位
                        array[j + 1] = temp;//前一位的值赋给后一位,即交换位置
                    }
                }
            }
            foreach (int elements in array)
            {
                Console.WriteLine(elements);
            }
            Console.ReadKey();

        }
    }
}

二分法排序

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace 二分法
{
    class Program
    {
        static void Main(string[] args)
        {

            int[] a = { 1, 6, 4, 3, 8, 5, 21, 9, 31, 81, 101, 55, 62, 151, 7, 2, 10 };

            DichotomySort(a);

            for (int i = 0; i < a.Length; i++)
            {
                Console.WriteLine(a[i]);
            }

            Console.Read();
        }

        public static void DichotomySort(int[] array)
        {
            for (int i = 0; i < array.Length; i++)
            {
                int start = 0;

                int end = i - 1;

                int middle = 0;

                int temp = array[i];

                while (start <= end)
                {
                    middle = (start + end) / 2;

                    if (array[middle] > temp)//要排序元素在已经排过序的数组左边
                    {
                        end = middle - 1;
                    }
                    else
                    {
                        start = middle + 1;
                    }
                }
                for (int j = i - 1; j > end; j--)//找到了要插入的位置，然后将这个位置以后的所有元素向后移动
                {
                    array[j + 1] = array[j];
                }

                array[end + 1] = temp;

            }
        }

    }
}

二分法查找

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 二分法
{
    class Program
    {
        static void Main(string[] args)
        {
            int[] arr = {1,2,3,4,5,6,7,8,9,10 };//测试的数组
            int value = BinarySearCh(arr,8);//调用方法
            Console.WriteLine(value);
            Console.ReadLine();

        }
        public static int BinarySearCh(int[] arr, int value)//传入数组和需要查找的值
        {
            int fir = 0;//数组下标第一位
            int end = arr.Length - 1;//数组下标最后一位
            while (fir <= end)//下标第一位不能大于最后一位
            {
                int num = (fir + end) / 2;//最中间的索引值
                if (value == arr[num])//传入的值是否跟最中间的相等,相等就返回这个最中间索引值
                {
                    return num;
                }
                else if (value > arr[num])//传入的值大于中间的,相当于需要查找的值在比较大的那一半,所以下一次最小的索引从最中间的数加一开始再次循环
                {
                    fir = num + 1;//
                }
                else//传入的值小于中间的,相当于需要查找的值在比较小的那一半,所以下一次最大的索引从最中间的数减一开始再次循环
                {
                    end = num - 1;
                }
            }
            return -1;//如果没找到就返回-1

        }
    }
}

拉格朗日插值法

<pre name="code" class="cpp">void search2(int a[M], int num)
{
	int tou = 0;
	int wei = M - 1;
	int zhong;
	int flag = -1;//一开始找不到
	int  ci = 0;
	while (tou <= wei)
	{
		ci++;
		//zhong =tou+ ( wei-tou) / 2;
		zhong = tou + (wei - tou) *1.0*(num - a[tou]) / (a[wei] - a[tou]);
		printf("%d   %d   %d   %d\n", tou, wei, zhong, ci);
		if (num == a[zhong])
		{
			printf("一共查找%d次    找到：a[%d]=%d\n", ci, zhong, num);
			flag = 1;//找到
			break;
		}
		else if (num > a[zhong])
		{
			tou = zhong + 1;
		}
		else
		{
			wei = zhong - 1;
		}
	}
	if (-1 == flag)
	{
		printf("没有找到\n");
	}
}
//二分查找 拉格朗日插值查找
void main()
{
	int a[M];
	for (size_t i = 0; i < M; i++)
	{
		a[i] = i;
		printf("%d    ", i);
	}
	printf("\n请输入要查找的数据：");
	int num;
	scanf("%d", &num);
	search2(a, num);
	system("pause");
}

快速排序法

static void Main(string[] args)
 {
     Console.WriteLine("请输入待排序数列(以\",\"分割):");
     string _s = Console.ReadLine();
     string[] _sArray = _s.Split(",".ToCharArray());
     int _nLength = _sArray.Length;
     int[] _nArray = new int[_nLength];
     for (int i = 0; i < _nLength; i++)
     {
         _nArray[i] = Convert.ToInt32(_sArray[i]);
     }
 
     var list = _nArray.ToList();
     QuickSort(list, 0, _nLength - 1);
 
     foreach (var i in list)
     {
          Console.WriteLine(i.ToString());
     }
     while (true)
     {
         Thread.Sleep(10000);
     }
}
 //获取按枢轴值左右分流后枢轴的位置
 private static int Division(List<int> list, int left, int right)
 {
     while (left < right)
     {
         int num = list[left]; //将首元素作为枢轴
         if (num > list[left + 1])
         {
             list[left] = list[left + 1];
             list[left + 1] = num;
             left++;
         }
         else
         {
             int temp = list[right];
             list[right] = list[left + 1];
             list[left + 1] = temp;
             right--;
         }
         Console.WriteLine(string.Join(",", list));
     }
     Console.WriteLine("--------------\n");
     return left; //指向的此时枢轴的位置
 }
 private static void QuickSort(List<int> list, int left, int right)
 {
     if (left < right)
     {
         int i = Division(list, left, right);
         //对枢轴的左边部分进行排序
         QuickSort(list, i + 1, right);
         //对枢轴的右边部分进行排序
         QuickSort(list, left, i - 1);
     }
 }   

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;


namespace 排序法
{
    class Program
    {
        static void Main(string[] args)
        {
            int[] arr = {5,8,3,6,7,4,9,1,2 }; //待排序数组
            QuickSort(arr, 0, arr.Length - 1);  //调用快速排序函数。传值(要排序数组，基准值位置，数组长度)


            //控制台遍历输出
            Console.WriteLine("排序后的数列：");
            foreach (int item in arr)
                Console.WriteLine(item);
            Console.ReadLine();


        }


        private static void QuickSort(int[] arr, int begin, int end)
        {
            if (begin >= end) return;   //两个指针重合就返回，结束调用
            int pivotIndex = QuickSort_Once(arr, begin, end);  //会得到一个基准值下标


            QuickSort(arr, begin, pivotIndex - 1);  //对基准的左端进行排序  递归
            QuickSort(arr, pivotIndex + 1, end);   //对基准的右端进行排序  递归
        }


        private static int QuickSort_Once(int[] arr, int begin, int end)
        {
            int pivot = arr[begin];   //将首元素作为基准
            int i = begin;
            int j = end;
            while (i < j)
            {
                //从右到左，寻找第一个小于基准pivot的元素
                while (arr[j] >= pivot && i < j) j--; //指针向前移
                arr[i] = arr[j];  //执行到此，j已指向从右端起第一个小于基准pivot的元素，执行替换


                //从左到右，寻找首个大于基准pivot的元素
                while (arr[i] <= pivot && i < j) i++; //指针向后移
                arr[j] = arr[i];  //执行到此,i已指向从左端起首个大于基准pivot的元素，执行替换
            }


            //退出while循环,执行至此，必定是 i= j的情况（最后两个指针会碰头）
            //i(或j)所指向的既是基准位置，定位该趟的基准并将该基准位置返回
            arr[i] = pivot;
            return i;
        }


    }
}

快排

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 快速排序
{
    class Program
    {
        static void Main(string[] args)
        {
            int[] arr = { 5, 8, 3, 6, 7, 4, 9, 1, 2 }; //待排序数组
            quickSort(arr, 0, arr.Length - 1);
            Console.WriteLine("排序后的数列：");
            foreach (int item in arr)
            {
                Console.WriteLine(item);
            }
            Console.ReadLine();
        }
        //快速排序算法,将数据分成两列
        private static void quickSort(int[] array, int low, int high)
        {
            if (low > high)
            {   //递归推出条件，非常重要
                return;
            }
            int first, last, key;
            first = low;
            last = high;
            key = array[first];
            while (first < last)
            {
                while (first < last && array[last] >= key)  //>=表明升序
                {
                    --last;
                }
                array[first] = array[last];
                while (first < last && array[first] <= key)
                {
                    ++first;
                }
                array[last] = array[first];
            }
            array[first] = key;
            quickSort(array, low, first - 1);
            quickSort(array, first + 1, high);
        }

    }
}

冒泡优化,判断是否是最优顺序

static void Sort(int[] array)
        {
            int tmp = 0;
            //记录最后一次交换的位置
            int lastExchangeIndex = 0;
            //无序数列的边界，每次比较只需要比到这里为止
            int sortBorder = array.Length - 1;
            for (int i = 0; i < array.Length; i++)
            {
                //有序标记,每一轮的初始值为true
                bool isStop = true;
                for (int j = 0; j < sortBorder; j++)
                {
                    if (array[j]>array[j+1])
                    {
                        tmp = array[j];
                        array[j] = array[j + 1];
                        array[j + 1] = tmp;
                        //有元素交换，所以不是有序，标记变为false
                        isStop= false;
                        //把无序数列的边界更新为最后一次交换元素的位置
                        lastExchangeIndex = j;                   
                    }
                }
                sortBorder = lastExchangeIndex;
                if(isStop)
                {
                    break;
                }
            }
        }```
璐希法
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构之二分法以及八大排序算法的理解与代码实现（Java）
yyf4321的博客
10-28 2029
二分法 顾明思意，二分法就是将我们的数组一分为二，然后拿我们要查找的数去和中间的那个元素比较，如果刚好等于中间那个元素，那么就返回中间位置的下标。如果比中间的元素小，那么再使用相同的方式从中间元素的前面部分去找；相反如果比中间元素更大，那么就在中间元素后面的部分去找。如此循环，这样就叫二分法，相信大家都意识到了，二分法之所以能这样做的前提是：数组已经是有序的（通常情况下是升序）。下面看一下二分法的具体实现： ![在这里插入图片描述](https://img-blog.csdnimg.cn/2
算法介绍--- 二分法,冒泡排序,快排
Yietong的博客
07-06 873
二分法是一种在有序数组中查找某一特定元素的搜索算法. 代码实现: 介绍冒泡排序，又称起泡排序。他是一种基于交换的排序典型，也是快排思想的基础。对于冒泡排序名字的由来，百度百科这么说：冒泡排序的基本思想为:从前往后把大元素往后调.分析具体思想为(把大元素往后调)：拿个例子来说，比如这个序列的冒泡排序来说。会有多趟(7)排序，每一趟要执行多(8-k)次。 对于它的第一趟排序来说是这样的： 多次排序后结果为:代码在具体实现的时候，要分清是从小到大还是从大到小，还有次数也要注意，谨防越界！ 至于冒泡排序的
排序算法之 二分法排序
热门推荐
love_gzd的博客
08-08 2万+
之所以单独来二分法排序，是因为近些天一直在做二分法查找的问题，延伸只二分法排序，做此记录，以便于以后记忆。 首先了解下二分法的思想：对于区间[a，b]上连续不断且f（a）·f（b）&lt;0的函数y=f（x），通过不断地把函数f（x）的零点所在的区间一分为二，使区间的两个端点逐步逼近零点，进而得到零点近似值的方法叫二分法。 个人理解二分法排序就是利用二分法查找结合插入...
二分查找和快速排序
asdbkaj的博客
10-10 4825
一、二分查找 二分查找的基本思想： ​ 二分查找就是给定一个已经排序好的数组，输入你想查找的数值，然后对数组进行折半查找，找到直接返回在数组中的位置，否则返回-1。它充分利用了元素间的次序关系，采用分治策略，可在最坏的情况下用O(log n)完成搜索任务。 具体实现： 1、binarySearch函数传入已经排序好的数组(nums[])，你想查找的目标数值(target),数组的长度(length) 2、binarySearch中先设置数组的左右边界left、right，然后求解数组的中间位置m
Java进阶——数组中常见的算法
LiLi的博客
11-17 232
排序算法： 冒泡排序算法 选择排序算法 查找算法： 二分法查找 以上算法在以后的java实际开发中我们不需要使用的。 因为java已经封装好了，直接调用就行 只不过以后面试的时候，可能会有机会碰上 算法实际上在java中不需要精通，因为java中已经封装好了，要排序就调用方法就行。例如：java中提供了一个数组工具类： java.util.Arrays Arrays是一个工具类。其中有一个sort()方法，可以排序。静态方法，直接使用类名调用就行。 冒泡排序 参与比较的数据：9 8 10 7 6 0
冒泡排序以及二分法查询
11-09
冒泡排序以及二分法查询冒泡排序以及二分法查询冒泡排序以及二分法查询冒泡排序以及二分法查询冒泡排序以及二分法查询
21天学会Java之(Java SE第八篇):数组、冒泡排序法、二分法查找
01-20
数组 数组的定义 数组是相同类型数据的有序集合，数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成。其中，每一个数据称作一个元素，每个元素可以通过一个索引(下标)来访问它们。...
冒泡排序法
10-23
关于排序的问题，冒牌排序、二分法、以及许多。此处为最基本的冒泡排序
diedaifa.rar_二分法_牛顿下山法
07-14
牛顿下山法和二分法程序，用来求解方程的解
二分法_ideazzf_二分法_弦截法_
09-30
计算方法，二分法，弦截法应用。对于区间[a，b]上连续不断且f（a）·f（b）<0的函数y=f（x），通过不断地把函数f（x）的零点所在的区间一分为二，使区间的两个端点逐步逼近零点，进而得到零点近似值的方法。
冒泡排序、快速排序和二分法查找的分析 Java
08-30
冒泡排序、快速排序和二分法查找的分析 Java
unity 使用快速排序、二分法查找
wakakakakakakak的博客
10-17 356
using UnityEngine; namespace QuickSort { public class TestQuickSort : MonoBehaviour { private void Awake() { int[] testArray =new int[100] ; for (int i = 0; i < testArray.Length; i++) {
面向对象——二分法、冒泡排序
weixin_51589875的博客
12-23 276
将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能方法操作该数据常用的操作之一：用于基本数据类型与字符串之间的转换；2、Integer类的概述和使用方法名说明valueOf​(inti)返回表示指定的int值的Integer实例valueOf返回一个保存指定值的Integer对象StringstaticintparseInt(String s)将字符串类型的整数变成int类型的整数。
递归二分法排序---数组
Zleah__的博客
04-17 443
题目 递归二分法给数组按照从小到大进行排序 思路 1. 准备一个函数, 接收一个数组 2. 准备递归 3. 先找停的条件: 只要数组的length < =1, 就停下来, 直接返回原数组 4. 停以外的行为: ***找到一个(数组长度/2)一般取整, 为数组中间数的索引 ***从数组里面把这个中间索引的数据拆出来, 用splice ***准备两个新数组, 一个表示左边, 一个表示右边 ***循环遍历被拆除一个数字的数组 ***判断大小, 让每个数字选择一个数组(左或右)放进去 代码如下（示例）：
算法基础（二分、选排、快排） -- PHP详解篇
MClink的博客
02-29 658
本篇文章你能学到什么： 1.二分查找法的原理及 PHP 实现 2.选择排序的原理及 PHP 实现 3.快速排序的原理及 PHP 实现 4.三种算法的时间复杂度分析及比较 5.剖析 大 O 表示法 前言：聊聊为什么要学算法，我相信大多数人工作是很少用的到算法的，如果我问你为什么要学算法，普遍的回答一般说是为了面试，没错，很现实，但是其实算法不但但只是为了面试过关，同时也是可以增强思维...
数组中的二分法和快速排序
weixin_43885459的博客
04-07 1412
二分法 在数组中查找一个数，其中之一的方法是二分法 二分法：先找到这个数组中中间的数，将要查找的数与这个数做对比，如果比中间的数小，以这个数为分界，找到这个数左边中间的数；如果比中间的数大，以这个数为分界，找到这个数右边中间的数。。。以此类推，直到找到这个数为止。 代码如下（递归） var text = parseInt(prompt('请输入您要查找的数')); var arr = [1...
冒泡，二分法插入，快速排序算法
weixin_34227447的博客
05-25 137
1.冒泡排序算法 过程： 1.遍历整个数组，每两两相邻的元素进行比较，如$a[$i]>$a[$i+1]则互换位置，每次比较消除一个逆序。 2.每一次循环后，下次再需要循环的次数减少1。 <?php // 冒泡排序 $arr = createarr(20); printarr($arr); popsort($arr); printarr($arr); function ...
js冒泡排序及二分法查找
Curtain的博客
12-01 7302
JavaScript冒泡排序： var arr = [5,0,-56,90,12]; var flag = false;//标志位进行优化，数组本来就是有序序列的话，无需再排序 //先进行大的排序 for(var i=0;i<arr.length-1;i++){ //小的排序 for(var j=0;j<arr.
二分法，快速排序
taienbug的博客
04-27 1131
第一次写博客，很简单，二分法的快速排序，复杂度为nlogn，是最基础的二分，代码如下：ps：顺序很重要，必须先右后左。#include&lt;stdio.h&gt;int a[1001],n;void quicksort(int left,int right){ int temp,i,j,t; if(left&gt;right) return; temp=a[left]; i=left; j=ri...
js 二分法冒泡排序
最新发布
09-14
二分法和冒泡排序是两种不同的排序算法，它们的实现和原理也有所不同。 对于二分法查找，它是一种在有序数组中查找目标元素的算法。它的基本思想是将待查找的数组分成两部分，然后通过比较目标元素与数组中间元素的大小关系，确定目标元素在哪个部分中，然后再在相应的部分中继续进行二分查找，直到找到目标元素或者确定目标元素不在数组中为止。在给定的代码中，二分法查找并未实现，只有排序部分的冒泡排序算法。 冒泡排序是一种简单但效率较低的排序算法。它的基本思想是从数组的第一个元素开始，依次比较相邻两个元素的大小关系，并根据需要交换它们的位置，使得较大的元素逐渐向数组的后部移动。在每一轮的比较过程中，最大的元素会被交换到数组的最后位置，然后再对剩余的元素进行相同的比较交换操作，直到数组完全有序为止。给定的代码中实现了冒泡排序算法，并将排序后的数组作为结果返回。 所以，给定的代码中实现了冒泡排序算法，而二分法查找的实现并未包含在其中。如果你想要实现二分法查找算法，你需要编写另外的代码来完成。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值