常见排序算法c++实现

最新推荐文章于 2022-08-27 12:02:50 发布
最新推荐文章于 2022-08-27 12:02:50 发布
阅读量337 收藏 2
点赞数 1
分类专栏： 编程 文章标签： 排序算法 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33278461/article/details/80738912
版权
排序算法分类：

比较排序，：冒泡排序，鸡尾酒排序，选择排序，插入排序，归并排序，堆排序，快速排序，希尔排序。
非比较排序：计数排序，基数排序，桶排序等。

排序算法稳定性：

如果Ai = Aj，排序前Ai在Aj之前，排序后Ai还在Aj之前，就是稳定的。

排序算法复杂度：
排序算法最坏时间复杂度最好时间复杂度平均时间复杂度空间复杂度是否稳定
冒泡排序O(n^2)O(n)O(n^2)O(1)稳定
选择排序O(n^2)O(nlogn)O(n^2)O(1)不稳定
直接插入排序O(n^2)O(n)O(n^2)O(1)稳定
归并排序O(nlogn)O(nlogn)O(nlogn)O(n)稳定
快速排序O(n^2)O(nlogn)O(nlogn)O(logn)不稳定
堆排序O(nlogn)O(nlogn)O(nlogn)O(1)不稳定
希尔排序O(n^2)O(n^1.3)O(nlogn)O(1)不稳定
桶排序O(n^2)O(n^2)O(n+k)O(n+k)稳定
计数排序O(n+k)O(n+k)O(n+k)O(n+k)稳定
基数排序O(N∗M)O(N∗M)O(N∗M)O(M)稳定

希尔排序的时间复杂度是：O(nlogn)～O(n ^ 2 ) ，最好情况是O(n ^1.3), 与序列选择有关。

简单描述：有时间在补充例子吧，来自自己的弱智笔记…

1.冒泡排序：
从头到尾依次比较相邻两个元素，Ai和Aj，如果Ai大于Aj，交换两个元素，所以每次都有一个元素放到最终位置。遍历一轮以后再从第一个元素开始，可以设置一个标志，如果某轮次没有交换，则停止，表明排序结束。

2.鸡尾酒排序：
其实和冒泡排序思想一样，只不过每次交换遍历方向，先从左往右找大的交换最后放到最右，然后从右往左返回，找最小的交换，一直到最左。

2.简单选择排序：
每次从其余元素的头到尾遍历寻找一个最小的元素放到最前。也是每次遍历都有一个元素放到最终位置。

3.直接插入排序
从左往右每次用当前元素和前面所有元素依次比较，如果前一个更大，就把它后移，一直到小于等于它的时候放入那个位置。

4.折半插入排序
直接插入排序的时候，用折半查找的方法找插入位置。

5.希尔排序：
就是分组直接插入，比如8个元素，设置一个间隔8/2=4，每隔4个元素一组，然后每隔4/2=2个元素一组，每次都是进行直接插入排序

6.快速排序：
基于分治的思想，设置两个指针，找一个元素(比如最后一个)作为中间元素，然后从头找大于这个元素的交换到最右，然后在从后往前找小于这个元素的交换到左面，最后位置放入这个中间元素，中间元素位置就是它的最终位置，左面元素都小于它，右面元素都大于它。然后左面和后面元素再分别重复刚才步骤。

7.归并排序：
把数字分组，每组排序再合并，继续排序。比如8个元素，先分成4组，每组排序，在合并为2组排序，最后合并在一起排序。

8.计数排序：
当输入的元素是 n 个 0到 k之间的整数时，可以用计数排序。计数排序不是基于比较的，排序的速度快于任何比较排序算法。
思想是，先统计数组里最大最小值，然后统计每个元素数目存入hash数组，然hash数组每个元素等于前一个元素加当前元素，其实就是求该元素的真实位置。然后创建新数组填充元素，某个元素填充一次后要ct–.
以上做法有一些问题：空间复杂度大，排序不稳定。
步骤：
1)遍历找出待排序的数组中最大和最小的元素(max和min)，创建hash数据大小为max-min+1(解决空间复杂度问题)；
2)统计每个元素出现的次数，数目存入hash数组的，(注意位置，如果大小为max-min+1需要换算)；
3.对所有的计数累加（从hash中的第一个元素开始，每一项和前一项相加），这样可以统计实际位置，比如0出现5次，1出现2次，此时hash[0]=5, hash[1]=2，更新为hash[0]=5,hash[1]=7； (保证稳定性)
4.反向填充目标数组(保存排序完元素的数组)：将每个元素i放在新数组的第hash[i]项，每放一个 元素就将hash[i]减去1 ； (保证稳定性)

