算法：分治策略

已于 2022-03-30 20:33:57 修改
阅读量355 收藏 2
点赞数
分类专栏： 算法 文章标签： c++ 数据结构 算法
于 2022-03-24 10:47:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_48580892/article/details/122909187
版权

文章目录

一、分治策略

1.定义：

是将规模比较大的问题可分割成规模较小的相同问题。问题不变，规模变小。这自然导致递归过程的产生。分治与递归像一对孪生兄弟，经常同时应用在算法设计之中，并由此产生许多高效算法。

2.特征

（1）该问题的规模缩小到一定的程度就可以容易地解决。
（2）该问题可以分解为若干个规模较小的相同问题。
（3）使用小规模的解,可以合并成该问题原规模的解。
（4）该问题所分解出的各个子规模是相互独立的。

3.递归

若一个函数直接地或间接地调用自己，则称这个函数是递归的函数。(简单地描述为“自己调用己”)。

3.1递归函数

递归函数的执行分为“递推”和“回归”两个过程，这两个过程由递归终止条件控制，即逐层递推，直至递归终止条件满足，种植递归，然后逐层回归。

递归调用同普通函数的调用一样，每当调用发生时，就要分配新的栈帧（型参数据，现场保护，局部变量），而与普通函数调用不同的是，由于递推的过程是一个逐层调用的过程，因此存在一个逐层连续的分配栈帧过程，直至遇到递归终止条件时，才开始回归，这时才逐层释放栈帧空间，返回到上一层，直至最后返回到主调函数。

凡是函数被调用，就要开辟栈帧

二、示例

1.例1

int fun(int n)//循环
{
    int sum = 1;
    for (int i = 1; i < n; ++i)
    {
        sum = sum * i;
    }
    return sum;
}
int fac(int n)//递归
{
    if (n <= 1)
    {
        return 1;
    }
    else
    {
        return fac(n - 1);
    }
}

2.例2

顺序打印

void Print(const int* br, int n)
{
    if (n > 0)
    {
        Print(br, n - 1);//顺序打印
        cout << br[n - 1] << " ";
       	//先执行上面语句进行递归，在倒过来执行三个输出函数进行打印
    }
}
void Print_Ar(const int* br, int n)//递归
{
    if (br == NULL || n < 1) return;
    Print(br, n);
    cout << endl;
}
int main()
{
    int ar[] = { 12, 23, 34 };
    int n = sizeof(ar) / sizeof(ar[0]);
    Print_Ar(ar, n);
    return 0;
}

逆序打印

void Print(const int* br, int n)
{
    if (n > 0)
    {
        cout << br[n - 1] << " ";
        Print(br, n - 1);//逆序打印
    }
}
void Print_Ar(const int* br, int n)//递归
{
    if (br == NULL || n < 1) return;
    Print(br, n);
    cout << endl;
}
int main()
{
    int ar[] = { 12, 23, 34 };
    int n = sizeof(ar) / sizeof(ar[0]);
    Print_Ar(ar, n);
    return 0;
}

栈溢出

void Print(const int* br, int n)
{
    if (n > 0)
    {
        Print(br, n--);//栈溢出
        cout << br[n - 1] << " ";
    }
}
void Print_Ar(const int* br, int n)//递归
{
    if (br == NULL || n < 1) return;
    Print(br, n);
    cout << endl;
}
int main()
{
    int ar[] = { 12, 23, 34 };
    int n = sizeof(ar) / sizeof(ar[0]);
    Print_Ar(ar, n);
    return 0;
}

引用

void Print(const int* br, int& n)//引用每次打印都是相同的元素
{
    if (n > 0)
    {
        Print(br, --n);
        cout << br[n - 1] << " ";
    }
}
void Print_Ar(const int* br, int n)//递归
{
    if (br == NULL || n < 1) return;
    Print(br, n);
    cout << endl;
}
int main()
{
    int ar[] = { 12, 23, 34 };
    int n = sizeof(ar) / sizeof(ar[0]);
    Print_Ar(ar, n);
    return 0;
}

3.例3：查找数组下标递归调用

int FindPos(const int* br, int n, int val)
{
    if (br == NULL || n < 1) return -1;
    int pos = n - 1;
    while (pos >= 0 && br[pos] != val)
    {
        --pos;
    }
    return pos;
}
int Find(const int* br, int n, int val)
{
    if (n <= 0 || br[n - 1] == val)
    {
        return n - 1;
    }
    else
    {
        return Find(br, n - 1, val);
    }
}

三、排序算法（快速排序，归并排序，堆排序）

1.知识点

（1）时间复杂度 ？
（2）空间复杂度 ？
（3）稳定还是不稳定排序？
（4）排序退化
（5）排序算法如何选择？
（6）非递归排序
（7）在什么情况下快排速度会降低？
当要排序的数组是有序的时候，时间复杂度会变为n^2

