排序算法实现

最新推荐文章于 2024-08-05 20:49:33 发布
最新推荐文章于 2024-08-05 20:49:33 发布
阅读量203 收藏 1
点赞数
分类专栏： 排序算法 文章标签： 算法 pivot algorithm null
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/feige200923435436546/article/details/6843473
版权

参考文献：Data Structures and Algorithm Analysis Weiss 2rd Edition 

快速排序：

#include <stdio.h>
#include <iostream.h>
#include <string.h>
#include<stdlib.h>
#include<assert.h>
#include <algorithm>
#include <vector>
using   namespace   std;
//字符串拷贝函数
char* Strcpy(char* des,const char* src)
{
	assert((des!=NULL)&&(src!=NULL));
	char* temp = des;
	while((*des++=*src++)!='\0'){}
	return temp;
}

//快速排序算法
#define CUTOFF (4)
void InsertionSort(int a[],int N)
{
	int j,P;
	int temp;
	for(P=1;P<N;P++){
		temp = a[P];
		for(j=P;j>0 && a[j-1]>temp;j--){
			a[j] = a[j-1];
		}
		a[j]=temp;
	}
}
int Median(int a[],int Left,int Right)
{
	int Center = (Left+Right)/2;
	if(a[Left] > a[Center])	swap(a[Left],a[Center]);
	if(a[Left] > a[Right])	swap(a[Left],a[Right]);
	if(a[Center] > a[Right])	return a[Right];
	else{
		swap(a[Center],a[Right]);
		return a[Right];
	}
	
}
void QSort(int a[],int Left,int Right)
{
	if(Left+CUTOFF<=Right){
		int Pivot = Median(a,Left,Right);
		int i = Left,j=Right-1;
		for(;;){
			while(a[i++]<Pivot){}
			while(a[j--]>Pivot){}
			if(--i < ++j)	swap(a[i],a[j]);
			else break;
		}
		swap(a[i],a[Right]);
		QSort(a,Left,i-1);
		QSort(a,i+1,Right);
	}
	else InsertionSort(a+Left,Right-Left+1);
}
void QuickSort(int a[],int N)
{
	QSort(a,0,N-1);
}
void main(void)
{
	int A[] = {9,-345,3234,9,-23,54,49,12,23,-35,932,987,23455};
	QuickSort(A,13);
	for(int i= 0; i<13; i++){
		printf("%d ",A[i]);
	}
	printf("\n");
}





#include <stdio.h>
#include <iostream.h>
#include <string.h>
#include <stdlib.h>
#include <assert.h>
#include <algorithm>
#include <vector>
using   namespace   std;

//快速排序算法
#define CUTOFF (4)
void InsertionSort(int a[],int N)	//插入排序
{
	int j,P;
	int temp;
	for(P=1;P<N;P++){
		temp = a[P];
		for(j=P;j>0 && a[j-1]>temp;j--){
			a[j] = a[j-1];
		}
		a[j]=temp;
	}
}
int Median(int a[],int Left,int Right)
{
	int Center = (Left+Right)/2;
	if(a[Left] > a[Center])	swap(a[Left],a[Center]);
	if(a[Left] > a[Right])	swap(a[Left],a[Right]);
	if(a[Center] > a[Right])	return a[Right];
	else{
		swap(a[Center],a[Right]);
		return a[Right];
	}
	
}
void QSort(int a[],int Left,int Right)
{
	if(Left+CUTOFF<=Right){
		int Pivot = Median(a,Left,Right);
		int i = Left,j=Right-1;
		for(;;){
			while(a[i++]<Pivot){}
			while(a[j--]>Pivot){}
			if(--i < ++j)	swap(a[i],a[j]);
			else break;
		}
		swap(a[i],a[Right]);
		QSort(a,Left,i-1);
		QSort(a,i+1,Right);
	}
	else InsertionSort(a+Left,Right-Left+1);
}
void QuickSort(int a[],int N)
{
	QSort(a,0,N-1);
}
void main(void)
{
	int A[] = {9,-345,3234,9,-23,54,49,12,23,-35,932,987,23455};
	QuickSort(A,13);
	for(int i= 0; i<13; i++){
		printf("%d ",A[i]);
	}
	printf("\n");
}


  
  

   
   


  
  




 

 

 
 
