大二用C++写的各种排序算法

最新推荐文章于 2024-07-19 13:40:17 发布

风万里

最新推荐文章于 2024-07-19 13:40:17 发布

阅读量387

点赞数

分类专栏： C/C++

本文链接：https://blog.csdn.net/kuangrenerlengzi/article/details/53572424

版权

C/C++ 专栏收录该内容

5 篇文章 0 订阅

订阅专栏

最开始这些代码都是扔在QQ空间里的，现在参加工作了，才意识到应该有一个属于自己的正式博客。翻出大二的代码，发现里边对变量的命名都是胡写的，记得当时的上机题还经常写拼音，让助教各种无语，哈哈……

冒泡排序

/**********************冒泡排序************************/
template 
    
    
     
     
void BubbleSort(T Data[],int n) {
    int i,j;
    for(i=0;i

 
  
  
  
  
  
  冒泡排序改进算法 
  
  
   
   
#include 
      
      
       
       
using namespace std;
/****************冒泡排序的改进算法*******************/
template 
       
       
        
        
void SuperBubbleSort(T Data[],int n)
{
    int flag=0; //标记每一趟的冒泡排序过程中是否发生了交换
    int i,j;
    for(i=0;i
        
        
       
       
      
       
   
   
  
 
 
  
    基数排序 
   
   
    
    基数排序.h
const int RADIX=10; //定义基数，用于区分不用进制
template 
      
      
       
       
struct LinkNode {//定义链式结构的结点
    T data;
    LinkNode *next;
};
template 
       
       
        
        
struct TubNode {//定义队列数组结点
    LinkNode
        
        
         
          *rear;
    LinkNode
         
         
          
           *front;
};
/*
            分配操作
输入: data[] 数组,n 元素个数,ith 第i次分配操作
输出：执行分配操作之后的一个队列数组
*/
template 
          
          
            TubNode 
           
             *Distribute(T data[],int n,int ith { //申请内存 TubNode 
            
              *tube=new TubNode 
             
               [RADIX]; //执行初始化 memset(tube,0,sizeof(TubNode 
              
                ) *RADIX); LinkNode 
               
                 *t; for(int i=0;i 
                
                  ; //申请新的链接表结点 t->data=data[i]; t->next=NULL; if(tube[v].front) { //如果对应的队列不为空，则放到末尾 tube[v].rear->next=t; tube[v].rear=t; } else {//否则，初始化队列头和尾 tube[v].front=tube[v].rear=t; } } return tube; } /* 收集操作，将tube中数据收集到data 数组中 输入：data 数据数组 ；tube 执行完分配操作之后的队列数组 输出：无 */ template 
                 
                   void Collect(T data[],TubNode 
                  
                    *tube) { LinkNode 
                   
                     *t,*p; //临时变量 int index=0; //数据下标 for(int i=0;i 
                    
                      data; //复制对应数据 t=t->next; delete p; //释放内存 p=t; } } delete []tube; //释放内存 } template 
                     
                       void RadixSort(T data[],int n,int keys) {//基数排序 TubNode 
                      
                        *tube; for(int i=0;i 
                       
                         (data,n,i+1); Collect 
                        
                          (data,tube); } } 
                         
                        
                       
                      
                     
                    
                   
                  
                 
                
               
              
             
            
          
         
         
        
        
       
       
      
       
    
    
    
 
    
   
     堆排序 
    
    
     
      /*********最大堆**********/
template 
       
       
        
        
class MaxHeap {
    public :
        MaxHeap() {
        cout<<"堆排序输出:";
    }
    void BuildHeap(T data[],int n);
    void SiftDown(T data[],int i,int n);
    void HeapSort(T data[],int n);
};
template 
        
        
         
         
void MaxHeap
         
         
          
          ::SiftDown(T data[],int i,int n) {
    //用来保持以结点i为根的最大堆的性质，n是所有元素的个数
    int l=2*i+1, r=2*i+2,min=i;//找到i结点的两个孩子的下标
    if(l
          
          
           
           
void MaxHeap
           
           
             ::BuildHeap(T data[],int n) { int p=n/2-1; //求出非叶子结点的最大下标 for(int i=p;i>=0;i--) { SiftDown(data,i,n);//调用SiftDown函数，保持最大堆的性质 } } template 
            
              void MaxHeap 
             
               ::HeapSort(T data[],int n) { BuildHeap(data,n); //首现建立一个最大堆 for(int i=n-1;i>0;i--) { //进行循环 T t=data[0]; //每次取出最大元素后不断调整最大堆 data[0]=data[i]; data[i]=t; SiftDown(data,0,i); } } 
              
             
           
          
          
         
         
        
        
       
        
     
     
     
 
     
    
      希尔排序 
     
     
      
      #include 
        
        
         
         
using namespace std;
template 
         
         
          
          
void shellSort(T Data[],int n) {
    int d=n/2;  //增量初始化为数组大小的一半
    while(d>=1) {//循环遍历增量的所有可能
        for(int k=0;k
          
          
           
           =k && Data[j]>temp) {
                    Data[j+d]=Data[j];
                    j-=d;
                }
                Data[j+d]=temp;
            }
        }
        d=d/2;  //增量变为上次的一半
    }
} 
          
          
         
         
        
         
      
     
 
     
    
      归并排序 
     
     
      
      /*************合并一个序列中的两个有序子序列************/
template 
        
        
         
         
//函数Merge，参数data是待归并数组，其中对data[start,mid]和data[mid+1,end]之间的数据进行归并
void Merge(T data[],int start,int mid,int end) {
    int len1=mid-start+1, len2=end-mid; //分别表示两个归并区间的长度

    int i,j,k;
    T *left=new T[len1]; //临时数组用来存放data[start,end]数据
    T *right=new T[len2]; //临时数组用来存放data[mid+!,end]数据
    for(i=0;i
         
         
          
          
void MergeSort(T data[],int start,int end) {
    //对data[start]=data[end]之间的序列进行归并排序
    if(start
          
          
         
         
        
         
      
      
  
     
     快速排序 
      
      快速排序.h
/***********************快速排序分割策略一****************************/
template 
        
        
         
         
int first_Partition(T data[],int left,int right) {
    //实现对data[left]到data[right]的分割操作，并返回划分后轴元素对应的位置
    T pivot=data[left]; //选择最左边的为轴元素
    while(left
         
         
          
          pivot) //控制right指针的移动
            right--;
        data[left]=data[right]; //将right指向的数据移动到left位置
        while(left
          
          
           
           
int second_Partition(T data[],int start,int end) {
    //实现对data[start]到data[end]的分割操作，并返回划分后轴元素对应的位置
    T pivot=data[start];
    int left=start,right=end; //初始化left,right
    while(left<=right) {//外层循环控制遍历数组
        while(left<=right && data[left]<=pivot) //控制left指针的移动
            left++;
        while(left<=right &7 data[right]>pivot)//控制right指针的移动
            right--;
        if(left
           
           
            
            
void QuickSort1(T data[],int left,int right) {
    //用快速分割策略一实现快速排序算法
    if(left
            
            
              void QuickSort2(T data[],int left,int right) { //用快速分割策略一实现快速排序算法 if(left 
              
            
           
           
          
          
         
         
        
         
     
  
    
    
      
      
 
      折半插入排序 
      
      #include 
        
        
         
         
using namespace std;
template 
         
         
          
          
void BinaryInsertionSort(T Data[],int n) {//参数，待排序数据和待排序元素个数
    int left,mid,right,p;  //声明一些变量
    for(p=1;p
          
          
           
           temp)  //中心点元素值比待插入数据大
                right=mid-1; //更新右区间值
            else
                left=mid+1; //更新左区间值
        }
        for(int i=p-1;i>=left;i--)  //执行移动操作
            Data[i+1]=Data[i];
        Data[left]=temp; //将待插入元素插入到有序表中
    }
}
          
          
         
         
        
         
     
  
  
 
     
     
 
     
    
      直接插入排序 
     
     
      
      #include 
        
        
         
         
using namespace std;
template 
         
         
          
          
void InsertionSort(T data[],int n) {
    //利用直接插入排序对于n个数据元素进行不减序排序
    int p,i;
    for(p=1;p
          
          
           
           =0 && data[i]>temp) {//把比temp大的元素都向后移动
            data[i+1]=data[i];
            i--;
        }
        data[i+1]=temp;
    }
} 
          
          
         
         
        
         
      
      
      
 
      
     
       简单选择排序 
      
      
       
       /*****************简单选择排序*******************/
/*简单选择排序算法就是利用线性查找的方法从一个序列中找到最小的元素，即第i趟的排序操作为：
通过n-i次关键字的比较，从n-i+1个元素中选出关键字最小的元素，并和第i-1（1<=i<=n-1）个元素
交换。简单选择排序算法也称为直接选择排序算法*/
template 
         
         
          
          
void SelectionSort(T data[],int n) {
    for(int i=1;i
          
          
         
          
       
       
        
        
 
        
       
         主方法 
        
        
         
         #include 
           
           
            
            
#include "直接插入排序.h"
#include "折半插入排序.h"
#include "希尔排序.h"
#include "冒泡排序.h"
#include "冒泡排序改进算法.h"
#include "快速排序.h"
#include "简单选择排序.h"
#include "堆排序.h"
#include "归并排序.h"
#include "基数排序.h"
using namespace std;
int main() {
    /**************************直接插入排序部分********************************/
    int A[15]={11,2,6,8,1,4,9,7,3,5};
    InsertionSort(A,10);
    int i;
    cout<<"直接插入排序输出:";
    for(i=0;i<10;i++)
        cout<
            
            
             
             <<' ';
    cout<
             
             
              
               h;
    h.HeapSort(I,10);
    for(i=0;i<10;i++)
        cout<
              
              
               
               <<' ';
    cout<