计数排序的时间复杂度为 O(N+K)。因为算法过程中需要申请一个额外空间和一个与待排序集合大小相同的已排序空间，所以空间复杂度为 O(N+K)。由此可知，计数排序只适用于元素值较为集中的情况，若集合中存在最大最小元素值相差甚远的情况，则计数排序开销较大、性能较差。

9.桶排序
数据分布比较均匀的时候可以用，比如范围0到n的k个数字，把数字划分成k/n个部分，每部分是一个桶，数字映射到自己属于的范围的桶里，每个桶进行排序，然后合并即为排序数组。
桶排序是把数据划分到不同桶里单独排序即可，相当于hash了几个桶在排序；归并排序是直接分成几个小组，合并在排序，再合并在排序。

10.基数排序：
是一种非比较排序算法，时间复杂度是 O(n) ，是桶排序的扩展，将整数按位数切割成不同的数字，然后按每个位数分别比较。位数不够的前面补0.
比如3位数，先按照个位数排序，在按照十位数排序，最后按照百位数排序。

some code：code也不全，有时间在写吧…
#include<bits/stdc++.h>
using namespace std;
/*
2018.6.18  oder
*/
void swap(int i,int j,vector<int>&nums){
	int temp=nums[i];
	nums[i]=nums[j];
	nums[j]=temp;
}
//1.冒泡排序
vector<int>bubble_sort(vector<int>nums){
	for(int i=0;i<nums.size();++i){
		int flag=0;//标记用来记录当前循环是否交换了元素，如果没交换就说明已经排好序 
		for(int j=0;j<nums.size()-i-1;++j){//已经确定位置的就不用遍历了 
			if(nums[j]>nums[j+1]){
				int temp=nums[j+1];
				nums[j+1]=nums[j];
				nums[j]=temp;
				flag=1;
			}
		}
		if(flag==0){
			break;
		}
	}
	return nums;
}
//2.鸡尾酒排序 
vector<int>cocktail_sort(vector<int>nums){
	int left=0;
	int right=nums.size()-1;//右面下标是数组长-1 
	while(left<right){//从左往右遍历 
	    int flag=0;//标记，如果没发生交换则说明已经有序 
		for(int i=0;i<right;++i){//从左到右遍历 
			if(nums[i]>nums[i+1]){
				swap(i,i+1,nums);
				flag=1; 
			}
		}
		right--;//最大元素已经放到最右，right-- 
		for(int i=right;i>left;--i){//从右到左遍历 
			if(nums[i]<nums[i-1]){
				swap(i,i-1,nums);
				flag=1;
			}
		}
		left++;//最小元素已经放到最左，left++ 
		if(flag==0){
			break;
		}
	}
	return nums;
}
//3.简单选择排序
vector<int>selection_sort(vector<int>nums){
	for(int i=0;i<nums.size()-1;++i){
		int min=i;
		for(int j=i+1;j<nums.size();++j){
			if(nums[j]<nums[min]){
				min=j;
			}
		}	
		if(min!=i){
			swap(i,min,nums);
		}
	}
	return nums; 
} 