#include <stdio.h>
#include <iostream.h>
#include <string.h>
#include <stdlib.h>
#include <assert.h>
#include <algorithm>
#include <vector>
using   namespace   std;

//快速排序算法
#define CUTOFF (4)
void InsertionSort(int a[],int N)	//插入排序
{
	int j,P;
	int temp;
	for(P=1;P<N;P++){
		temp = a[P];
		for(j=P;j>0 && a[j-1]>temp;j--){
			a[j] = a[j-1];
		}
		a[j]=temp;
	}
}
int Median(int a[],int Left,int Right)
{
	int Center = (Left+Right)/2;
	if(a[Left] > a[Center])	swap(a[Left],a[Center]);
	if(a[Left] > a[Right])	swap(a[Left],a[Right]);
	if(a[Center] > a[Right])	return a[Right];
	else{
		swap(a[Center],a[Right]);
		return a[Right];
	}
	
}
void QSort(int a[],int Left,int Right)
{
	if(Left+CUTOFF<=Right){
		int Pivot = Median(a,Left,Right);
		int i = Left,j=Right-1;
		for(;;){
			while(a[i++]<Pivot){}
			while(a[j--]>Pivot){}
			if(--i < ++j)	swap(a[i],a[j]);
			else break;
		}
		swap(a[i],a[Right]);
		QSort(a,Left,i-1);
		QSort(a,i+1,Right);
	}
	else InsertionSort(a+Left,Right-Left+1);
}
void QuickSort(int a[],int N)
{
	QSort(a,0,N-1);
}
void main(void)
{
	int A[] = {9,-345,3234,9,-23,54,49,12,23,-35,932,987,23455};
	QuickSort(A,13);
	for(int i= 0; i<13; i++){
		printf("%d ",A[i]);
	}
	printf("\n");
}


  
  

   
   


  
  




 

 

 
 
#include <stdio.h>
#include <iostream.h>
#include <string.h>
#include <stdlib.h>
#include <assert.h>
#include <algorithm>
#include <vector>
using   namespace   std;

//快速排序算法
#define CUTOFF (4)
void InsertionSort(int a[],int N)	//插入排序
{
	int j,P;
	int temp;
	for(P=1;P<N;P++){
		temp = a[P];
		for(j=P;j>0 && a[j-1]>temp;j--){
			a[j] = a[j-1];
		}
		a[j]=temp;
	}
}
int Median(int a[],int Left,int Right)
{
	int Center = (Left+Right)/2;
	if(a[Left] > a[Center])	swap(a[Left],a[Center]);
	if(a[Left] > a[Right])	swap(a[Left],a[Right]);
	if(a[Center] > a[Right])	return a[Right];
	else{
		swap(a[Center],a[Right]);
		return a[Right];
	}
	
}
void QSort(int a[],int Left,int Right)
{
	if(Left+CUTOFF<=Right){
		int Pivot = Median(a,Left,Right);
		int i = Left,j=Right-1;
		for(;;){
			while(a[i++]<Pivot){}
			while(a[j--]>Pivot){}
			if(--i < ++j)	swap(a[i],a[j]);
			else break;
		}
		swap(a[i],a[Right]);
		QSort(a,Left,i-1);
		QSort(a,i+1,Right);
	}
	else InsertionSort(a+Left,Right-Left+1);
}
void QuickSort(int a[],int N)
{
	QSort(a,0,N-1);
}
void main(void)
{
	int A[] = {9,-345,3234,9,-23,54,49,12,23,-35,932,987,23455};
	QuickSort(A,13);
	for(int i= 0; i<13; i++){
		printf("%d ",A[i]);
	}
	printf("\n");
}


  
  

   
   


  
  




 

 

 
 
#include <stdio.h>
#include <iostream.h>
#include <string.h>
#include <stdlib.h>
#include <assert.h>
#include <algorithm>
#include <vector>
using   namespace   std;

