C++数据结构第49课、归并排序和快速排序

最新推荐文章于 2022-06-28 14:03:23 发布
最新推荐文章于 2022-06-28 14:03:23 发布
阅读量166 收藏
点赞数
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiebs/article/details/108144410
版权

１、归并排序:

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

#ifndef SORT_H
#define SORT_H

#include "Object.h"
namespace XiebsLib
{
class Sort : public Object
{
private:
    Sort();
    Sort(const Sort&);
    Sort& operator=(const Sort&);

    template <typename T>
    static void Swap(T& a, T& b)
    {
        T c = a;
        a = b;
        b = c;
    }

    template<typename T>
    static void Merge(T src[], T helper[], int begin, int mid, int end, bool min2max = true)
    {
        int i = begin;
        int j = mid + 1;
        int k = begin;

        while(i <= mid && j <= end)
        {
            if(min2max ? (src[i] < src[j]) : (src[i] > src[j]))
            {
                helper[k++] = src[i++];
            }
            else
            {
                helper[k++] = src[j++];
            }
        }

        while(i <= mid)
        {
            helper[k++] = src[i++];
        }

        while(j <= end)
        {
            helper[k++] = src[j++];
        }

        for(int i = begin; i <= end; i++)
        {
            src[i] = helper[i];
        }
    }

    template<typename T>
    static void Merge(T src[], T helper[], int begin, int end, bool min2max = true)
    {
        if(begin == end)
        {
            return;
        }
        else
        {
            int mid = (begin + end) / 2;
            Merge(src, helper, begin, mid, min2max);
            Merge(src, helper, mid+1, end, min2max);
            Merge(src, helper, begin, mid, end, min2max);
        }
    }

public:

    template<typename T>
    static void Select(T array[], int len, bool min2max = true)
    {
        for(int i = 0;  i < len; i++)
        {
            int min = i;
            for(int j = i + 1; j < len; j++)
            {
                if(min2max ? (array[min] > array[j]) : (array[i] < array[j]))
                {
                    min = j;
                }
            }

            if(min != i)
            {
                Swap(array[i],array[min]);
            }
        }
    }

    template < typename T >
    static void insert(T array[], int len, bool min2max = true)
    {
        for(int i = 1; i < len; i++)
        {
            int k = i;
            T e = array[i];
            for(int j = i-1; (j >= 0) && (min2max ? array[j] > e : array[j] < e); j--)
            {

                array[j+1] = array[j];      //满足条件的后移一位
                k = j;
            }

            if(i != k)
            {
                array[k] = e;
            }
        }
    }


    template < typename T >
    static void Bubble(T array[], int len, bool min2max = true)
    {
        bool exchange = true;
        for(int i = 0; i < len && exchange; i++)
        {
            exchange = false;
            for(int j = len-1; j > i; j--)
            {
                if(min2max ? (array[j-1] > array[j]) : (array[j-1] < array[j]))
                {
                    Swap(array[j-1], array[j]);
                    exchange = true;
                }
            }
        }
    }

    template < typename T >
    static void Shell(T array[], int len, bool min2max = true)
    {
      int d = len;
      do
      {
          d = d / 3 + 1;   // 之所以这样写是因为经过数学推导，这样的效率是最高的。也可以写成 d--;
          for(int i = d; i < len; i += d)
          {
              int k = i;
              T e = array[i];

              for(int j = i-d; (j >= 0) && (min2max ? array[j] > e : array[j] < e); j -= d)
              {

                  array[j+d] = array[j];
                  k = j;
              }

              if(i != k)
              {
                  array[k] = e;
              }
          }
      }
      while(d > 1);
    }

//    template < typename T >
//    static void Shell_Bubble(T array[], int len, bool min2max = true)
//    {
//      int d = len;
//      do
//      {
//          d = d / 3 + 1;   // 之所以这样写是因为经过数学推导，这样的效率是最高的。也可以写成 d--;
//          bool exchange = true;
//          for(int i = 0; i < len && exchange; i += d)
//          {
//              exchange = false;
//              for(int j = len-1; j > i; j-=d)
//              {
//                  if(min2max ? (array[j-d] > array[j]) : (array[j-d] < array[j]))
//                  {
//                      Swap(array[j-d], array[j]);
//                      exchange = true;
//                  }
//              }
//          }
//      }
//      while(d > 1);
//    }