//4.直接插入排序 
vector<int>insertion_sort(vector<int>nums){
	for(int i=1;i<nums.size();++i){
		int now=nums[i];
		int j=i-1;
		while(j>=0&&nums[j]>now){//如果大于当前数字，则把后移 
			nums[j+1]=nums[j];
			--j;
		}
		nums[j+1]=now;
	}
	return nums;
} 
//5.折半插入排序
vector<int> binary_insertion_sort(vector<int>nums){
	for(int i=1;i<nums.size();++i){
		int left=0;
		int right=i-1; 
		int now =nums[i]; 
		while(left<=right){//找到要插入的位置 
			int mid=(left+right)/2;
			if(nums[mid]>now){
				right=mid-1;
			}else{
				left=mid+1;
			}
		}
		for(int j=i-1;j>=left;--j){//把要插入位置后和之后所有数向后移动一位 
			nums[j+1]=nums[j];
		}
		nums[left]=now;
	} 
	return nums;
}
//6.快速排序
//两种partition都可以
int partition(int left,int right,vector<int>&nums){
	int pivot =nums[right];
	while(left<right){
		while(left<right&&nums[left]<=pivot){//从左往右找大于中心元素的 
			++left;
		}
		swap(left,right,nums);
		while(left<right&&nums[right]>=pivot){//从右往左找小于中心元素的 
			--right;
		}
		swap(left,right,nums); 
	} 
	return left;
} 
int partition(int left,int right,vector<int>&nums){
	int pivot =nums[right];
	while(left<right){
		while(left<right&&nums[left]<=pivot){//从左往右找大于中心元素的
			++left;
		}
		nums[right]=nums[left];
		while(left<right&&nums[right]>=pivot){//从右往左找小于中心元素的
			--right;
		}
		nums[left]=nums[right];
	}
	nums[left]=pivot;
	return left;
}
//递归实现
void quick_sort(int left,int right,vector<int>&nums){
	if(left>=right){
		return;
	}
	int pivot_index=partition(left,right,nums);//找中间元素索引
	quick_sort(left,pivot_index-1,nums);//左半部分快排
	quick_sort(pivot_index+1,right,nums);//右半部分快排
}
//非递归实现，用栈，每次入栈的是某一段的left和right，这样一段一段排序
void quick_sort(vector<int>&nums){
    stack<int>s;
    s.push(0);
    s.push(nums.size()-1);
    cout<<nums.size()<<endl;
    while(!s.empty()){
        int right=s.top();
        s.pop();
        int left=s.top();
        s.pop();
        int mid = partition(nums,left,right);
        for(int i=0;i<nums.size();++i)
            cout<<nums[i]<<" ";
        cout<<endl;
        cout<<mid<<endl;
        if(mid>left+1){
            s.push(left);
            s.push(mid-1);
        }

        if(mid<right-1){
            s.push(mid+1);
            s.push(right);
        }
    }
}
//7.希尔排序，就是分组直接插入，元素之间的距离是gap而不再是1 
vector<int>shell_sort(vector<int>nums){
	for(int gap=nums.size()/2;gap>=1;gap/=2){//分组距离每次除2 
		for(int i=gap;i<nums.size();++i){
			int j=i;
			while(j-gap>=0&&nums[j]<nums[j-gap]){
				swap(j,j-gap,nums);
				j=j-gap;
			}
		}
	}  
	return nums;
}
//8.计数排序
vector<int> count_sort(vector<int>&nums,int &k){
    vector<int>ct(k,0); //可以不从0开始，因为空间浪费，比如数组从97-120，则可以设置max-min+1的数组大小，第一个位置保存97
    for(int i=0;i<nums.size();++i){//初始化计数数组并统计次数
        ct[nums[i]]++;
    }
    for(int i=1;i<ct.size();++i){//更新计数数组，可以表示元素位置
        ct[i]+=ct[i-1];
        cout<<ct[i]<<" ";
    }
    cout<<endl;
    vector<int>new_nums(nums.size());
    for(int i=ct.size(); i>0; i--){//根据元素位置生成新的有序数组，逆向遍历源数组（保证稳定性），根据计数数组中对应的值填充到先的数组中   
        new_nums[ct[nums[i]]-1]=nums[i];
        --ct[nums[i]];
    }
    return new_nums;
}
//9.桶排序
 vector<int> bucket_sort(vector<int>&nums){
     vector<int>res;
    int n_min=0x7fffffff;
    int n_max=0x80000000;
    for(int i=0;i<nums.size();++i){
        n_max=max(n_max,nums[i]);
        n_min=min(n_min,nums[i]);
    }
    //cout<<"min: "<<n_min<<endl;
    //cout<<"max: "<<n_max<<endl;
    int ct_per_bucket=(n_max-n_min)/nums.size()+1;//nums分配成若干份
    //cout<<"ct_per_bucket: "<<ct_per_bucket<<endl;
    vector<vector<int> >bucket(ct_per_bucket,vector<int>(0));//外层是每个桶
    for(int i=0;i<nums.size();++i){
        int num=(nums[i]-n_min)/nums.size();
        //cout<<nums[i]<<" ";
        bucket[num].push_back(nums[i]);
    }
    //cout<<"sort: ";
    for(int i=0;i<bucket.size();++i){
        sort(bucket[i].begin(),bucket[i].end());
        /*for(int j=0;j<bucket[i].size();++j)
            cout<<bucket[i][j]<<" ";*/
        res.insert(res.end(), bucket[i].begin(), bucket[i].end());
    }
    return res;
}
//10.归并排序
void _merge(vector<int>&data,int left,int mid, int right){
    vector<int> temp(right-left+1);
    int i=left,j=mid+1,k=0;
    while(i<=mid&&j<=right){
        /*
        if(data[i]>data[j]){
            temp[k++]=data[i++];
        }else{
            temp[k++]=data[j++];
        }*/
        if(data[i]>data[j]){
            temp[k++]=data[j++];
        }else{
            temp[k++]=data[i++];
        }
    }
    while(i<=mid){
        temp[k++]=data[i++];
    }
    while(j<=right){
        temp[k++]=data[j++];
    }
    k=0;
    for(int i=left;i<=right;++i){
        data[i]=temp[k++];
    }
}
void merge_sort(vector<int>&data,int left,int right){
    if(left>=right)
        return;
    int mid=(left+right)/2;
    merge_sort(data,left,mid);
    merge_sort(data,mid+1,right);
    _merge(data, left, mid, right);
}