//快速排序算法
#define CUTOFF (4)
void InsertionSort(int a[],int N)	//插入排序
{
	int j,P;
	int temp;
	for(P=1;P<N;P++){
		temp = a[P];
		for(j=P;j>0 && a[j-1]>temp;j--){
			a[j] = a[j-1];
		}
		a[j]=temp;
	}
}
int Median(int a[],int Left,int Right)
{
	int Center = (Left+Right)/2;
	if(a[Left] > a[Center])	swap(a[Left],a[Center]);
	if(a[Left] > a[Right])	swap(a[Left],a[Right]);
	if(a[Center] > a[Right])	return a[Right];
	else{
		swap(a[Center],a[Right]);
		return a[Right];
	}
	
}
void QSort(int a[],int Left,int Right)
{
	if(Left+CUTOFF<=Right){
		int Pivot = Median(a,Left,Right);
		int i = Left,j=Right-1;
		for(;;){
			while(a[i++]<Pivot){}
			while(a[j--]>Pivot){}
			if(--i < ++j)	swap(a[i],a[j]);
			else break;
		}
		swap(a[i],a[Right]);
		QSort(a,Left,i-1);
		QSort(a,i+1,Right);
	}
	else InsertionSort(a+Left,Right-Left+1);
}
void QuickSort(int a[],int N)
{
	QSort(a,0,N-1);
}
void main(void)
{
	int A[] = {9,-345,3234,9,-23,54,49,12,23,-35,932,987,23455};
	QuickSort(A,13);
	for(int i= 0; i<13; i++){
		printf("%d ",A[i]);
	}
	printf("\n");
}


  
  

   
   


  
  




 


                

        

        

    




    

      

        

            

              
                
                  feige200923435436546
                
              
            

            

                关注
              
            

        

        

          
    
            
  • 
              
                
                
                
                
                      0
                
              
              
    点赞
    
            
    • 
            
  • 
              
                
                
                
              
              
    踩
    
            
    • 
            
  • 
              
                
                
                
                
                    1
                
              
              
    
                
    
                  
                    收藏
                  
                
    
              
    
              
    
                
    
                  觉得还不错?
                  
                    一键收藏
                  
                 
                
    
              
    
            
    • 
          
  • 
            
    
              
              
            
    
              
              
              
                    0
              
            
            
    评论
    
          
    • 
          
  • 
          
    • 
          
  • 
            
              
            
              
    
            
              
                
            
    
          
    • 
        

      

      

            

                专栏目录
          










                



	

		

			

				
					
快速排序算法实现.docx

				
			

			

				

					11-17
				

			

		

		

			
				
快速排序算法实现  快速排序算法是一种高效的排序算法，基于 Divide and Conquer 策略，通过选择一个基准元素，partition数组，使得左侧元素小于基准，右侧元素大于基准，然后递归地对左侧和右侧元素进行排序。  ...

			
		

	



                

              
                



	

		

			

				
					
C语言实现12种排序算法

				
			

			

				

					yishuihanq的博客
				

				

					02-01
					
					3668
					
				

			

		

		

			
				
用C语言完整实现12种排序方法

			
		

	



                


  
              

                


	

		

			

				
					
排序算法：希尔排序算法实现及分析

				
			

			

				

					重庆李四
				

				

					02-23
					
					5368
					
				

			

		

		

			
				
希尔排序算法介绍希尔排序是D.LShell 与1957年提出来的一种排序算法，在这之前排序算法的时间复杂度都是O(n^2),希尔排序算法是突破这个时间复杂度的第一批算法之一。我们知道直接插入排序算法（不知道的请看：排序算法：直接插入排序算法实现及分析），在某些情况下的效率是很很高的，1.当我们的记录本身就是基本有序（小的关键字基本在前面，大的基本在后面）的，我们只需要少量的插入操作，就可以完成排序...

			
		

	





	

		

			

				
					
实验四  查找和排序算法实现

				
			

			

				

					雨化于画
				

				

					02-22
					
					5348
					
				

			

		

		

			
				
