十归并排序有用的算法和二进制搜索的基础

归并排序

归并排序是建立在归并操作上的一种有效的排序算法。该算法是採用分治法(Divide and Conquer)的一个很典型的应用。

算法步骤:

1. 申请空间,使其大小为两个已经排序序列之和。该空间用来存放合并后的序列

2. 设定两个指针,最初位置分别为两个已经排序序列的起始位置

3. 比較两个指针所指向的元素,选择相对小的元素放入到合并空间,并移动指针到下一位置

4. 反复步骤3直到某一指针达到序列尾

5. 将还有一序列剩下的全部元素直接拷贝到合并序列尾

用分治策略解决这个问题分为三步:分解、解决、合并。

也即:将原问题划分成n个规模较小而结构与原问题相似的子问题;
递归地解决这些子问题。然后再合并其结果,得到原问题的解。此处n=2。每次都把原问题划分为两个子问题。

归并排序的伪代码(来自算法导论)

合并排序伪代码(使用哨兵):
merge(A,p,q,r)://合并算法,[p,q],[q+1,r]
    n1 <—— q-p+1
    n2 <—— r-q
    create array L[0,n1] and R[0,n2]
    for i <—— 0 to n1-1
        do L[i] <—— A[p+i]
    for j <—— 0 to n2-1
        do R[j] <—— A[q+j+1]
    L[n1] <—— +∞
    R[n2] <—— +∞
    i <—— 0
    j <—— 0
    for k i <—— p to r
        do if L[i]<=R[j]
            then A[k]  <—— L[i]
                 i <—— i+1
           else A[k] <—— R[j]
                 j <—— j+1

//通过调用merge完毕排序:
merge_sort(A,p,r):
    if p<r
       then q <—— [(p+r)/2] //向下取整
          merge_sort(A,p,q) //分治
          merge_sort(A,q+1,r)
          merge(A,p,q,r)    //合并结果

归并排序实现

#include <stdio.h>
#include <stdlib.h>
#define MAX_INT  ~(1<<31)//最大整数
//arr[p,q]  arr[q+1,r]
void merge(int *arr,int p,int q,int r)
{
    if(arr==NULL)
        return;
    int n1=q-p+1;
    int n2=r-q;
    int *L=(int*)malloc((n1+1)*sizeof(int));//申请新空间用于暂时存储元素
    int *R=(int*)malloc((n2+1)*sizeof(int));
    int i,j;//这里直接申请一个r-p+1长度的数组,在暂时数组中排序后拷贝回原数组
    for(i=0;i<n1;++i)
        L[i]=arr[p+i];
    for(j=0;j<n2;++j)
        R[j]=arr[q+j+1];
    //哨兵元素赋值
    L[n1]=MAX_INT;
    R[n2]=MAX_INT;
    int k;
    i=0,j=0;
    for(k=p;k<=r;++k){
        if(L[i]<=R[j])
            arr[k]=L[i++];
        else
            arr[k]=R[j++];
    }//最后可能有一个数组有元素剩余,这里使用一个哨兵(MAX_INT)能够在一次循环中完毕所有复制
    free(L);
    free(R);
}
void merge_sort(int *arr,int p,int r)
{
    if(p<r){
        int q=(r+p)/2;
        merge_sort(arr,p,q);//分治
        merge_sort(arr,q+1,r);
        merge(arr,p,q,r);//合并结果
    }

}
 int main()
{
    int arr[8]={32,3,4,5,6,7,9,106};
    merge_sort(arr,0,7);
    for (int i=0;i<8;i++)
    printf("%d ",arr[i]);
    system("pause");
}

二分查找算法

二分查找算法是一种在有序数组中查找某一特定元素的搜索算法。搜素过程从数组的中间元素開始,假设中间元素正好是要查找的元素。则搜素过程结束;假设某一特定元素大于或者小于中间元素,则在数组大于或小于中间元素的那一半中查找,并且跟開始一样从中间元素開始比較。假设在某一步骤数组为空,则代表找不到。

这样的搜索算法每一次比較都使搜索范围缩小一半。