    template<typename T>
    static void Merge(T array[], int len, bool min2max = true)
    {
        T* helper = new T[len];
        if(helper != nullptr)
        {
            Merge(array, helper, 0, len - 1, min2max);
        }
        delete []helper;
    }
};
}
#endif // SORT_H

#include <iostream>
#include "Sort.h"

using namespace std;
using namespace XiebsLib;

int main()
{
    int array[] = {9, 3, 2, 4, 1, 5, 7, 6, 9, 8};

    Sort::Merge(array, 10, false);

    for(int i = 0; i < 10; i++)
    {
        cout << array[i] << endl;
    }
}

在这里插入图片描述

2、快速排序

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

#ifndef SORT_H
#define SORT_H

#include "Object.h"
namespace XiebsLib
{
class Sort : public Object
{
private:
    Sort();
    Sort(const Sort&);
    Sort& operator=(const Sort&);

    template <typename T>
    static void Swap(T& a, T& b)
    {
        T c = a;
        a = b;
        b = c;
    }

    template<typename T>
    static void Merge(T src[], T helper[], int begin, int mid, int end, bool min2max = true)
    {
        int i = begin;
        int j = mid + 1;
        int k = begin;

        while(i <= mid && j <= end)
        {
            if(min2max ? (src[i] < src[j]) : (src[i] > src[j]))
            {
                helper[k++] = src[i++];
            }
            else
            {
                helper[k++] = src[j++];
            }
        }

        while(i <= mid)
        {
            helper[k++] = src[i++];
        }

        while(j <= end)
        {
            helper[k++] = src[j++];
        }

        for(int i = begin; i <= end; i++)
        {
            src[i] = helper[i];
        }
    }

    template<typename T>
    static void Merge(T src[], T helper[], int begin, int end, bool min2max = true)
    {
        if(begin == end)
        {
            return;
        }
        else
        {
            int mid = (begin + end) / 2;
            Merge(src, helper, begin, mid, min2max);
            Merge(src, helper, mid+1, end, min2max);
            Merge(src, helper, begin, mid, end, min2max);
        }
    }

    template<typename T>
    static int Partition(T array[], int begin, int end, bool min2max = true)
    {
        T pv = array[begin];
        while(begin < end)
        {
            while(begin < end && (min2max ? (array[end] > pv) : (array[end] < pv)))
            {
                end--;
            }
            Swap(array[begin], array[end]);

            while(begin < end && (min2max ? (array[begin] <= pv) : (array[begin] >= pv)))
            {
                begin++;
            }
            Swap(array[begin], array[end]);
        }
        array[begin] = pv;
        return begin;
    }

    template<typename T>
    static void Quick(T array[], int begin, int end, bool min2max = true)
    {
        if(begin < end)
        {
            int pivot = Partition(array, begin, end, min2max);

            Quick(array, begin, pivot-1, min2max);
            Quick(array, pivot+1, end, min2max);
        }
    }
public:

    template<typename T>
    static void Select(T array[], int len, bool min2max = true)
    {
        for(int i = 0;  i < len; i++)
        {
            int min = i;
            for(int j = i + 1; j < len; j++)
            {
                if(min2max ? (array[min] > array[j]) : (array[i] < array[j]))
                {
                    min = j;
                }
            }

            if(min != i)
            {
                Swap(array[i],array[min]);
            }
        }
    }

    template < typename T >
    static void insert(T array[], int len, bool min2max = true)
    {
        for(int i = 1; i < len; i++)
        {
            int k = i;
            T e = array[i];
            for(int j = i-1; (j >= 0) && (min2max ? array[j] > e : array[j] < e); j--)
            {

                array[j+1] = array[j];      //满足条件的后移一位
                k = j;
            }

            if(i != k)
            {
                array[k] = e;
            }
        }
    }