广州大学学生实验报告
开课实验室：计算机科学与工程实验（电子楼418A）
学院	计算机科学与网络工程学院	
实验课程	数据结构实验	
实验项目	实验四  查找和排序算法实现

一、实验目的：
1、各种排序算法的实现
2、各种查找算法实现
二、使用仪器、器材
微机一台
操作系统：WinXP
编程软件：C++
三、实验内容及原理
1、各种排序算法的实现 
用随机函数生成16个2位正整数（10~99），...

			
		

	



		

			
		



	

		

			

				
					
SWUST OJ 1016: 插入排序算法实现

				
			

			

				

					橙橙橙汁i的博客
				

				

					05-10
					
					1547
					
				

			

		

		

			
				
1016: 插入排序算法实现
题目描述
插入排序算法实现。
输入

第一行是待排序数据元素的个数；
第二行是待排序的数据元素。

输出

一趟直接插入排序算法结果。

样例输入

10
50 36 41 19 23 4 20 18 12 22

样例输出

36 50 41 19 23 4 20 18 12 22

思路：


插入排序假设待排序的记录存放在数组 R[0….n-1] 中，排序过程的某一中间时刻， R 被划分成两个子区间 R[0…i-1] 和 R[i….n-1] ，其中：前一个子区间是已排好序

			
		

	





	

		

			

				
					
常用十大排序算法

					
热门推荐

				
			

			

				

					qq_51664685的博客
				

				

					04-26
					
					13万+
					
				

			

		

		

			
				
列举了常见的十大内部排序算法：插入排序、希尔排序、选择排序、冒泡排序、归并排序、快速排序、堆排序、基数排序，计数排序，桶排序。

			
		

	





	

		

			

				
					
C语言实现快速排序算法

				
			

			

				

					wantsnowfly的博客
				

				

					01-15
					
					5463
					
				

			

		

		

			
				
快排作为公认最优秀的排序方法，是每一个程序员都应该掌握的，那么，今天就由我来为大家简单讲解一下快速排序算法的代码。

源代码如下：

