精华内容
下载资源
问答
  • 归并排序 快速排序 数组的查找 线性查找 二分查找 数据结构 数据结构定义 数据结构指所有数据元素以及数据元素之间的关系,可以看作是相互之间存在着某种特定关系的数据元素的集合。简单来说,决定着数据存储...

    目录

    数据结构

    数据结构定义

    数据结构类型

    链表

    数组

    队列

    哈希表

    二叉查找树

    排序

    排序定义

    排序种类

    冒泡排序

    选择排序

    插入排序

    堆排序

    归并排序

    快速排序

    数组的查找

    线性查找

    二分查找


    数据结构

    数据结构定义

            数据结构指所有数据元素以及数据元素之间的关系,可以看作是相互之间存在着某种特定关系的数据元素的集合。简单来说,决定着数据存储在内存中时数据顺序和位置关系的便是“数据结构”。

            例如:内存中存放数据1、数据2、数据3,顺序排列有3!=6种排序方式,决定着哪种排序方式的就是“数据结构”

     

    数据结构类型

    链表

            链表的大类属于线性表,线性表是具有相同特性的数据元素的一个有限序列。线性表的顺序存储结构成为顺序表,链式存储结构称为链表。由于顺序表概念简单且利用率低,此处仅讨论链表。

            链表中逻辑上相邻的元素对应的存储位置通过指针来链接

            链表种类:单链表、双链表、循环链表

            链表特点:可以实现空间动态管理,数据呈线性排列,分散存储与内存中。

            优点:数据添加、删除较快

            缺点:访问较慢

    数组

            数组是具有相同类型数据元素的有限序列

            特点:数据呈线性排列存储在内存的连续空间内

            优点:访问较快

            缺点:添加、删除数据较慢

            栈是一种只能在一端进行插入或删除操作的线性表

            特点:“后进先出”

    队列

            队列简称队,是一种只能在表的一端进行插入、在表的另一端进行删除的线性表

            特点:“先进先出”

    哈希表

            哈希表利用哈希函数快速访问到数组中的目标数据

    (此处省略哈希函数的计算方法和哈希冲突解决方法,详后对哈希函数单独解) 

            特点:线性存储

            堆是一种图的树形结构,被用于实现“优先队列”(优先队列可以自由添加数据,但要求取出数据时从最小值按序取出)分为最大堆和最小堆,区别是节点排序方式不同

            最小堆规则:每个结点最多两个子结点,存储数据时子结点必定大于父结点(故最小值被存储在顶端的根节点中),结点排列顺序为从上到下,同一行从左到右。添加新数据时,新数据被放在最下面一行靠左的位置,最下面一行没有多余空间时再往下另起一行,数据加在该行的最左端,再一边比较它与父结点数据大小,一边往上移动。取出数据时将最后的数据移动到最顶端,一边比较它与子结点数据的大小,一边往下移动。

            最大堆同理

    二叉查找树

            二叉查找树采用了图的树形结构,数据存储于二叉查找树的各个结点中

            规则:每个结点最多有两个子结点,每个结点的值均大于其左子树上任意一个结点的值、小于其右子树上任意一个结点的值

            查找结点:查找最小结点从顶端开始,往左下末端查找;查找最大节点从顶端开始,往右下末端寻找

            添加结点:从顶端开始比较,小于则左移,大于则右移

            删除结点:若所需删除结点无子结点,则直接删除该结点;若有所需删除结点只有一个子结点,先删除目标结点,再移位子结点;若所需删除结点有两个子结点,先删除目标结点,在被删除结点左子树中寻找最大结点移到被删除结点位置上,若需要移动的点还有子结点,递归执行前面操作。

    排序

    排序定义

            排序:按照递增或递减关系有序整理表中的元素

    排序种类

    冒泡排序

            冒泡排序:通俗来讲就是重复从序列右边开始比较相邻两数字大小,根据结果交换两数字位置这个操作

            特点:交换数字的次数和输入数据的排列数序有关

    选择排序

            选择排序:通俗来讲就是重复从数据中寻找最小值与序列最左边数字进行交换这个操作

            特点:使用线性查找寻找最小值

    插入排序

            插入排序:从序列左端开始依次对数据进行排序

    堆排序

            堆排序:在堆中存储所有的数据,按降序来构建堆

            特点:从降序排列的堆中取出数据会从最大的数据开始取,故将取出得数据反序输出则排序完成

    归并排序

            归并序列:将序列分成长度相同的两个子序列,无法继续下分时,对子序列进行归并,合并时顺序排列

    快速排序

            快速排序:在序列中随机选择一个基准值,将除了基准值以外的数分为“比基准值小的数”和“比基准值大的数”两个类别,即[比基准值小的数]基准值[比基准值大的数],再使用快速排序对“[]”中的数据进行排序

    数组的查找

    线性查找

            线性查找:从头开始不断按照顺序查找数据

    二分查找

            与线性查找不同,二分查找只能查找已经排好序的数据,每一次查找都可以将查找范围减半

    展开全文
  • 归并排序算法一、归并排序的概念二、原地归并的抽象方法(一)、原地归并的抽象方法的概念(二)、原地归并的抽象方法的代码示例三、自顶向下的归并排序(一)、自顶向下的归并排序的概念(二)、自顶向下的归并排序...

    一、归并排序的概念

    ​ 归并:即将两个有序的数组归并成一个更大的有序数组。根据归并这一操作,得出一种简单的递归排序算法:归并排序。要将一个数组排序,可以先(递归地)将它分为两半分别排序,然后将结果归并起来。

    ​ 归并排序的一个重要性质:它能够保证将任意长度为N的数组排序所需时间和NlogN成正比。它的主要缺点则是:它所需的额外空间和N成正比。

    二、原地归并的抽象方法

    (一)、原地归并的抽象方法的概念

    ​ 实现归并的一种直截了当的办法是将两个不同的有序数组归并到第三个数组中,两个数组中的元素应该都实现了Comparable接口。实现的方法很简单,创建一个适当大小的数组然后将两个输入数组的元素一个个从小到大放入这个数组中。

    ​ 但是,当用归并将要给大数组排序时,需要进行很多次归并,因此在每次归并时都创建一个新数组来存储排序结果会带来问题。

    ​ 因此,假如有一种原地归并的方法,就可以先将前半部分排序,然后将后半部分排序,然后再数组中移动元素而不需要额外的空间。但实际上已有的实现都非常复杂,尤其是和使用额外空间的方法相比。

    ​ 但将原地归并并抽象化仍然是有帮助的,与之对应的是我们的方法merge(a,lo,mid,hi),它将子数组a[lo…mid]和a[mid+1…hi]归并成一个有序的数组并将结果存放在a[lo…hi]中。

    (二)、原地归并的抽象方法的代码示例

    ​ 该方法先将所有元素复制到aux[]中,然后再归并回arr[]中。

    ​ 在第二个for循环(归并)时进行了4个条件判断:左半边用尽(取右半边的元素)、右半边用尽(取左半边的元素)、右半边的当前元素小于左半边的当前元素(取右半边的元素)以及右半边的当前元素大于等于左半边的当前元素(取左半边的元素)。

        public static void merge(Comparable[] arr, int lo, int mid, int hi) {
            // 将arr[lo...mid]和a[mid+1...hi]归并
            int i = lo;
            int j = mid + 1;
            Comparable[] aux = new Comparable[arr.length];
            for (int k = lo; k <= hi; k++) {
                aux[k] = arr[k];
            }
            for (int k = lo; k <= hi; k++) {
                if (i > mid) {
                    arr[k] = aux[j++];
                } else if (j > hi) {
                    arr[k] = aux[i++];
                } else if (less(aux[j], aux[i])) {
                    arr[k] = aux[j++];
                } else {
                    arr[k] = aux[i++];
                }
            }
        }
    
        // 对元素进行比较
        private static boolean less(Comparable v, Comparable w) {
            // 返回-1/0/1:表示v小于/等于/大于w
            return v.compareTo(w) < 0;
        }
    

    三、自顶向下的归并排序

    (一)、自顶向下的归并排序的概念

    ​ 自顶向下的归并排序是基于原地归并的抽象实现了另一种递归归并。

    ​ 这段递归代码是归纳证明算法能够正确地将数组排序的基础:如果它能将两个子数组排序,它就能够通过归并两个子数组来将整个数组排序。

    (二)、自顶向下的归并排序的代码示例

    public class Merge {
    
        // 归并所需的辅助数组
        private static Comparable[] aux;
    
        public static void sort(Comparable[] arr) {
            aux = new Comparable[arr.length];
            sort(arr, 0, arr.length - 1);
        }
    
        private static void sort(Comparable[] arr, int lo, int hi) {
            if (hi <= lo) {
                return;
            }
            int mid = lo + (hi - lo) / 2;
            sort(arr, lo, mid);
            sort(arr, mid + 1, hi);
            merge(arr, lo, mid, hi);
        }
    
        public static void merge(Comparable[] arr, int lo, int mid, int hi) {
            // 将arr[lo...mid]和a[mid+1...hi]归并
            int i = lo;
            int j = mid + 1;
            for (int k = lo; k <= hi; k++) {
                aux[k] = arr[k];
            }
            for (int k = lo; k <= hi; k++) {
                if (i > mid) {
                    arr[k] = aux[j++];
                } else if (j > hi) {
                    arr[k] = aux[i++];
                } else if (less(aux[j], aux[i])) {
                    arr[k] = aux[j++];
                } else {
                    arr[k] = aux[i++];
                }
            }
        }
    
        // 对元素进行比较
        private static boolean less(Comparable v, Comparable w) {
            // 返回-1/0/1:表示v小于/等于/大于w
            return v.compareTo(w) < 0;
        }
    }
    

    (三)、自顶向下的归并排序的基本性质

    ​ 1、对于长度为N的任意数组,自顶向下的归并排序需要1/2NlgN——NlgN次比较。

    ​ 2、对于长度为N的任意数组,自顶向下的归并排序最多需要访问数组6NlgN次。

    ​ 以上两个性质说明了归并排序所需的实际和NlgN成正比,它表明我们只需要比遍历整个数组多个对数因子的时间就能将一个庞大的数组排序。可以用归并排序处理数百万甚至更大规模的数组,这是插入排序或选择排序做不到的。

    ​ 归并排序的主要缺点是辅助数组所使用的额外空间和N的大小成正比。

    四、自底向上的归并排序

    (一)、自底向上的归并排序的概念

    ​ 递归实现的归并排序是算法设计中分治思想的典型应用。我们将一个大问题分割成小问题分别解决,然后用所有小问题的答案来解决大问题。尽管我们考虑的问题是归并两个大数组,实际上我们归并的数组大多数都非常小。

    ​ 实现归并排序的另一种方法是先归并那些微型数组,然后再成对归并得到的子数组,如此这般,直到我们将整个数组归并在一起。这种实现方法比标准递归方法所需要的代码量更少。

    (二)、自底向上的归并排序的代码示例

    public class MergeBU {
    
        // 归并所需的辅助数组
        private static Comparable[] aux;
    
        public static void sort(Comparable[] arr) {
            // 进行lgN次两两归并
            int n = arr.length;
            aux = new Comparable[n];
            // sz:子数组大小
            for (int sz = 1; sz < n; sz = sz + sz) {
                // lo:子数组索引
                for (int lo = 0; lo < n - sz; lo += sz + sz) {
                    merge(arr, lo, lo + sz - 1, Math.min(lo + sz + sz - 1, n - 1));
                }
            }
        }
    
        private static void merge(Comparable[] arr, int lo, int mid, int hi) {
            // 将arr[lo...mid]和a[mid+1...hi]归并
            int i = lo;
            int j = mid + 1;
            for (int k = lo; k <= hi; k++) {
                aux[k] = arr[k];
            }
            for (int k = lo; k <= hi; k++) {
                if (i > mid) {
                    arr[k] = aux[j++];
                } else if (j > hi) {
                    arr[k] = aux[i++];
                } else if (less(aux[j], aux[i])) {
                    arr[k] = aux[j++];
                } else {
                    arr[k] = aux[i++];
                }
            }
        }
    
        // 对元素进行比较
        private static boolean less(Comparable v, Comparable w) {
            // 返回-1/0/1:表示v小于/等于/大于w
            return v.compareTo(w) < 0;
        }
    }
    

    (三)、自底向上的归并排序的基本性质

    ​ 1、对于长度为N 的任意数组,自底向上的归并排序需要1/2NlgN至NlgN次比较,最多访问数组6NlgN次。

    ​ 当数组长度为2的幂时,自顶向下喝自底向上的归并排序所用的比较次数喝数组访问次数正好相同,只是顺序不同。其他时候,两种方法的比较和数组访问的次序会有所不同。

    ​ 自底向上的归并排序比较使用用链表组织的数组。这种方法只需要重新组织链表链接就能将链表原地排序(不需要创建任何新的链表节点)。

    展开全文
  • 归并排序

    2020-11-04 06:40:49
    归并排序 要将一个数组排序,可以先(递归地)将他分成两半分别排序,然后将结果归并起来 归并排序能够保证将任意长度为 NNN 的数组排序所需 时间 和...对于长度为 NNN 的任意数组,自顶向下的归并排序最多需要访问数组

    归并排序

    要将一个数组排序,可以先(递归地)将他分成两半分别排序,然后将结果归并起来

    归并排序能够保证将任意长度为 N N N 的数组排序所需 时间 N l o g 2 N Nlog_2N Nlog2N 成正比

    主要缺点: 归并排序所需的 额外空间 N N N 成正比

    自顶向下

    对于长度为 N N N 的任意数组,自顶向下的归并排序需要 1 / 2 N l o g 2 N 1/2Nlog_2N 1/2Nlog2N N l o g 2 N Nlog_2N Nlog2N 次比较

    对于长度为 N N N 的任意数组,自顶向下的归并排序最多需要访问数组 6 N l o g 2 N 6Nlog_2N 6Nlog2N

    public class Merge {
    
        private static Comparable[] aux;
    
        public static void sort(Comparable[] a) {
            int length = a.length;
    
            aux = new Comparable[length];
    
            sort(a, 0, length - 1);
        }
    
        public static void sort(Comparable[] a, int lo, int hi) {
            if (hi <= lo) {
                return;
            }
    
            int mid = lo + (hi - lo) / 2;
    
            sort(a, lo, mid);
    
            sort(a, mid + 1, hi);
    
            merge(a, lo, mid, hi);
        }
    
        /**
         * 原地归并的抽象方法; 该方法将所有元素复制到 aux[] 中,然后在归并回到 a[] 中。 方法在归并时(第二个 for 循环)进行了 4 个条件判断: 左半边用尽 -> 取右半边的元素 右半边用尽 -> 取左半边的元素
         * 右半边的当前元素小于左半边当前元素 -> 取右半边的当前元素 右半边的当前元素大于等于左半边的当前元素 -> 取左半边的元素
         * 
         * @param a
         *            待排序数组
         * @param lo
         *            最小下标
         * @param mid
         *            中值下标
         * @param hi
         *            最大下标
         */
        private static void merge(Comparable[] a, int lo, int mid, int hi) {
            int i = lo;
            int j = mid + 1;
    
            // 将 a[lo...hi] 复制到 aux[lo...hi]
            for (int k = lo; k <= hi; k++) {
                aux[k] = a[k];
            }
    
            // 归并回到a[lo...hi]
            for (int k = lo; k <= hi; k++) {
                if (i > mid) {
                    a[k] = aux[j++];
                } else if (j > hi) {
                    a[k] = aux[i++];
                } else if (less(aux[j], aux[i])) {
                    a[k] = aux[j++];
                } else {
                    a[k] = aux[i++];
                }
            }
    
        }
    
        public static boolean less(Comparable a, Comparable b) {
            return a.compareTo(b) < 0;
        }
    }
    

    自底向上

    算法原理:先归并微型数组,在***成对***归并得到的子数组

    自底向上的归并排序多次遍历整个数组,根据子数组大小进行两两归并。子数组大小 sz 的初始值为 1,每次***加倍***。最后一个子数组的大小只有在数组大小时 sz 的***偶数倍***的时候才会等于 sz (否则它会比 sz 小)。

    对于长度为 N N N 的任意数组,自底向上的归并排序需要 1 / 2 N l o g 2 N 1/2Nlog_2N 1/2Nlog2N N l o g 2 N Nlog_2N Nlog2N 次比较,最多访问数组 6 N l o g 2 N 6Nlog_2N 6Nlog2N 次。

    当数组的长度为 2 的幂时,自顶向下和自底向上所用的比较次数和数组访问次数正好相同。

    • 自顶向下:化整为零
    • 自底向上:循序渐进
    public class MergeBU {
    
        private static Comparable[] aux;
    
        public static void sort(Comparable[] a) {
            int length = a.length;
    
            aux = new Comparable[length];
    
            for (int sz = 1; sz < length; sz = sz + sz) {
                for (int lo = 0; lo < length - sz; lo += sz + sz) {
                    merge(a, lo, lo + sz - 1, Math.min(lo + sz + sz - 1, length - 1));
                }
            }
        }
    
        /**
         * 原地归并的抽象方法; 该方法将所有元素复制到 aux[] 中,然后在归并回到 a[] 中。 方法在归并时(第二个 for 循环)进行了 4 个条件判断: 左半边用尽 -> 取右半边的元素 右半边用尽 -> 取左半边的元素
         * 右半边的当前元素小于左半边当前元素 -> 取右半边的当前元素 右半边的当前元素大于等于左半边的当前元素 -> 取左半边的元素
         *
         * @param a
         *            待排序数组
         * @param lo
         *            最小下标
         * @param mid
         *            中值下标
         * @param hi
         *            最大下标
         */
        private static void merge(Comparable[] a, int lo, int mid, int hi) {
            int i = lo;
            int j = mid + 1;
    
            // 将 a[lo...hi] 复制到 aux[lo...hi]
            for (int k = lo; k <= hi; k++) {
                aux[k] = a[k];
            }
    
            // 归并回到a[lo...hi]
            for (int k = lo; k <= hi; k++) {
                if (i > mid) {
                    a[k] = aux[j++];
                } else if (j > hi) {
                    a[k] = aux[i++];
                } else if (less(aux[j], aux[i])) {
                    a[k] = aux[j++];
                } else {
                    a[k] = aux[i++];
                }
            }
    
        }
    
        public static boolean less(Comparable a, Comparable b) {
            return a.compareTo(b) < 0;
        }
    
    }
    

    归并排序的意义

    归并排序是一种渐进最优的基于***比较排序***的算法

    理解:最坏情况下任意基于***比较排序***的算法所需要的比较次数最少都是   N l o g 2 N ~Nlog_2N  Nlog2N

    归并排序的最优性不是结束,也不代表实际应用中不需要考虑其他方法,因为:

    • 归并排序的空间复杂度不是最优
    • 实践中不一定会遇到最坏情况
    • 除了比较,算法的其他操作(例如访问数组)也可能很重要
      比较排序*的算法

    理解:最坏情况下任意基于***比较排序***的算法所需要的比较次数最少都是   N l o g 2 N ~Nlog_2N  Nlog2N

    归并排序的最优性不是结束,也不代表实际应用中不需要考虑其他方法,因为:

    • 归并排序的空间复杂度不是最优
    • 实践中不一定会遇到最坏情况
    • 除了比较,算法的其他操作(例如访问数组)也可能很重要
    • 不进行比较也能将某些数组排序
    展开全文
  • 归并排序要将一个数组排序,可以先(递归地)将它分成两半分别排序,然后将结果归并起来。自顶向下的归并排序归并排序...命题G:对于长度为 N 的人艺术组,自顶向下的归并排序最多需要访问数组 6NlgN 次。因为递归会

    归并排序


    要将一个数组排序,可以先(递归地)将它分成两半分别排序,然后将结果归并起来。


    自顶向下的归并排序


    归并排序应用了分治的思想,如果它能将两个子数组排序,它就能够通过归并两个子数组来将整个数组排序。

    命题F:对于长度为 N 的任意数组,自顶向下的归并排序需要 (1/2)*NlgN  到 NlgN 次比较。
    
    命题G:对于长度为 N 的人艺术组,自顶向下的归并排序最多需要访问数组 6NlgN 次。
    因为递归会使小规模问题中方法的调用过于频繁,使用插入排序处理小规模子数组(比如长度小于15)一般可以将归并排序的运行时间缩短 10%-15%。
    
    
    如果 arr[mid] <= arr[mid+1],就认为数组已经是有序的,跳过 merge() 方法。这个改动不影响排序的递归调用,但是任意有序的子数组算法的运行时间就变为了线性的。
    
    
    当把辅助数组 aux[] 声明为 merge() 方法的局部变量时,即使每次归并很小的数组,都需要创建新的数组,这样创建新数组将成为归并排序运行时间的主要部分。更好的解决方案是将 aux[] 变为 sort() 方法的局部变量,并将它作为参数传递给 merge() 方法。

    自底向上的归并排序


    自底向上的归并排序是,先归并那些微型数组,然后再成对归并得到的子数组,如此这般,直到将整个数组归并到一起。

    命题H:对于长度为 N 的任意数组,自底向上的归并排序需要 (1/2)NlgN 至 NlgN 次比较,最多访问数组 6NlgN 次。

    自底向上的归并排序比较适合用链表组织的数据,只需要重新组织链表的链接就能将链表原地排序。


    快速排序


    快速排序切分方法的内循环会用一个递增的索引将数组元素与一个定值比较。归并排序和希尔排序一般较慢的原因是,它们在内循环中移动数据。

    快速排序另一个优势是它的比较次数很少。

    快速排序的最好情况是每次都正好能将数组对半分。

    命题K:将长度为 N 的无重复数组排序,快速排序平均需要 ~2NlnN 次比较(以及1/6的交换)。
    
    命题L:快速排序最多需要约 N^2/2 次比较,但随即打乱数组能够预防这种情况。

    在快速排序中,对于小数组,使用插入排序,在 5~15之间的人一直在大多数情况下都让人满意。

    对于包含大量重复元素的数组,三向切分快速排序的排序时间从线性对数降低到了线性时间。


    这里写图片描述

    展开全文
  • 归并排序算法

    2021-08-10 17:04:45
    整个归并排序算法可以看成两部分:将数组递归分解,将两部分数组进行合并 其中,使用MergeSort函数进行排序,传入参数为:arr(待排序数组),l(待排序数组左侧),r(待排序数组右侧) MergeSort函数: 找出需要排序数组...
  • 归并排序(内部)总结归并排序建立在归并操作(即将两个有序数组归并为一个更大的有序数组)上的一种有效的排序算法,该算法是分治法的一个非常典型的应用 我们常用的自顶向下归并排序分为两步: I. 无序数组逐层...
  • 排序算法:归并排序

    2021-01-20 23:42:31
    归并排序 现在所讨论的算法基于归并这个操作,即将两个有序的数组归并成一个更大的有序数组。人们根据这个操作发明处了一种递归排序算法:归并排序。要将一个数组排序,可以先(递归地)将它分成两半分别排序,然后...
  • 归并排序 1. 简介 归并排序(MERGE-SORT)是建立在归并操作上的一种有效的排序算法,该算法是采用分治法(Divide and Conquer)的一个非常典型的应用。...将当前数组按中间分为两个子数组,分别对子数组进行归并排序...
  • 文章目录1、原地归并的抽象方法2、自顶向下的归并排序3、关于自顶向下归并排序的改进3.1、对小规模子数组使用插入排序3.2、测试数组是否已经有序3.3、不将元素复制到辅助数组3、自底向上的归并排序4、比较 ...
  • 1.归并排序最吸引人的性质是它能够保证将任意长度为N...3.对于长度为N的任意数组,自顶向下的归并排序最多需要访问数组6NlogN次。 4.使用插入排序处理小规模的子数组(比如长度小于15)一般可以将归并排序的运行时...
  • 那么归并排序就可以这样描述:要将一个数组排序,可以先(递归地)将它分成两半分别排序,然后将结果(两个分别有序的数组)归并成一个更大的有序的数组。 再来看看图解过程: 对左、右子数组进行排序的过程,其实...
  • 笔者,特别地对归并排序的 复杂度 进行了分析;看了好多博客,只是简单的说了下结论,结论怎么来的,根本不去分析,写博客跟没写似的,,更气人的是,还有抄书的,书上写啥...再分析 访问数组次数 master定理 改进 ...
  • 算法-8-归并排序

    2020-01-18 23:15:24
    3、自顶向下的归并排序 4、自底向上的归并排序 5、归并排序的优化 6、使用场景 7、归并排序是一种渐进最优的基于比较排序的算法。 1、描述 归并排序是基于递归方式进行排序的。它其实可以分为两步: 第一步 ...
  • 归并排序与快速排序

    2021-05-18 22:21:37
    排序算法是最基本的算法之一 本篇博客主要讲解了归并排序以及快速排序
  • 算法系列—自底向上归并排序

    千次阅读 2016-10-22 17:17:03
    思路:先归并微型数组,然后再成对归并得到的子数组,直到我们将整个数组归并到一起 ...对于长度为N的任意数组,自底向上的归并排序需要 1/2NlgN至NlgN次比较,最多访问数组6NlgN次。N为数组元素个数。
  • 归并排序Merge sort1简单释义2 自顶向下的归并排序2.1图解2.2 原地归并抽象方法的解释2.3自顶向下的归并排序2.4自顶向下的归并排序优化建议3 自底向上的归并... 归并排序能够保证将任意长度为NNN的数组排序所需时间和Nl
  • 排序算法——归并排序与快速排序

    万次阅读 多人点赞 2018-07-27 20:50:08
    今天总结一下两种性能优秀的排序算法,归并排序与快速排序。 首先,二者都运用了递归和分治的两种重要思想。在这里递归就不做详细介绍。 分治:顾名思义,分而治之,这是在排序中我们非常常见的一种思想,同时也是...
  • 算法介绍  归并排序的算法逻辑为把两个有序的数组归并为一个有序的数组。举个例子,对于一个长度为8的数组,有两种归并方式自顶向下的归并: 1. 先分为[0-3],[4-7],左右有序后再归并到一起就变成一个完整的有序...
  • 归并排序及其优化

    千次阅读 2017-11-06 14:29:48
    Q:什么是归并排序? A:它是建立在归并操作上的一种有效的排序算法;是采用分治法的一个非常典型的应用;是一种稳定的基本思想要将一个数组排序,可以先(递归地)将它分成两半分别排序,然后将结果归并起来。优点...
  • 归并排序的主要优势是它能保证将任意长度为n的数组排序所需时间与nlogn成正比,它的主要缺点则是它所需的额外空间与n成正比。4.1 原地归并原地排序先将前半部分排序,再将后半部分排序,然后在数组中移动元素而不...
  • “归并”操作是将两个有序的数组合并成一个更大的有序数组归并排序就是基于这一操作,先递归地将一个数组分成两半分别排序,然后将排序结果归并起来。 归并的代码如下: private static void merge(Comparable[] a...
  • 归并排序**分治思想** **思想:将两个有序的数组归并成一个有序数组。** 原始归并的抽象方法(下面两种归并方法用到): 创建一个适当大小的数组,然后将两个有序数组一个个有序的放入所创建的数组中(在此造成了...
  • 归并排序 要将一个数组排序,可以先(递归)将它分成两半分别排序,然后将结果归并起来。 简单归并排序 创建一个适当大小的数组,然后将两个输入数组中的元素一个一个放入这个数组中。 这种算法很容易实现,但是当...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 11,549
精华内容 4,619
关键字:

归并排序访问数组的次数