2.快速排序算法

void Print_Ar(const int* br, int n)
{
    if (br == NULL || n < 1) return;
    for (int i = 0; i < n; ++i)
    {
        cout << br[i] << " ";
    }
    cout << endl;
}
int Parition(int* br, int left, int right)
{
    int tmp = br[left];
    while (left < right)
    {
        while (left < right && br[right]>tmp)
        {
            --right;
        }
        if (left < right)
        {
            br[left] = br[right];
        }
        while (left < right && br[left] <= tmp)
        {
            ++left;
        }
        if (left < right)
        {
            br[right] = br[left];
        }
    }
    br[left] = tmp;
    return left;
}
void PassQuick(int* br, int left, int right)
{
    if (left < right)
    {
        int pos = Parition(br, left, right);
        PassQuick(br, left, pos - 1);
        PassQuick(br, pos + 1, right);
    }
}
void QuickSort(int* br, int n)
{
    if (br == NULL || n < 2) return;
    PassQuick(br, 0, n - 1);
}
int main()
{
    int ar[] = { 56,12,78,90,34,23,100,56,45,67,89 };
    int n = sizeof(ar) / sizeof(ar[0]);
    Print_Ar(ar, n);
    QuickSort(ar, n);
    Print_Ar(ar, n);
    return 0;
}

在这里插入图片描述

3.非递归写法

#include<iostream>
#include<list>
#include<vector>
#include<queue>
#include<stack>
using namespace std;


void Print_Ar(const int* br, int n)
{
    if (br == NULL || n < 1) return;
    for (int i = 0; i < n; ++i)
    {
        cout << br[i] << " ";
    }
    cout << endl;
}
int Parition(int* br, int left, int right)
{
    int tmp = br[left];
    while (left < right)
    {
        while (left < right && br[right]>tmp)
        {
            --right;
        }
        if (left < right)
        {
            br[left] = br[right];
        }
        while (left < right && br[left] <= tmp)
        {
            ++left;
        }
        if (left < right)
        {
            br[right] = br[left];
        }
    }
    br[left] = tmp;
    return left;
}
void PassQuick(int* br, int left, int right)
{
    if (left < right)
    {
        int pos = Parition(br, left, right);
        PassQuick(br, left, pos - 1);
        PassQuick(br, pos + 1, right);
    }
}
void QuickSort(int* br, int n)//非递归排序算法
{
    if (br == NULL || n < 2) return;
    queue<int> qu;
    qu.push(0);
    qu.push(n - 1);
    while (!qu.empty())
    {
        int left = qu.front();
        qu.pop();
        int right = qu.front();
        qu.pop();
        int pos = Parition(br, left, right);
        if (left < pos - 1)
        {
            qu.push(left);
            qu.push(pos - 1);
        }
        if (pos + 1 < right)
        {
            qu.push(pos + 1);
            qu.push(right);
        }
    }
}
void QuickSort(int* br, int n)//递归排序算法
{
    if (br == NULL || n < 2) return;
    PassQuick(br, 0, n - 1);
}
int main()
{
    int ar[] = { 56,12,78,90,34,23,100,56,45,67,89 };
    int n = sizeof(ar) / sizeof(ar[0]);
    Print_Ar(ar, n);
    QuickSort(ar, n);
    Print_Ar(ar, n);
    return 0;
}

4.pair对的用法

#include<iostream>
#include<list>
#include<vector>
#include<queue>
#include<stack>
#include<stdio.h>
using namespace std;