#include<stdio.h>
void quicksort(int *a,int left,int right)
{
 if(left>right)
 {
  return ;
 }
 int i=left;
 int j=right;
 int key=a[left];
 while(i!=j)
...

			
		

	





	

		

			

				
					
十大经典排序算法-归并排序算法详解

				
			

			

				

					qq_35344198的博客
				

				

					06-19
					
					12万+
					
				

			

		

		

			
				
一、什么是归并排序
1.概念
归并排序（Merge sort）是建立在归并操作上的一种有效的排序算法，归并排序对序列的元素进行逐层折半分组，然后从最小分组开始比较排序，合并成一个大的分组，逐层进行，最终所有的元素都是有序的
2.算法原理
这是一个无序数列：4、5、8、1、7、2、6、3，我们要将它按从小到大排序。按照归并排序的思想，我们要把序列逐层进行拆分

序列逐层拆分如下

然后从下往上逐层合并，首先对第一层序列1（只包含元素4）和序列2（只包含元素5）进行合并
创建一个大序列，序列长度为两个小序列长度

			
		

	





	

		

			

				
					
快速排序算法

				
			

			

				

					鹏鹏2077
				

				

					05-08
					
					4861
					
				

			

		

		

			
				
快速排序（Quicksort），计算机科学词汇，适用领域Pascal，c++等语言，是对冒泡排序算法的一种改进。本次实现使用的Java代码。快速排序是一种高效的排序算法，其核心思想是分治法。快速排序的基本思路是先选取一个枢轴元素，通过一趟排序将待排序序列分成两部分，其中左边部分的所有元素都小于等于枢轴元素，右边部分的所有元素都大于等于枢轴元素，然后分别递归地对左右两部分进行排序，直到整个序列有序。

			
		

	





	

		

			

				
					
直接插入排序算法

				
			

			

				

					m0_64529905的博客
				

				

					08-03
					
					2924
					
				

			

		

		

			
				
在有序区（r[1]~r[i-1]）中插入r[i],首先找到第i个记录的正确插入位置，然后将r[i]插入到有序序        列中。1、 基本思想：在插入第i个元素时，前（i-1） 个元素已经有序。(2)  r[0]暂存r[i]的元素，避免了因元素的后移覆盖r[i]的值。（1）在查找嘻哈如位置的循环中r[0]起到监视哨（或者监视哨兵的作用）最好情况（正序）：例如1、2、3、4、5、6。最差情况（逆序）：例如6、5、4、3、2、1。比较次数：n-1 （共有n个元素）移动次数：2（n-1）时间复杂度：O(n).

			
		

	





	

		

			

				
					
C语言实现选择排序算法

				
			

			

				

					qq_58417838的博客
				

				

					11-14
					
					3083
					
				

			

		

		

			
				
选择排序算法

			
		

	





	

		

			

				
					
java十大排序算法实现

				
			

			

				

					11-20
				

			

		

		

			
				
java十大排序算法实现 1. 冒泡排序（Bubble Sort） 2. 选择排序（Selection Sort） 3. 插入排序（Insertion Sort） 4. 快速排序（Quick Sort） 5. 归并排序（Merge Sort） 6. 堆排序（Heap Sort） 7. 计数排序...

			
		

	





	

		

			

				
					
广州大学 数据结构实验报告  实验四  查找和排序算法实现

				
			

			

				

					05-23
				

			

		

		

			
				
实验报告的主题聚焦于数据结构中的查找和排序算法实现，这是计算机科学中基础且重要的部分，尤其是在处理大量数据时。以下是对这些算法的详细说明：  1. **插入排序**：插入排序的基本思想是将一个记录插入到已经排...

			
		

	





	

		

			

				
					
C++ 排序算法实现

				
			

			

				

					11-05
				

			

		

		

			
				
常用的八种算法，包括简单选择排序、冒泡排序、堆排序、直接插入排序、希尔排序、折半插入排序、二路归并排序和快速排序。亲测有效。感兴趣的朋友可以下载跑跑玩玩。

			
		

	





	

		

			

				
					
(leetcode学习)50. Pow(x, n)

				
			

			

				

					m0_54888411的博客
				

				

					08-05
					
					168
					
				

			

		

		

			
				
快速幂，第一次写的时候用 n%2==1，这样不能处理负数的问题。

			
		

	





	

		

			

				
					
5力扣：最长回文子串

				
			

			

				

					m0_75015083的博客
				

				

					08-02
					
					223
					
				

			

		

		

			
				
从后到前遍历是为了让每一次遍历时所需用到的子串提前被计算过。

			
		

	





	

		

			

				
					
算法第十七天：leetcode242.有效的字母异位词

				
			

			

				

					m0_75068978的博客
				

				

					08-02
					
					459
					
				

			

		

		

			
				
如下表所示，您可以直接复制下面网址进入力扣学习，在观看下面的内容之前您一定要先做一遍哦，以便让你印象更加深刻！

			
		

	





	

		

			

				
					
嵌入式初学-C语言-十五

					
最新发布

				
			

			

				

					MaBaB的博客
				

				

					08-05
					
					501
					
				

			

		

		

			
				
函数：实现一定功能的，独立的代码模块，我们的函数一定是先定义后使用使用函数的优势可以通过函数提供功能给别人使用，当然我们也可以使用别人提供的函数，减少代码量借助函数可以减少重复性代码。实现结构化（模块化）程序设计思想结构化程序设计思想：将大型的任务功能，划分为相互独立的小型的任务模块来设计3.函数是c语言程序的基本组成单元：C语言程序是由一个（必然是main函数）或多个函数组成。语法：返回类型 函数名(形参列表)                 -- 函数头 | 函数首部。

			
		

	





	

		

			

				
					
排序算法实现与优化

				
			

			

				

					
				

			

		

		

			
				
哈希算法与贪心算法在排序算法中的应用  在本章节中，我们将讨论哈希算法和贪心算法在排序算法中的应用。排序算法是计算机科学中的一种基本算法，用于对数据进行排序。常见的排序算法有冒泡排序、选择排序、插入排序...

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值