int main(){
	int n;
	//cin>>n;//n number;7
	 3 4 1 9 6 2 5 8 
    vector<int>nums={7,3,4,1,9,6,2,5,8};
    vector<int>res; 
	/*while(n--){
		int now;
		cin>>now;
		nums.push_back(now);
	} */
	//res=Bubble_Sort(nums);
	//res=Cocktail_sort(nums);
	//res= selection_sort(nums);
	//res=insertion_sort(nums);
	//merge_sort(nums,0,nums.size()-1);
	/*quick_sort(0,nums.size()-1,nums);
	res=nums;*/
	res=binary_insertion_sort(nums); 
	//res=shell_sort(nums);
	for(int i=0;i<nums.size();++i){
		cout<<res[i]<<" ";
	}
	cout<<endl;
	return 0;
}
 
 //11.三路快排
/*
思想其实就是拿第一个当pivot，设置三个指针lt=l、i=l+1、rt=r+1,每次比较arr[i]和arr[lt]，arr[i]小于arr[lt]就swap(arr[i],arr[lt+1])，i++,lt++；
如果大于就swap(arr[i],arr[rt-1])，lt--;等于就i++；
思想就是每次i跟pivot比，把小于的放最左可放位置lt+1，此时lt++，i++，可放位置和比较的都往后顺延；
如果大于就把它放到最后，此时最后的数交换了过来，这个数还没判断，所以不进行i++，只进行rt--。
最后lt位置的数小于pivot，交换它和pivot，会在中间留下等于pivot的数的连续序列，在递归l到lt-1和rt到r。

*/
void quicksort3(vector<int>nums, int l, int r){
    int lt = l;
    int rt = r+1;
    int i = l+1;
    int pivot = nums[l];
    while(i<rt){
        if(nums[i] < pivot){
            swap(nums[i], nums[lt+1]);
            lt++;
            i++;
        }else if(nums[i] > pivot){
            swap(nums[i], nums[rt-1]);
            rt--;
        }else{
            i++;
        }
    }
    swap(nums[l], nums[lt]);//因为第一个元素是pivot，把他和最后一个小于pivot的数交换，
    quicksort(nums, l, lt-1);//因为lt是pivot，所以l到lt-1
    quicksort(nums, rt, r);
}
//12.三路快排2
template <typename Item>
void quick_sort(Item a[], int left, int right) {
  	if (right-left < M) // prevent little array recursion
  		 return;
  // median-of-three
	compare_exchange(a[left], a[(left+right)/2]);
    compare_exchange(a[left], a[right]);
    compare_exchange(a[right], a[(left+right)/2]);

  // three-way-partition

    Item v = a[right];

    int i = left-1, p = left-1, j = right, q = right;

    for (;;) {
        while (a[++i] < v) {}
        while (a[--j] > v)
        if (j == left)
            break;
        if (i >= j)
            break;
        exchange(a[i], a[j]);
        if (a[i] == v)
        exchange(a[++p], a[i]);
        if (a[j] == v)
        exchange(a[--q], a[j]);
    }
    exchange(a[i], a[right]);
  // move equal elements to middle of array
    j = i-1;
    i = i+1;

    int k;
    for (k = left; k <= p && j > p; ++k, --j)
        exchange(a[k], a[j]);
    j -= p-k+1;
    for (k = right-1; k >= q && i < q; --k, ++i)
        exchange(a[k], a[i]);
    i += k-q+1;
    quick_sort(a, left, j);
    quick_sort(a, i, right);
}