void Print_Ar(const int* br, int n)
{
    if (br == NULL || n < 1) return;
    for (int i = 0; i < n; ++i)
    {
        cout << br[i] << " ";
    }
    cout << endl;
}
int Parition(int* br, int left, int right)
{
    int tmp = br[left];
    while (left < right)
    {
        while (left < right && br[right]>tmp)
        {
            --right;
        }
        if (left < right)
        {
            br[left] = br[right];
        }
        while (left < right && br[left] <= tmp)
        {
            ++left;
        }
        if (left < right)
        {
            br[right] = br[left];
        }
    }
    br[left] = tmp;
    return left;
}
void PassQuick(int* br, int left, int right)
{
    if (left < right)
    {
        int pos = Parition(br, left, right);
        PassQuick(br, left, pos - 1);
        PassQuick(br, pos + 1, right);
    }
}
void QuickSort(int* br, int n)//非递归排序算法
{
    if (br == NULL || n < 2) return;
    queue<int> qu;
    qu.push(0);
    qu.push(n - 1);
    while (!qu.empty())
    {
        int left = qu.front();
        qu.pop();
        int right = qu.front();
        qu.pop();
        int pos = Parition(br, left, right);
        if (left < pos - 1)
        {
            qu.push(left);
            qu.push(pos - 1);
        }
        if (pos + 1 < right)
        {
            qu.push(pos + 1);
            qu.push(right);
        }
    }
}
void QuickSort(int* br, int n)//递归排序算法
{
    if (br == NULL || n < 2) return;
    PassQuick(br, 0, n - 1);
}
void QuickSort(int* br, int n)//队排序算法(第一种)
{
    if (br == NULL || n < 2) return;
    queue<std::pair<int, int>> qu;
    qu.push(std::pair<int, int>(0, n - 1));//左边和右边
    while (!qu.empty())
    {
        std::pair<int, int> pos = qu.front();
        qu.pop();
        int mid = Parition(br, pos.first, pos.second);
        if (pos.first < mid - 1)
        {
            qu.push(std::pair<int, int>(pos.first, mid - 1));
        }
        if (mid + 1 < pos.second)
        {
            qu.push(std::pair<int, int>(mid + 1, pos.second));
        }
    }
}
void QuickSort(int* br, int n)//队排序算法(第二种)
{
    if (br == NULL || n < 2) return;
    typedef std::pair<int, int> Pair;//typedef关键使程序更加清楚
    queue<Pair> qu;
    qu.push(Pair(0, n - 1));
    while (!qu.empty())
    {
        Pair pos = qu.front();
        qu.pop();
        int mid = Parition(br, pos.first, pos.second);
        if (pos.first < mid - 1)
        {
            qu.push(Pair(pos.first, mid - 1));
        }
        if (mid + 1 < pos.second)
        {
            qu.push(Pair(mid + 1, pos.second));
        }
    }
}