折半搜索每次把搜索区域降低一半,时间复杂度为Ο(logn)

二分查找能够解决(预排序数组的查找)问题:仅仅要数组中包括T(即要查找的值),那么通过不断缩小包括T的范围,终于就能够找到它。其算法流程例如以下:

  • 1、一開始,范围覆盖整个数组。

  • 2、将数组的中间项与T进行比較,假设T比数组的中间项要小,则到数组的前半部分继续查找,反之,则到数组的后半部分继续查找。
  • 3、如此,每次查找能够排除一半元素。范围缩小一半。就这样重复比較,重复缩小范围,终于就会在数组中找到T,或者确定原以为T所在的范围实际为空。

对于包括N个元素的表,整个查找过程大约要经过log(2)N次比較。

//首先要把握以下几个要点:
//right = n-1 => while(left <= right) => right = middle-1;
//right = n   => while(left <  right) => right = middle;
//middle的计算不能写在while循环外,否则无法得到更新。

int BinarySearch(int array[], int n, int value)
{
    int left = 0;
    int right = n - 1;
    //假设这里是int right = n 的话,那么以下有两处地方须要改动,以保证一一相应:
    //1、以下循环的条件则是while(left < right)
    //2、循环内当 array[middle] > value 的时候,right = mid

    while (left <= right)  //循环条件,适时而变
    {
        int middle = left + ((right - left) >> 1);  /*防止溢出。移位也更高效。

同一时候。每次循环都须要更新。mid = left + (right-left)/2这样写能够有效避免right + left 溢出。假设写成mid = (left + right)/2可能存在溢出*/

        if (array[middle] > value)
        {
            right = middle - 1;  //right赋值,适时而变
        }
        else if(array[middle] < value)
        {
            left = middle + 1;
        }
        else
            return middle;
        //可能会有读者觉得刚開始时就要推断相等。但毕竟数组中不相等的情况很多其它
        //假设每次循环都推断一下是否相等,将耗费时间
    }
    return -1;
}

以上就是本次介绍的归并排序和二分查找。

版权声明:本文博主原创文章。博客,未经同意不得转载。

时间: 2024-10-28 20:40:45

十归并排序有用的算法和二进制搜索的基础的相关文章

十大基础实用算法之深度优先搜索和广度优先搜索

深度优先搜索算法(Depth-First-Search),是搜索算法的一种.它沿着树的深度遍历树的节点,尽可能深的搜索树的分支.当节点v的所有边都己被探寻过,搜索将回溯到发现节点v的那条边的起始节点.这一过程一直进行到已发现从源节点可达的所有节点为止.如果还存在未被发现的节点,则选择其中一个作为源节点并重复以上过程,整个进程反复进行直到所有节点都被访问为止.DFS属于盲目搜索. 深度优先搜索是图论中的经典算法,利用深度优先搜索算法可以产生目标图的相应拓扑排序表,利用拓扑排序表可以方便的解决很多相

一文搞定十大经典排序算法(Java实现)

本文总结十大经典排序算法及变形,并提供Java实现. 参考文章: 十大经典排序算法总结(Java语言实现) 快速排序算法—左右指针法,挖坑法,前后指针法,递归和非递归 快速排序及优化(三路划分等) 一.排序算法概述 1.定义 将杂乱无章的数据元素,通过一定的方法按关键字顺序排列的过程叫做排序. 2.分类 十种常见排序算法可以分为两大类: 非线性时间比较类排序:通过比较来决定元素间的相对次序,由于其时间复杂度不能突破O(nlogn),因此称为非线性时间比较类排序. 线性时间非比较类排序:不通过比较

浅谈算法和数据结构: 十二 无向图相关算法基础

从这篇文章开始介绍图相关的算法,这也是Algorithms在线课程第二部分的第一次课程笔记. 图的应用很广泛,也有很多非常有用的算法,当然也有很多待解决的问题,根据性质,图可以分为无向图和有向图.本文先介绍无向图,后文再介绍有向图. 之所以要研究图,是因为图在生活中应用比较广泛: 无向图 图是若干个顶点(Vertices)和边(Edges)相互连接组成的.边仅由两个顶点连接,并且没有方向的图称为无向图. 在研究图之前,有一些定义需要明确,下图中表示了图的一些基本属性的含义,这里就不多说明. 图的