    template < typename T >
    static void Bubble(T array[], int len, bool min2max = true)
    {
        bool exchange = true;
        for(int i = 0; i < len && exchange; i++)
        {
            exchange = false;
            for(int j = len-1; j > i; j--)
            {
                if(min2max ? (array[j-1] > array[j]) : (array[j-1] < array[j]))
                {
                    Swap(array[j-1], array[j]);
                    exchange = true;
                }
            }
        }
    }

    template < typename T >
    static void Shell(T array[], int len, bool min2max = true)
    {
      int d = len;
      do
      {
          d = d / 3 + 1;   // 之所以这样写是因为经过数学推导，这样的效率是最高的。也可以写成 d--;
          for(int i = d; i < len; i += d)
          {
              int k = i;
              T e = array[i];

              for(int j = i-d; (j >= 0) && (min2max ? array[j] > e : array[j] < e); j -= d)
              {

                  array[j+d] = array[j];
                  k = j;
              }

              if(i != k)
              {
                  array[k] = e;
              }
          }
      }
      while(d > 1);
    }

//    template < typename T >
//    static void Shell_Bubble(T array[], int len, bool min2max = true)
//    {
//      int d = len;
//      do
//      {
//          d = d / 3 + 1;   // 之所以这样写是因为经过数学推导，这样的效率是最高的。也可以写成 d--;
//          bool exchange = true;
//          for(int i = 0; i < len && exchange; i += d)
//          {
//              exchange = false;
//              for(int j = len-1; j > i; j-=d)
//              {
//                  if(min2max ? (array[j-d] > array[j]) : (array[j-d] < array[j]))
//                  {
//                      Swap(array[j-d], array[j]);
//                      exchange = true;
//                  }
//              }
//          }
//      }
//      while(d > 1);
//    }

    template<typename T>
    static void Merge(T array[], int len, bool min2max = true)
    {
        T* helper = new T[len];
        if(helper != nullptr)
        {
            Merge(array, helper, 0, len - 1, min2max);
        }
        delete []helper;
    }

    template<typename T>
    static void Quick(T array[], int len, bool min2max = true)
    {
        Quick(array, 0, len - 1, min2max);
    }
};
}
#endif // SORT_H

#include <iostream>
#include "Sort.h"

using namespace std;
using namespace XiebsLib;

int main()
{
    int array[] = {9, 3, 2, 4, 1, 5, 7, 6, 9, 8};

    Sort::Quick(array, 10, false);

    for(int i = 0; i < 10; i++)
    {
        cout << array[i] << endl;
    }
}

在这里插入图片描述

  • 小结
    1、归并排序需要额外的辅助空间才能完成，空间复杂度为 O(n)；
    2、归并排序的时间复杂度为 O(n * logn)，是一种稳定的排序法；
    3、快速排序通过对递归的方式对排序问题进行划分；
    4、快速排序的时间复杂度为 O(n * logn)，是一种不稳定的排序法。