int main()
{
    int ar[] = { 56,12,78,90,34,23,100,56,45,67,89 };
    int n = sizeof(ar) / sizeof(ar[0]);
    Print_Ar(ar, n);
    QuickSort(ar, n);
    Print_Ar(ar, n);
    return 0;
}
何小柒（qi)～
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【算法】分治策略
xiaoxiaoguailou的博客
04-12 1997
文章目录一、关于分治策略二、使用分治策略+递归解题 一、关于分治策略 分治策略： 简单来说就是将问题的规模变小，问题本身不变 解题步骤： 分解： 将原问题划分成子问题，规模变小 递归： 递归求解子问题，若子问题规模足够小，此时停止递归，直接求解 合并： 将小规模的解合并成原规模的解 注意： 分治策略是一种处理问题的思想，递归是一种算法。 二、使用分治策略+递归解题 ...
算法——分治策略
lengxuenong的博客
04-23 3723
引用自：http://blog.csdn.net/com_stu_zhang/article/details/7233761 分治的概念与基本思想    在计算机科学中，分治法是一种很重要的算法。字面上的解释是“分而治之”，就是把一个复杂的问题分成两个或更多的相同或相似的子问题，再把子问题分成更小的子问题……直到最后子问题可以简单的直接求解，原问题的解即子问题的解的合并。这个技巧是很多
算法-分治策略
sinat_31655507的博客
02-25 366
分治法 最大子数组问题 矩阵乘法Strassen算法 最大子数组 运用递归：时间复杂度O(NlogN) 不运用递归：线性时间O(N) int FindMaxCross Subarray(vector<int> &arr, int low, int mid, int high){ int left_sum=INT_MIN; int right_sum=INT_MIN; int
[算法导论][4]分治策略
T0UGH
03-10 208
第4章 分治策略 在分治策略中，我们递归地求解一个问题，在每层递归中运用如下三个步骤 分解(Divide)：将问题划分为一些子问题，子问题的形式与原问题一样，只是规模更小 解决(Comquer)：递归的求解出子问题，如果子问题的规模足够小，则停止递归，直接求解 合并(Combine)：将子问题的解组合成原问题的解 递归情况和基本...
算法之分治策略与应用
apigfly的博客
10-29 723
归并排序中我们利用了分治策略，在分治策略中，我们递归求解一个问题，在每层递归中应用如下三个步骤： 分解：将问题划分为一些子问题，子问题的形式与原问题一样，只是规模更小。 解决：递归的求解出子问题。如果子问题的规模足够小，则停止递归，直接求解。 合并：将子问题的解组合成原问题的解。 当子问题足够大，需要递归求解时，称之为递归情况。当子问题变得足够小，不需要再递归时，递归已经"触底"，进入了基...
算法策略 - 分治（Divide And Conquer）
宋卓的博客
01-29 412
分治，也就是分而治之。它的一般步骤是 将原问题分解成若干个规模较小的子问题（子问题和原问题的结构一样，只是规模不一样） 子问题又不断分解成规模更小的子问题，直到不能再分解（知道可以轻易算出子问题的解） 利用子问题的解推导出原问题的解 因此，分治策略非常适合用递归 需要注意的是：子问题之间是互相独立的 分治的应用 快速排序 归并排序 Karatsuba算法（大数乘法） ...
算法与分析实验一：分治与递归
02-10
针对本实验中的网球循环赛日程表设计，我们可以采用分治策略。首先，如果只剩两个选手，日程表安排就非常简单，只需安排他们之间的一场比赛。如果选手人数更多，我们把选手分为两组，每组再继续进行分治，直到每个...
二分搜索算法（分治策略）报告.doc
12-26
二分搜索算法是一种高效的数据查找方法，属于分治策略的典型应用。在已排序的数组中，二分搜索通过不断将查找区间减半来定位目标元素。以下是关于这个实验报告的详细解读： 1. **问题描述**：实验要求在给定的、已...
算法分析与设计实验一：分治策略.doc
10-29
算法分析与设计实验报告
《算法设计与分析》实验报告：实验一（分治策略）
11-17
实验报告的标题是“《算法设计与分析》实验报告：实验一（分治策略）”，主要探讨了如何运用分治思想来设计和实现算法，并通过实际的编程实验进行了验证和性能分析。实验涉及的主要算法包括二分搜索、合并排序以及可...
算法分析及实例解析（一）——分治法
小熊的博客
08-08 1157
分治法（divide and conquer） 对于一个规模为n的问题，若该问题可以容易地解决，则直接解决，否则将其分解为k个规模较小的子问题，这些子问题互相独立，且与原问题形式相同，递归地解决这些子问题，然后将各子问题的解合并，得到原问题的解。这种算法设计策略叫做分治策略。 分治法在每层递归上由三个步骤组成： 1）划分（divide）：将原问题分解成若干规模较小、相互独立、与原
算法设计学习笔记（五）分治策略
weixin_43869415的博客
07-07 377
文章目录前言一、pandas是什么？二、使用步骤1.引入库2.读入数据总结 前言 本文是对于算法设计的学习笔记，如有错误，请不吝赐教。 一、pandas是什么？ 示例：pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。 二、使用步骤 1.引入库 代码如下（示例）： import numpy as np import pandas as pd import matplotlib.pyplot as plt import seaborn as sns import warni
【算法学习】---（一）分治策略
zypf_lover的博客
05-13 1231
本节算法：分治法 分治策略：是将规模较大的问题分割成为规模较小的子问题。==“问题不变，规模减小”==这是分治策略的核心思想。 分治策略可以解决的问题具有一下特点： 该问题缩小到一定的规模很容易求解 该问题可以分解为若干个规模较小的子问题 使用较小规模的子问题，可以合并成该问题原规模的解 该问题分解出的子问题之间是相互独立的 举个简单的例子，现在有50000项任务需要一个项目组去完成，似乎听起来很难很快完成，但是，当这个项目组中有200个成员时，安排第1个成员去完成前250个任务，第2个成员完成接下来
算法---递归与分治策略
Koving的博客
10-07 359
算法—递归与分治策略 概念 直接或间接的调用自身的算法成为递归算法。用函数自身给出定义的函数称为递归函数。 在使用递增归策略时，必须有一个明确的递归结束条件，称为递归出口，否则将无限进行下去（死锁）。 逆序输出一个正数中的每一位数 例如，对于数12345，依次输出5 4 3 2 1 void Reverse( int n){ if(n/10==0) cout<<n; el...
分治策略
fugitive1的博客
06-13 2329
多项式大于、小于 多项式大于： 若f(n)f(n)f(n)多项式大于g(n)g(n)g(n)，则：∃e&gt;0,n0,使得当n&gt;n0，有f(n)&gt;g(n)ne\exist e&gt;0,n_0,使得当n&gt;n_0，有f(n)&gt;g(n)n^e∃e>0,n0​,使得当n>n0​，有f(n)>g(n)ne 多项式小...
探索分治算法：解决复杂问题的有效策略
最新发布
m0_73731708的博客
06-30 1116
该算法将问题分解为更小、更易解决的子问题，然后通过合并子问题的解来得到原问题的解。通过将原问题划分为规模较小的子问题，递归地解决每个子问题，并将子问题的解合并为原问题的解，我们能够高效地解决复杂问题。归并排序（Merge Sort）是一种常用的排序算法，它利用分治算法的思想来将一个待排序的数组分成两个相等大小的子数组，然后递归地对子数组进行排序，并最后将两个有序子数组合并为一个有序数组。分治算法的核心思想是将一个复杂的问题划分为可解决的小问题，然后通过递归地求解这些小问题，最后将其结果合并为原问题的解。
程序设计与算法：分治策略和归并排序
分治算法与归并排序 分治算法是一种常用的解决问题的方法，通过将一个复杂的问题分解成多个小问题，然后分别解决这些小问题，最终合并这些小问题的解决方案来解决原始问题。这种方法可以将问题的规模缩小，从而使...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值