//13.堆排序
/*
几个函数：
1.adj_max_heap调整堆函数，从i开始，跟他的儿子结点比较找一个最大的索引largest，如果是i，不操作；
  不是i，和i交换位置，并递归调用从largest开始继续调整
2.build_heap建堆函数，  从len/2开始到0的位置调整堆，for(int i=len/2;i>0;--i)，其实就是最后一个非叶子结点开始。
3.heap_sort堆排序函数，首先要建堆，然后遍历所有元素，依次把第一个元素交换到最后，len--，这个时候从第一个元素调整堆，只不过长度-1了，这个时候最后的位置保存的就是最大或者最小的元素。
其实大顶堆排序完是升序，最大的放最后，小顶堆相反。
步骤：
0.把数据表示为完全二叉树，数组元素本来就可以表示为完全二叉树，用下标结点i的左儿子为2*i，右儿子为2*i+1，根节点为1
1.建堆，此时需要让每个父节点的数值 > 左右儿子节点；从倒数第一个父节点(length/2)开始调整，一直调整到根节点，在调整过程中如果最大值是父节点则不需要操作，如果最大值是儿子节点2*i，则需要和父节点交换数值，再以交换上来的那个儿子节点位置2*i为父节点继续往下调整；
2.排序，调整完的堆最大值一定在根节点，此时把他交换到最后一个节点位置，length--，在从根节点调整堆(注意此时的length已经不包含最后一个节点)，重复操作，则把数组调整为升序。
*/
void adj_max_heap(int *datas, int length,int i){
    int left,right,largest;
    int temp;
    left=2*i;
    right=2*i+1;
    if(left<=length&&datas[left]>datas[i]){
        largest=left;
    }else{
        largest=i;
    }
    if(right<=length&&datas[right]>datas[largest]){
        largest=right;
    }
    if(largest!=i){
        temp=datas[i];
        datas[i]=datas[largest];
        datas[largest]=temp;
        adj_max_heap(datas,length,largest);
    }
}
void build_heap(int *datas, int length){
    //int i;
    for(int i=len/2;i>0;--i){
        adj_max_heap(datas,length,i);
    }
}
void heap_sort(int *datas, int length){
    build_heap(datas,length);//建堆
    int i=length,temp;
    while(i>1){
        temp=datas[i];
        datas[i]=datas[1];
        datas[1]=datas[i];
        adj_max_heap(datas,i-1,1);
    }
}
//14.链表快排
//也是找中间的pivot，但是partition的时候，pivot=left->val，p和q的指针，从头往后遍历，
//q<pivot的时候就交换q和p的数值
ListNode* sortList(ListNode* head) {
        if(head==nullptr||head->next==nullptr)
            return head;
        /*ListNode* end=head;
        while(end->next)
            end=end->next;*/
        Quick_sort(head, nullptr);
        return head;
    }
    
    void Quick_sort(ListNode* begin,ListNode* end){
        if(begin==end)
            return;
        ListNode * mid = partition(begin, end);
        Quick_sort(begin, mid);
        Quick_sort(mid->next, end);
        
    }
    ListNode* partition(ListNode* begin, ListNode* end){
        int pivot = begin->val;
        ListNode * p = begin;
        ListNode * q = begin->next;
        while(q!=end){
            if(q->val<pivot){
                p=p->next;
                swap(q->val,p->val);
            }
            q=q->next;
                
        }
        swap(p->val,begin->val);//把最后一个<pivot的数放到最前(和pivot交换)
        return p;
    }
