【顶配快速排序】CUTOFF配合三点中值法的三路划分

已于 2023-05-11 22:01:38 修改
阅读量625 收藏 1
点赞数 1
分类专栏： 算法新解 文章标签： c++ 算法 排序算法 快排
于 2023-05-11 18:43:04 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34890856/article/details/130605289
版权

目录

1引入情境

  从低到高排成一队，怎么办？
  1. 以大雄为中心，比他高度的到右边，比他低的到左边。
  2. 分好之后左侧的每个人也重复第一步，右侧也重复第一步。

  把大雄的身高为枢纽，如果下图中的紫色横线。每次从左右两侧找的不满足条件的，即在大雄左边却比大雄高，在大雄右边却比大雄低，交换两者，不断递归，最后有序。

2 形式化描述

2-1递归结构

  整体是函数递归的方式对序列L排序：
s o r t ( L ) = { s o r t ( { x ∣ x ∈ L ′ , x ≤ l 1 } ) ∪ { l 1 } ∪ s o r t ( { x ∣ x ∈ L ′ , x > l 1 } ) , L不空 ∅ , L为空集  sort(L) = \begin{cases} sort(\{ x| x\in L^\prime ,x \leq l_1 \} )\cup \{l_1\}\cup sort(\{x| x\in L^\prime ,x > l_1 \}), & \text{L不空} \\ \emptyset, & \text {L为空集 } \end{cases} sort(L)={sort({x∣x∈L′,x≤l1​})∪{l1​}∪sort({x∣x∈L′,x>l1​}),∅,​L不空L为空集 ​

  • l 1 l_1 l1​ 是上图的紫色横线，即分割点或枢纽pivot，通常取队列的第一个数据。注意，pivot的选择会直接影响到排序的效率。
  • L ′ L^\prime L′是队列去除枢纽值 l 1 l_1 l1​后的部分。
  • 比较条件为小于等于，即单调非递减的顺序排序。

  利用python 可以基本如上公式实现快速排序。

def sort(L):
	if L == []:
		return []
	pivot = L[0]
	aL = sort(filter(lambda x:x<=pivot,L[1:]))
	bL = sort(filter(lambda x:x >pivot,L[1:]))
	return aL+[pivot]+bL

  注意到，这里为了获得比枢纽pivot大的元素遍历了一次（filter），同样的为了获得比枢纽pivot小的元素又遍历了一次（filter），这个过程可以合并为一次划分过程，就是最上面图示里的交换。

2-2 一次划分

  对（Nico Lomuto提出的）划分方法说明具体可参照下图：

  • 选取最左边第一个元素 x l x_l xl​为枢纽pivot，当划分结束，pivot会被放到分界线位置，作为不大于pivot和大于它的枢纽。
  • 大于pivot的部分被显式的下标L,R所确定，即区间[L,R]内的元素都大于pivot，记为断言P。
  • 划分开始，L=R，即大于pivot的区间初始化为空集。之后，R向右移动，如果 x R > p i v o t x_R>pivot xR​>pivot即满足断言P故R继续向右移动；如果 x R ≤ p i v o t x_R\leq pivot xR​≤pivot，不满足断言P，需要将 x R x_R xR​移出区间[L,R]，具体来说就是交换 x L + 1 x_{L+1} xL+1​和 x R x_R xR​，即可保证[l,L)内的元素不大于pivot。
  • 划分结束时，L指向边界，需要把pivot和当前值交换，划分后即得到不大于枢纽的[l,L) 与大于枢纽的[L,r]。

  伪代码说明

function partitio(A,l,r):
	p = A[l] #枢纽pivot
	L = l		# 左侧标记
	for R from l+1 to r do # 迭代未处理的元素
		if not (p < A[R]) then
			L=L+1
			swap(A[L],A[R])
	swap(A[L],A[l])
	return L+1 #返回划分位置

2-3 C++实现

  代码将断言P封装为独立的函数，然后作为参数传入划分函数中。

#include<iostream>
#include<vector>
#include<functional> //函数指针包装

using namespace std;
using Array=vector<int>;
using Assertion=function<bool(int,int)>;

//断言 当前值大于枢纽
bool P(int now,int pivot){
    return pivot<now;
}

int partition(Array &A,int l,int r,Assertion P){
    int p=A[l];
    int L=l,R;
    for(R=l+1;R<=r;++R){
        if(!P(A[R],p)){ //不满足断言P需要交换
            ++L;
            swap(A[R],A[L]);
        }
    }
    swap(A[l],A[L]);
    return L+1;
}

void qsort(Array &A,int l,int r){
    if(l<r){
        int p=partition(A,l,r,P);
        qsort(A,l,p-1);
        qsort(A,p,r);//p是枢纽的下一个位置
    }
}

#define see(x) cout<<(x)<<endl
void test(){
    Array A{5,9,2,6,1};

    // test partition
    // see(partition(A,0,4));

    //test qsort
    qsort(A,0,A.size()-1);
    for(auto &x:A){
        see(x);
    }
}
int main(){
    test();
    return 0;
}

3 在工程中的改进

  考虑不同情况下的性能：

  1. 理想情况下，每次都能平均划分成差不多的两段，即分lgN次最后得到一棵平衡二叉树，N个单一元素为叶子，总处理时间O(N)；层层加起来，即O(NlgN)。
  2. 最坏情况下二叉树退化为链表，即 O ( N 2 ) O(N^2) O(N2)。
    • 其中一种情况是大部分元素都相同，上述的划分方法会对相同值也做无效交换，效率降低；
    • 或序列本来有序，因此每次划分得到左边（或右边）是空集，相当于无效划分。

3-1 处理重复元素

  如下图，把二分划分变为三分划分，将重复元素（即等于枢纽pivot）的值作为一个集合E。为方便理解三路划分的思路，需要先了解一下经典的双向划分作为基础。

双向划分

  再把开头的图拉上来，注意到红色双箭头表示有两个指针分别从当前段的头尾出发，向中间收缩，等找到一对儿违反断言X:左侧 ≤ \leq ≤ pivot < < <右侧的数据就交换左右的值。

// 注意 数组范围是A[l,r]
void qsort1(Array &A,int l,int r){
	int i,j,pivot;
	if(l<r-1){
		pivot=i=l;
		j=r+1;//为了凑下面形式一致用--j得到真实数据
		while(1){
            while(i<r && A[++i]<A[pivot]);
            while(j>=l && A[pivot]<A[--j]);
            if(i>j) break;
            swap(A[i],A[j]);
        }
        swap(A[pivot],A[j]);
        qsort1(A,l,j);
        qsort1(A,i,r);
    }
}

  极端情况下，所有数字都相同，会发生N/2次不必要的交换，因为划分是平衡的，故总体性能还是O(NlgN)。这里举一个划分一次的实际用来说明i、 pivot 、j实际的位置含义。注意到，这种划分跳过了本来就正确的元素2，不进行交换，比Nick Lomuto 提出的一次划分减少了交换次数。

  • 同色的气球发生了交换
  • 划分完成后，pivot并不在边界上
  • 注意到 j j j 最终在 i i i的左侧
#include<iostream>
#include<vector>
using namespace std;
using Array=vector<int>;

void qsort1(Array &A,int l,int r){
	int i,j,pivot;
	if(l<r-1){
		pivot=i=l;
		j=r+1;
		while(1){
            while(i<r && A[++i]<A[pivot]);
            while(j>=l && A[pivot]<A[--j]);
            if(i>j) break;
            //cout<<i<<" <--> "<<j<<endl;
            swap(A[i],A[j]);
        }
        //cout<<"final "<<pivot<<" "<<j<<endl;
        // for(auto& x:A){
        //   cout<<x<<" ";
        //}
        //cout<<endl;
        swap(A[pivot],A[j]);
        qsort1(A,l,j);
        qsort1(A,i,r);
    }
}
#define see(x) cout<<(x)<<endl
void test(){
    Array A{4,5,2,4,4,4,1,3};
    //test qsort
    qsort1(A,0,A.size()-1);
    for(auto &x:A){
        see(x);
    }
}
int main(){
    test();
    return 0;
}

三路划分

  如下图所示，三路划分有几个特点：

  1. i 和 j 指针和二路划分的动作相似，从两头向中间，寻找不满足断言Y:左侧 < < < pivot < < <右侧的一对 x i x_i xi​ 和 x j x_j xj​。
  2. 当 x i ≥ p i v o t x_i \geq pivot xi​≥pivot 并且 x j ≤ p i v o t x_j \leq pivot xj​≤pivot 时，有个分类讨论。
    - 当 i < j i < j i<j时，先交换 x j x_j xj​ 和 x i x_i xi​，否则退出。
    - 当存在某值等于 p i v o t pivot pivot，需要交换 s w a p ( x p , x i ) swap(x_p, x_i) swap(xp​,xi​)，或 s w a p ( x j , x q ) swap(x_j,x_q) swap(xj​,xq​)，保证等于pivot的元素在两边。
  3. 划分结束之前需要把所有等于pivot的元素从两边交换到中间，O(重复元素个数），之后对严格大于、严格小于的部分递归排序。

  伪代码说明：

# 数组A[l,r),r取不到
function Sort(A,l,r):
	if r-l >1 then # 至少有1个数据
		i=l, j=r
		p=l, q=r
		pivot= A[l] # 以上初始化
		loop
			# 先忽略下标检查
			repeat
				i=i+1
			until A[i]>= pivot
			repeat
				j=j-1
			until A[j]<= pivot # 以上寻找非断言Y的数据对

			if j<=i then # 注意，取等也要退出
				break
			swap(A[j],A[i])
			if A[i]==pivot then
				p=p+1
				swap(A[p],A[i])
			if A[j]==pivot then
				q= q -1
				swap(A[q],A[j])
		#loop end
		if i==j and A[i]==pivot then #特殊情况
			j= j-1, i=i+1
		
		# 移动到中间，注意此刻j在i的左边
		for k from l to p do
			swap(A[k],A[j])
			j=j-1
		for k from r-1 down-to q do
			swap(A[k],A[i])
			i=i+1
		
		Sort(A,l,j+1)
		Sort(A,i,r)

C++ 实现


void qsort2(Array A,int l,int r){
    // A[l,r)，注意r是取不到的
    int i, j, k, p, q, pivot;
    if (l < r - 1)
    {
        i = p = l;
        j = q = r;
        pivot = A[l];
        while (1)
        {
            while (i < r && A[++i] < pivot)
                ; //先检查下标
            while (j >= l && pivot < A[--j])
                ;

            if (j <= i)
                break;
            swap(A[i], A[j]);

            // 多了移动相同值
            if (A[i] == pivot)
            {
                ++p;
                swap(A[i], A[p]);
            }
            if (A[j] == pivot)
            {
                --q;
                swap(A[j], A[q]);
            }
        }
        // 确认j在i的左边
        if (i == j && A[i] == pivot)
        {
            --j;
            ++i;
        }
        for (k = l, k <= p; ++k, --j)
        {
            swap(A[k], A[j]);
        }
        for (k = u - 1; k >= q; --k, ++i)
        {
            swap(A[k], A[i]);
        }

        qsort2(A, l, j + 1);
        qsort2(A, i, r);
    }
}

3-2 最差情况的改进

  假定 x 1 x_1 x1​到 x n x_n xn​自然有序，最差情况：

  • 有序，还选取第一个数作为pivot，划分的结果总包含一个空集。
  • { x n , x 1 , x n − 1 , x 2 , . . . } \{x_n,x_1,x_{n-1},x_2,...\} {xn​,x1​,xn−1​,x2​,...}，重复的Z字形，选第一个做pivot还是补平衡，一边可能只有一个元素；
  • { x m , x m − 1 , . . . , x 1 , x m + 1 , x m + 2 , . . . , x n } \{x_m,x_{m-1},...,x_1,x_{m+1},x_{m+2},...,x_n\} {xm​,xm−1​,...,x1​,xm+1​,xm+2​,...,xn​}只有第一次平衡，其他都是不平衡的。

  可以发现问题出在对pivot的选择有局限性。怎么选择pivot来实现平衡的划分是一个关键。

三点中值法

  一种抽样的方法是检查，头，尾巴，中间的元素，然后选出其中的中位数作为pivot，即可保证最短序列至少有一个元素。

注意，计算中间值下标，用 L + R L+R L+R可能会溢出，建议用 L + ( R − L ) / 2 L+(R-L)/2 L+(R−L)/2。

  怎么求中位数呢？

  • 三次比较，ABC来确定
  • 交换方法，使得最小值在左边，中值在中间，大值在右边。
# 采用交换的方式来实现
function Sort(A,l,r):
	if r-l > 1 then
		m = (l+r)/2  # 小心溢出问题
		if A[m] < A[l] then # 保证 A[l]<=A[m]
			swap(A[l],A[m])
		if A[u-1]<A[l] then # 保证A[l]<=A[r-1]
			swap(A[l],A[u-1])  
		if A[r-1]<A[m] then # 保证 A[m]<=A[r-1]
		 	swap(A[m],A[r-1])
		swap(A[m],A[l])   # 把选出来的中值放到首个，默认作为partition函数枢纽
		(i,j) <- partition(A,l,r)
		Sort(A,l,i)
		Sort(A,j,r)

随机选择pivot

  很简单，就是随机选一个值和左边的第一个值交换。见命令式函数的伪代码描述：

# A[l,r) 末尾r取不到
function Sort(A,l,r)
	if r-l > 1 then
		swap(A[l],A[Random(l,r)]) # 随机选择元素，放到首位
		(i,j) = partition(A,l,r)
		Sort(A,l,i)
		Sort(A,j,r)

   注意到，纯函数式编程中，列表的底层是单向链表，没有简单的方法可以实现纯函数式的随机快速排序。

短序列切回插入排序

  这个更简单，因为Robert Sedgewick 观察到，当序列较短时，快速排序引入的额外代价比较明显，此时插入排序反而更快。即如果序列的元素个数少于Cut-Off 就转入插入排序。其中Cut-Off可以由对特定的数据做具体实验获得。

function Sort(A,l,r):
	if r-l >Cut-Off then
		Quick-Sort(A,l,r)
	else
		Insertion-Sort(A,l,r);

4 全部改进技术加持

  测试后可知，对int数当序列长度接近23左右时，插入排序更好，且该结果随着整体元素的变大而有所波动。

#include<iostream>
#include<vector>
#include<functional> //函数指针包装
#include<chrono> //测试运行时间
#include<ctime> // 随机数数组

using namespace std;

// 模拟模板类
using Key=int;
using Array=vector<Key>;
using Assertion=function<bool(int,int)>; //断言函数指针


// 用于测试运行的时间
using Time=chrono::steady_clock;
using Duration=chrono::duration<double>;
using SortFunc=function<void(Array&,int ,int)>; //排序的函数指针
double getRunTime(SortFunc run,Array &A,int l,int r){
    auto beforeTime = Time::now();
	run(A,l,r);
	auto afterTime = Time::now();
	// 运行多少秒
	return  Duration(afterTime - beforeTime).count();
}


class Sort
{
    // 默认A[l,r)右边界一律取不到；(r-l)即数组长度。
private:
    static const size_t CUT_OFF=24;
    static void get_pivot(Array &A, int l, int r);//三点中值法求pivot
public:
    static void insert_sort(Array &A,int l,int r);
    static void quick_sort(Array &A,int l,int r);
    static void sort(Array &A,int l,int r){
        if(r-l>CUT_OFF){
            quick_sort(A,l,r);
        }else{
            insert_sort(A,l,r);
        }
    }


};
// 三点中值法，并将中值放到A[l]，划分默认以A[l]为pivot
void Sort::get_pivot(Array &A, int l, int r){
    int m=l+(r-l)/2;
    if(A[m]<A[l]){   //保证A[l]<=A[m]
        swap(A[m],A[l]);
    }
    if(A[r-1]<A[l]){ //保证A[l]<=A[r-1]
        swap(A[r-1],A[l]);
    }
    if(A[r-1]<A[m]){ //保证A[m]<=A[r-1]
        swap(A[r-1],A[m]);
    }
    swap(A[l],A[m]);
}
//三路划分+三点中值法
void Sort::quick_sort(Array &A, int l, int r)
{
    // A[l,r)，注意r是取不到的
    int i, j, k, p, q, pivot;
    if (l < r - 1)
    {
        i = p = l;
        j = q = r;
        get_pivot(A,l,r);//三点中值法
        pivot = A[l];
        while (1)
        {
            while (i < r && A[++i] < pivot)
                ;
            while (j >= l && pivot < A[--j])
                ;

            if (j <= i)
                break;
            swap(A[i], A[j]);

            // 多了移动相同值
            if (A[i] == pivot)
            {
                ++p;
                swap(A[i], A[p]);
            }
            if (A[j] == pivot)
            {
                --q;
                swap(A[j], A[q]);
            }
        }
        // 包装j在i的左边
        if (i == j && A[i] == pivot)
        {
            --j;
            ++i;
        }
        for (k = l; k <= p; ++k, --j)
        {
            swap(A[k], A[j]);
        }
        for (k = r - 1; k >= q; --k, ++i)
        {
            swap(A[k], A[i]);
        }

        quick_sort(A, l, j + 1);
        quick_sort(A, i, r);
    }
}

void Sort::insert_sort(Array &A, int l, int r){
    if (r - l > 1)
    {
        for (int j = l + 1; j < r; j++)
        {
            int key = A[j];
            int i = j - 1;
            while (i >= 0 && A[i] > key)
            {
                A[i + 1] = A[i];
                i--;
            }
            A[i + 1] = key;
        }
    }
}

//生成范围在l~r的随机数 
void random_array(Array &A,int l,int r)
{
	srand(time(0));  //设置时间种子
	for(int i=0;i<A.size();i++){
		A[i]=rand()%(r-l+1)+l;
	}
}

// 用于测试真实的cut-off的值
void test_cutoff(size_t cutoff)
{
    //随机数组
    Array A(cutoff);
    const size_t MAX=992453499;
    random_array(A, 0, MAX);
    // 测时间
    Sort obj;
    auto insert_time = getRunTime(obj.insert_sort,A,0,A.size());
    auto qsort_time = getRunTime(obj.quick_sort,A,0,A.size());

    cout<<"MAX = "<<MAX <<" CUT-OFF = "<<cutoff<<" ";
    if(insert_time<qsort_time){
        cout<<"insert better"<<endl;
    }else{
        cout<<"qsort better"<<endl;
    }
} // MAX = 992453499 CUT-OFF = 24 insert better

#define see(x) cout<<(x)<<endl
void test(){
    Sort obj;
    Array A{4,5,2,4,4,4,1,3};
    obj.sort(A,0,A.size());  
    obj.insert_sort(A,0,A.size());
    obj.quick_sort(A,0,A.size());
    for(auto &x:A){
        see(x);
    }
}

int main(){
    test();
    // test_cutoff(24);
    return 0;
}
一即一切2120
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
一种快速并行中值滤波算法的实现
02-23
介针对传统中值滤波算法计算量大、耗时较长的缺点提出了一种快速并行中值滤波算法。对于3×3滑动窗口,窗口的9个数据是并行传给计算比较模块的,第二级的计算也是并行进行的。新算法有效减少了重复比较操作的执行...
论文研究-基于SystemGenerator的快速中值滤波算法设计与实现.pdf
07-22
该算法通过两次行、列排序将3×3窗口中9个像素取中值简化为3个像素的排序运算，使得单窗口查找中值的比较次数由传统排序算法的36次最少降到了14次。结合System Generator系统建模工具，将处理速度提升到传统方法的近...
三、排序_02 &快速排序 &快速排序的优化——三点中值法（笔记）
oQQSanGuo的博客
03-29 1051
先上代码 import java.util.Arrays; import java.util.Random; public class A008_快排的优化_1_三点中值法 { static int cnt = 0; public static void main(String[] args) { int len = 2000; int max = 1000000000; in...
快速排序（三数中值法）
折纸鹤
10-29 9657
 快速排序：快速排序的主要思想即是在待排序数组中找到一个枢纽元，作为参考将数组分为大于枢纽元与小于枢纽元两部分来处理，然后运用分治法的思想进行递归，在分出来的两部分中分别再取一个枢纽元进行参考作类似的处理。该算法的平均运行时间是O(NlogN),而最坏的情形时性能为O(N^2),由此可见该算法的性能取决于枢纽元的选取上，因此在此采用了三数中值法来对枢纽元进行选取，可以有效规避最坏的情形。 三...
快速排序及其优化（三数中值法）
af74776的专栏
06-02 3375
传统的快速排序法实现如下： def quickSort(L,left,right): if left>=right: return base=L[left] r=right l=left while left<right: while left<right and L[right]>=base: ...
快速排序之三数中值分割法
Vocsal12580的博客
06-30 5412
枢纽元：与其他数做大小比较作用，作为一个中间参考值。步骤：1.       通过选取第一个元素、最后一个元素和最中间一个元素的中间值作为枢纽元。2.       将枢纽元与最后一个元素交换位置。3.       i指向第一个元素，j指向倒数第二个元素（最后一个元素为枢纽元）。4.       i向右移直到i指向的元素大于等于枢纽元就停止移动。（跳过那些小于枢纽元的元素，这样就能保证比枢纽元小的元素...
【排序】快速排序
小米子的成长日记
07-18 781
对于C++，快速排序(quicksort)历史上一直是实践中已知最快的泛型排序算法，其平均运行时间是O(NlogN)。
快速排序--选取A[0]做主元，随机选取做主元，三点中值做主元
北枫凉的博客
03-29 449
代码实现以及现象分析 //北航机试2020/3/28 /* 头中尾三位取中 针对不同的数据量 */ #include<stdio.h> #include<stdlib.h> #include<time.h> #include<algorithm> using namespace std; #define MAXN 10000000 int...
三数中值法快速排序
CN_BIT的博客
03-18 2069
要求根据给定输入，按照课堂给定的快速排序算法进行排序。在划分时，以当前序列的首位元素、中间位置元素和最末元素的中间值为枢轴，记为median3。注意，如median3不在首尾，需要和首位元素交换位置。 要求输出排序结果和median3的返回值。 注：1,cutoff值为5，不足cutoff使用插入排序。 2,输入、输出格式参见测试用例0。 测试输入 ...
快速排序（三指取中法）
wender76的博客
03-12 970
快速排序（三指取中法） 排序是算法基础，也是每个学编程的人最早接触的算法之一，快速排序便是排序家族中的一员，其最坏情况O（n^2）,每次划分只能将要排序的序列分成一个元素与其他元素两部分，这时就变身为为冒泡排序，而三指取中法正是为了避免最坏情况存在的（上代码） #include<stdio.h> int swap(int a[],int l,int r) { int b =...
快速排序普通法与中值枢纽元法以及三切法
DanBoErNingJingYi的博客
01-10 1067
快速排序影响速度的一个因素便是枢纽元，在这里第一种方法为将第一个元素作为枢纽元，这样做有一个弊端，就是当顺序为逆序时或者大量重复的数时T(N) = O(N^2),方法一是中值枢纽法，即将第一个，中间的，和最后一个取中值，并将他们放在合适的位置，然后递归，这里有一点与普通法不同，i=left,j=right -1（中值法）;i = left,j=right+1(普通法)且在最后的交换也不同！还有一点
zhongzhi.rar_快速 中值_快速中值滤波
07-14
"zhongzhi.rar_快速 中值_快速中值滤波"这个压缩包可能包含了一个关于快速中值滤波算法的实现，包括代码文件（zhongzhi.asv和zhongzhi.m）以及一个测试图像（lenna.tif）。 中值滤波的基本原理是，对于图像中的每一...
基于C++的中值滤波（冒泡排序）设计与实现
05-13
基于C++的中值滤波（冒泡排序）设计与实现
快速中值滤波算法.rar
09-07
快速中值滤波是一种在数字图像处理领域广泛应用的非线性滤波技术，它能够有效去除图像中的椒盐噪声、斑点噪声等不规则干扰，同时保持图像边缘和细节的完整性。这种滤波方法的核心是将每个像素点的值替换为其周围像素...
C语言 之 理解指针（1）
fallzzzzz的博客
07-20 1235
就是先获取该数组的首元素的地址，从前面我们知道，指针的类型的作用是指针+1 所跳过的字节数，int为整形，大小为4个字节，所以p+1就跳过4个字节，p+2就跳过8个字节，计算机的CPU（中央处理器）在处理数据的时候，需要的数据是在内存中读取的，处理后数据也会放回内存中，如果想对这些空间进行高效的管理，就可以。并且我们知道，数组的元素存放是随着下标增长，内存地址变大的。上面的代码创建了一个整型变量n，因为一个整形的大小是4个字节，所以内存中申请了4个字节，⽤于存放整数10，其中每个字节都有地址。
用cmake创建一个c++工程，调用c语言函数打印“c hello!”。
最新发布
LW_12345的博客
07-26 234
添加语言类型：在project命令中指定项目支持C和C++语言。设置标准：在CMakeLists.txt中明确设置C和C++的标准。添加库：使用创建C语言库，并用将其链接到C++可执行文件。这样，CMake就能正确识别C语言源文件，并将其链接到C++项目中。
C++ primer plus 第16章string 类和标准模板库, 关联容器
zhyjhacker的博客
07-25 692
C++ primer plus 第16章string 类和标准模板库, 关联容器。
【C++修炼之路 第五章】string 类（补充）：string 扩展空间规律 + reserve 的缩容 + resize 的使用
唯有忍受别人不能忍受的，才能享受别人不能享受的
07-23 1143
【详细剖析】string 扩展空间规律 + reserve 的缩容性质与只改变capacity的性质 + resize 的使用 + shink_to_fit 的缩容函数
matlab 三点中值滤波
03-19
Matlab中的三点中值滤波是一种常用的图像处理方法，用于去除图像中的噪声。它通过对每个像素周围的邻域进行排序，并选择中间值作为该像素的新值来实现滤波。 三点中值滤波的步骤如下： 1. 对于图像中的每个像素，选择一个3x3的邻域。 2. 将邻域中的所有像素值进行排序。 3. 选择排序后的中间值作为该像素的新值。 4. 重复以上步骤，直到对整个图像完成滤波。 三点中值滤波可以有效地去除图像中的椒盐噪声和其他类型的噪声，同时保持图像的边缘信息。它在图像处理和计算机视觉领域广泛应用。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值