xiebs_
关注
专栏目录
插入排序-希尔排序-选择排序-冒泡排序-快速排序-基数排序-外部排序-归并排序[数据结构与算法]
weixin_44972997的博客
03-05 3700
文章详细总结了插入排序、希尔排序、选择排序、归并排序、交换排序（冒泡排序、快速排序）、基数排序、外部排序。从`思想`到`代码实现`。 大三党，大数据专业，正在为面试准备，欢迎学习交流`。
数据结构（排序，冒泡排序、选择排序、插入排序、希尔排序、堆排序、快速排序、归并排序，C++）
konglongdanfo的博客
07-24 362
冒泡排序 冒泡排序（Bubble Sort）一种交换排序，它的基本思想是：两两比较相邻记录的关键字，如果反序则交换，知道没有反序的记录为止。冒泡排序是一种比较简单的排序方法，实现代码如下： // 交换两个下标所指的值 template&amp;lt;typename T&amp;gt; void swap(T *ptr, int i, int j) { T temp = ptr[i]; ...
【算法】单链表的快速排序和归并排序
萧十一的技术小站
01-30 464
当我们要对一个单链表进行排序，并要求复杂度为O(nlgn)时。在对数组排序的算法中，复杂度为O(nlgn)的算法有：快速排序、归并排序和堆排序。由于堆排序需要将数据组织成一个最大堆，这对于链表来说需要将其重新构造为一个二叉树，这样做太过复杂并且浪费额外的空间。所以只能考虑快速排序和归并排序。 由于单链表不支持对结点的随机访问，所以不能直接套用在数组上的排序算法。由于快速排序和归并排序都包含二分的...
对单链表的归并排序的C++实现
Hikers、Wan的博客
02-28 779
前言 记录用C++实现基于单链表的归并排序 代码 一共三个文件SingleLinkedList.h, CNode.h以及main.cpp。 首先是CNode.h #ifndef _NODE_H__ #define _NODE_H__ class CNode{ private: int data; CNode *nextNode; public: CNode(); void setData...
C++第49课--多态的概念和意义
奶牛养殖场小马
02-05 304
本文学习自 狄泰软件学院 唐佐林老师的 C++课程 当 函数重写遇到赋值兼容 如上节最后一例的解析，编译器会草率的为了安全直接调用指针或引用类型的类的成员函数，而不会理会所指向的类型是什么，这样不符合我们是实际要求，于是 推出了多态的概念，将父类中的有可能被重写的成员函数加上 virtual 虚函数属性，这样的话，virtual 告诉编译器， print() 有可能在后续被继承的过程中被重写的，...
C++链表排序（归并法+快速排序）
qq_41884662的博客
04-18 6722
我们可以试用归并排序解决： 对链表归并排序的过程如下。 找到链表的中点，以中点为分界，将链表拆分成两个子链表。寻找链表的中点可以使用快慢指针的做法，快指针每次移动 2 步，慢指针每次移动 1步，当快指针到达链表末尾时，慢指针指向的链表节点即为链表的中点。 对两个子链表分别排序。 将两个排序后的子链表合并，得到完整的排序后的链表 上述过程可以通过递归实现。递归的终止条件是链表的节点个数小于或等于 1，即当链表为空或者链表只包含 1 个节点时，不需要对链表进行拆分和排序。 class Solution { .
算法：C++ 实现 快速排序、归并排序
博樽
04-09 2326
快速排序、归并排序；理解过后看代码解析。
C++实现排序 - 02 归并排序、快速排序和堆排序
Newin2020的博客
06-28 1742
数据结构与算法专栏 —— C++实现归并排序采用了分治法的思想，不断将两个有序的序列进行合并从而最终得到整个有序的序列，算法步骤如下：直接上图：我们先对序列进行划分操作：然后对各个子序列进行回溯：通过合并操作，得到最终的子序列。 快速排序 快速排序也是利用了递归思想，算法步骤如下：直接上图：第一步：选取第一个数作为基准数。第二步：从后往前找一个比基准数小的数放到前面。第三步：从前往后找到一个比基准数大的树放到后面。第四步：继续从后往前查找，发现 first 和 last 重合，本次遍历结束，并将基准数放到指
【数据结构】十大排序
热门推荐
英雄哪里出来
01-11 7万+
打开算法大门，从排序开始
【精品课件】数据结构与算法 数据结构与C语言 data structure课程 第0章 C++复习（共49页）.ppt
11-05
查找算法涉及到如何在数据集合中寻找特定元素，而排序算法如冒泡排序、选择排序、插入排序、快速排序和归并排序等，关注的是如何有效地排列元素序列。 通过这门课程的学习，学生不仅能掌握C++语言的基本语法，还能...
十大经典排序算法(C++、Java实现)动图演示及代码解析-冒泡排序、选择排序、插入排序、快速排序、堆排序、希尔排序、归并排序、计数排序、桶排序、基数排序
SmallBottle-CGWLMX的博客
09-10 2981
和我的LeetCode系列源码放到一起。做IT行业，不管是测试、开发、运维等等，或简单或复杂的算法是必不可少的，也是大家面试工作中的必要环节，这个专栏开始和大家一起来研究著名的LeetCode，里边有上千种最常见的算法，面试工作出现几率很高，值得掌握研究，每次完成博客更新我会同步更新我的个人Github上的代码，每个算法都可以直接运行调试以供掌握，GitHub地址：https://github.c...
C++ 九大排序和三大查找 详解（原理+代码实现，含主函数）
楚尧的博客
08-14 658
一、查找 1.二分折半查找 #include<iostream> using namespace std; //二分查找法，查找一个数组的元素，并返回所在的位置的下标， //必须要是一个有序的数组， int select_arr(int arr[], int len, int arr_value) { while (1) { int left = 0; //数组的左侧下标 int right = len-1; //数组的右侧下标
单链表排序（快速排序、归并排序）
doufei_JLU_CCST_08
03-26 1万+
本题目来源于LeetCode,具体如下： Sort a linked list in O(n log n) time using constant space complexity. 题目要求复杂度O(nlogn)，因此我们很自然考虑使用快速排序或者归并排序，但是后来经过实践证明，使用快速排序总是AC超时，归并排序则可以正确AC。 分析一下原因，个人认为是与测试数据有关，因为快速排序不能
算法系列（四）排序算法中篇--归并排序和快速排序
robert的专栏
05-30 8842
在算法系列（三）排序算法上篇 一文中，介绍了冒泡排序，插入排序和选择排序算法。这篇文章继续讲解排序算法。 概述 冒泡排序，插入排序和选择排序算法这些算法的时间复杂度都是O(N^2),是否有更高效的排序算法呢？当然有了，堆排序，归并排序，快速排序，它们的时间复杂度都是O(nlogn)。堆排序使用了树结构，到目我们前还没有介绍树相关的算法，这里先分析归并排序跟快速排序。 归并排序 基本原理
C++数据结构第63课、二叉树中的结点插入操作
xiebs的博客
08-27 2046
我们在进行插入操作的时候不是二叉树的任意结点都能插入，必须得指明插入新结点的位置，是左子树还是右子树，如果不指明便是默认从左向右的进行插入。 因此我们得定义一个枚举，用来表示二叉树结点的位置。 插入操作分为两种： — 插入新结点 bool insert(TreeNode<T>* node) bool insert(TreeNode<T>* node, BTNodePos pos) — 插入数据元素 bool insert(const T& value, TreeNode..
C++数据结构第24课、单链表的遍历和优化
xiebs的博客
07-02 1167
问题 如何遍历单链表中的每一个数据元素 当前单链表的遍历方法 LinkList<int> list; for(int i = 0;i < 5;i++) { list.insert(0, i); } for(int i = 0;i < list.length();i++) { cout << list.get(i) << endl; } 遗憾的是：我们不能以线性的时间复.
C++数据结构第64课、二叉树中的结点删除与清除
xiebs的博客
08-27 1051
删除的方式 — 基于数据元素值的删除：SharedPointer< Tree<T> > remove(const T& value) — 基于结点的删除：SharedPointer< Tree<T> > remove(TreeNode<T>* node) 二叉树中结点的删除 删除操作功能的定义 — virtual void remove(BTreeNode<T>* node, BTree<T>*& ret.
C++数据结构第54课、树中结点的插入操作
xiebs的博客
08-24 1033
插入的方式应分为两种： — 插入新结点：bool insert(TreeNode<T>* node) — 插入数据元素：bool insert(const T& value, TreeNode<T>* parent) 如何在树中指定新结点的位置？ — 树是非线性的，无法采用下标的形式定位数据元素 — 每一个树结点都有唯一的前驱结点（父结点） — 因此，必须先找到前驱节点，才能完成新结点的插入 插入新结点的流程： 插入数据元素流程： ...
C++数据结构算法模板：快速排序、归并排序与二分查找
在本文档中，提供了四个关于数据结构的C++代码模板，分别对应于快速排序、归并排序、整数二分搜索以及浮点数二分搜索。这些模板是编程竞赛或解决实际问题中常用的算法实现，对于理解和应用数据结构有重要作用。 1. ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值