数据结构与算法 - 排序与搜索

排序与搜索 排序算法(英语:Sorting algorithm)是一种能将一串数据依照特定顺序进行排列的一种算法. 1.冒泡排序 冒泡排序(英语:Bubble Sort)是一种简单的排序算法.它重复地遍历要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来.遍历数列的工作是重复地进行直到没有再需要交换,也就是说该数列已经排序完成.这个算法的名字由来是因为越小的元素会经由交换慢慢"浮"到数列的顶端. 冒泡排序算法的运作如下: 比较相邻的元素.如果第一个比第二个大(升序),就

数据结构(十二)——排序算法

数据结构(十二)--排序算法 一.排序简介 1.排序的一般定义 排序是计算机中经常进行的操作,目的在于将一组无序的数据元素调整为有序的数据元素.序列:1,20,45,5,2,12排序后:1,2,5,12,20,45 2.排序的数学定义 3.排序的稳定性 如果序列中的两个元素R[i].R[j],关键字分别为K[i].K[j],并且在排序之前R[i]排在R[j]前面,如果排序操作后,元素R[i]仍然排在R[j]前面,则排序方法是稳定的:否则排序是不稳定的. 4.排序实现的关键 比较:任意两个数据元素

十大经典排序算法(python实现)(原创)

经典排序算法图解: 经典排序算法的复杂度: 大类一(比较排序法): 1.冒泡排序(Bubble Sort) python代码实现: 1 d0 = [2, 15, 5, 9, 7, 6, 4, 12, 5, 4, 2, 64, 5, 6, 4, 2, 3, 54, 45, 4, 44] 2 d0_out = [2, 2, 2, 3, 4, 4, 4, 4, 5, 5, 5, 6, 6, 7, 9, 12, 15, 44, 45, 54, 64] # 正确排序 3 4 while 1: 5 stat

【转】十大经典排序算法

[转]十大经典排序算法:https://www.cnblogs.com/onepixel/articles/7674659.html 0.算法概述 0.1 算法分类 十种常见排序算法可以分为两大类: 比较类排序:通过比较来决定元素间的相对次序,由于其时间复杂度不能突破O(nlogn),因此也称为非线性时间比较类排序. 非比较类排序:不通过比较来决定元素间的相对次序,它可以突破基于比较排序的时间下界,以线性时间运行,因此也称为线性时间非比较类排序. 0.2 算法复杂度 0.3 相关概念 稳定:如果

python 十大经典排序算法

python 十大经典排序算法 排序算法可以分为内部排序和外部排序,内部排序是数据记录在内存中进行排序,而外部排序是因排序的数据很大,一次不能容纳全部的排序记录,在排序过程中需要访问外存.常见的内部排序算法有:插入排序.希尔排序.选择排序.冒泡排序.归并排序.快速排序.堆排序.基数排序等.用一张图概括: 关于时间复杂度: 平方阶 (O(n2)) 排序 各类简单排序:直接插入.直接选择和冒泡排序. 线性对数阶 (O(nlog2n)) 排序 快速排序.堆排序和归并排序. O(n1+§)) 排序,§

44. 蛤蟆的数据结构笔记之四十四弗洛伊德Floyd算法

44. 蛤蟆的数据结构笔记之四十四弗洛伊德Floyd算法 本篇名言:"希望是厄运的忠实的姐妹. --普希金" 我们继续来看下数据结构图中的一个算法,这个算法来自图灵奖得主. 1.  Floyd算法介绍 Floyd算法又称为插点法,是一种用于寻找给定的加权图中多源点之间最短路径的算法.该算法名称以创始人之一.1978年图灵奖获得者.斯坦福大学计算机科学系教授罗伯特·弗洛伊德命名.注意这个可不是心理学的那个弗洛伊德. 是解决任意两点间的最短路径的一种算法,可以正确处理有向图或负权的最短路径