星落秋风五丈原
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
经典排序算法C++全实现：插入、选择、冒泡、快排、归并、基数，堆排、希尔...
湫一
09-28 646
以下代码是个人学习排序算法的一些实践，实现了大部分排序算法的升序版本，并且对每一种算法进行了简要的介绍和复杂度分析。 涉及的算法如下： 插入排序：直接插入排序、折半插入排序、希尔排序 交换排序：冒泡排序、快速排序 选择排序：简单选择排序、堆排序 其他类型：归并排序、基数排序 #include <iostream> #include <string> #include &...
信息学奥赛一本通C++语言——1188：菲波那契数列(2)
子航OIer
04-02 1721
【题目描述】 菲波那契数列是指这样的数列: 数列的第一个和第二个数都为1，接下来每个数都等于前面2个数之和。 给出一个正整数a，要求菲波那契数列中第a个数对1000取模的结果是多少。 【输入】 第1行是测试数据的组数n，后面跟着n行输入。每组测试数据占1行，包括一个正整数a(1 ≤ a ≤ 1000000)。 【输出】 n行，每行输出对应一个输入。输出应是一个正整数，为菲波那契数列中第a个数对10...
[源码和文档分享]基于C++的9种排序算法的实现与比较
qq_38474647的博客
12-11 191
一、使用说明 1.1 项目简介 随机函数产生10000个随机数，用快速排序，直接插入排序，冒泡排序，直接选择排序的排序方法排序，并统计每种排序所花费的排序时间和交换次数。其中，随机数的个数由用户定义，系统产生随机数，并且显示他们的比较次数，排序算法包括冒泡排序，直接选择排序，直接插入排序，希尔排序，快速排序，堆排序，归并排序，基数排序，折半插入...
c++语言编程希尔排序法排序,C++实现八个常用的排序算法：插入排序、冒泡排序、选择排序、希尔排序等...
weixin_33474071的博客
05-18 178
本文实现了八个常用的排序算法：插入排序、冒泡排序、选择排序、希尔排序 、快速排序、归并排序、堆排序和LST基数排序首先是算法实现文件Sort.h，代码如下：/** 实现了八个常用的排序算法：插入排序、冒泡排序、选择排序、希尔排序* 以及快速排序、归并排序、堆排序和LST基数排序* @author gkh178*/#include templatevoid swap_value(T &a,T...
【算法】1. C++实现排序算法（附完整代码）（冒泡排序、选择排序、插入排序、快速排序、希尔排序、归并排序、堆排序、计数排序、基数排序、桶排序）
瞌睡的博客
12-11 1234
希尔排序的思想是采用插入排序的方法，先让数组中任意间隔为 h 的元素有序，刚开始 h 的大小可以是h = n / 2,接着让 h = n / 4，让 h 一直缩小，当 h = 1 时，也就是此时数组中任意间隔为1的元素有序，此时的数组就是有序的了。通过递归的方式将一个大的数组一直分割，分割到数组的大小为 1，此时只有一个元素，那么该数组就是有序的了，之后再把两个数组大小为1的合并成一个大小为2的，再把两个大小为2的合并成4的 …插入排序是在一个已经有序的小序列的基础上，一次插入一个元素。
C++实现冒泡排序、选择排序、插入排序、希尔排序、堆排序、归并排序、快速排序
weixin_44520881的博客
07-07 817
总结记录一下，C++实现各种排序算法，加深理解。参考《大话数据结构》
常见排序算法C++实现
01-23
在编程领域，排序算法是数据结构与算法学习中的基础部分，尤其在C++这样的系统级编程语言中，理解和掌握各种排序算法的实现至关重要。这里我们将深入探讨标题中提到的五种排序算法——归并排序、快速排序、希尔排序...
C++实现常用排序算法
07-15
本文将深入探讨C++实现的几种常见排序算法：冒泡排序、选择排序、插入排序、归并排序、快速排序以及堆排序。 1. **冒泡排序**： 冒泡排序是一种简单的排序算法，它重复地遍历待排序的数列，一次比较两个元素，如果...
C++实现各种排序算法.zip
最新发布
10-10
本资料包"**C++实现各种排序算法.zip**"提供了C++语言实现的多种排序算法，这对我们深入理解和运用这些算法具有重要意义。 首先，让我们探讨一下**排序算法**的基本概念。排序是指将一组数据按照特定顺序排列的过程...
c++排序算法个人总结
悟叭鸽
05-25 9149
/* 排序算法总结 ①Selection Sort （选择排序) ②Merge Sort（归并排序） ③Quick Sort（快速排序） ④Bubble Sort（冒泡排序） ⑤Insertion Sort（插入排序） ⑥Radix Sort（基数排序) ⑦Count Sort (计数排序) --------------------------Cxk 2019.1.2...
排序算法总结
qq_41269155的博客
10-20 229
排序算法总结 排序是对一串元素按关键字进行有序的排列。其中排序算法有很多种，常见的有冒泡排序、快速排序、希尔排序、堆排序、直接选择排序、基数排序、直接插入排序、折半插入排序、归并排序。 当中快速排序、希尔排序、堆排序、直接选择排序不是稳定的排序算法 而基数排序、冒泡排序、直接插入排序、折半插入排序、归并排序是稳定的排序算法。 当中快速排序、希尔排序、堆排序、直接选择排序、冒泡排序、直接插入排序、归并排序是比较排序，计数排序、桶排序、基数排序是非比较排序。 一、冒泡排序 1、概念：冒泡排序就是把数字小的经过交
C++数组求和两种方法
sss_114514_bbb的博客
08-27 6541
一个简单的程序（第一个函数中a是范围，不能超出b的有效索引）
数据结构各种排序算法C++实现
onlyone__的博客
09-30 525
数据结构各种排序算法C++实现 包含了直接插入排序，折半插入排序，希尔排序，冒泡排序，快速排序，选择排序，归并排序，这几种排序的算法实现。堆排序和基数排序没写，觉的代码实现起来有点难，明白了思路但是没写。哈哈哈！ 代码： #include <stdlib.h> #include <iostream> using namespace std; #define MAXSIZE 100 //顺序表大小，即为一共能存储的记录数（数据） typedef struct{ //元素只有一
各大排序算法C++代码实现
zpznba的博客
03-12 463
排序算法分类 排序算法比较表格 注： 1 归并排序可以通过手摇算法将空间复杂度降到O（1），但是时间复杂度会提高。 2 基数排序时间复杂度为O（N*M），其中N为数据个数，M为数据位数。 辅助记忆 ---- 时间复杂度记忆- 冒泡、选择、直接 排序需要两个for循环，每次只关注一个元素，平均时间复杂度为O()O()（一遍找元素O(n)O(n)，一遍找位置O(n)O(n)...
C语言_数据结构：随机10000个数字，进行所学的各种排序（八大排序）
qq_39112175的博客
07-02 1万+
C语言_数据结构：随机10000个数字，进行所学的8（9）大排序 题目： 由计算机生成10000个整数，使用所学几种排序算法进行排序，统计排序所用的时间，分析各种排序的性能。 创建数组 //创建数组 int *CreatArray() { int *arr = (int*)malloc(sizeof(int)*MAX); srand((unsigned int)time(NULL)); for (int i = 0; i < MAX; i++) { int randNum = ran
C++ 几种常用排序算法讲解
热门推荐
DreamerZhang的专栏
06-06 2万+
一、冒泡法 排序算法，大家用过或者写得最多就是冒泡算法了吧，就是临近的数字两两比较，用两层循环来比较。这样，第一趟（外循环）完后最小或者最大的值就到了最前面，形象点就是小泡泡浮了起来。这个不用多介绍了，直接上代码： void maoPaoSort(int array[]){ for (int i = 0; i < N-1; i++){ for (int j = 0; j < N; j++
C++三种排序方法
weixin_42403703的博客
07-19 4900
C++三种排序算法汇总（选择排序法、冒泡排序法、快速排序法） 目的：重温并记录 选择排序 在要排序的一组数中，选出最小的一个数与第一个位置的数交换； 然后在剩下的数当中再找最小的与第二个位置的数交换，如此循环 到倒数第二个数和最后一个数比较为止。 选择排序是不稳定的。算法复杂度 O(n2)–[n 的平方] //选择排序——从小到大 void ChoseSort(double a[],int n) ...
python常用编写格式和规范
qq_33278461的博客
06-06 1万+
0.目录格式 列举了几种常用写法，深度学习各种模型常用3中方法， #1: VIS/ |-- bin/ | |-- vis | |-- vis/ | |-- tests/ | | |-- __init__.py | | |-- test_main.py | | | |-- __init__.py | |-- main.py | |-- docs/ | |-- ...
计算组合数python实现
qq_33278461的博客
04-27 9887
组合数 1.阶乘的写法 Cnm=AnmAmm=n!(n−m)!∗1m!C_n^m=\frac{A_n^m}{A_m^m}=\frac{n!}{(n-m)!}*\frac{1}{m!}Cnm​=Amm​Anm​​=(n−m)!n!​∗m!1​ # import math # math.factorial() ，math里也自带了阶乘函数 def factorial(n): res = 1 ...
C++实现常见算法：排序方法详解
本资源包含了四种常见的排序算法，分别是：直接插入排序、希尔排序、选择排序和冒泡排序，以及归并排序。这些排序算法在实际编程中具有重要的应用价值，因为它们是数据处理和算法设计的基础。 1. **直接插入排序**:...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值