排序算法

Posted 2022-12-10 上衫_

排序算法

• 说明
• 冒泡排序
• 直接插入排序
• 希尔排序
• 直接选择排序
• 快速排序
• 堆排序
• 两路归并排序

说明

目前还没有时间写出算法详解，等以后有时间会补上的

冒泡排序

template <class T>
void bubble_sort(vector<T> &x)//冒泡排序

    inf temp;
    for (inf i = 0; i < x.size();i++)
    
        inf maxnum = x[0];
        inf max_posion = 0;
        for (inf j = 1; j < x.size() - i;j++)
        
            if(x[j]>maxnum)
            
                maxnum = x[j];
                max_posion = j;
            
        
        temp = x[max_posion];
        x[max_posion] = x[x.size() - i - 1];
        x[x.size() - i - 1] = maxnum;

    

直接插入排序

template <class T>
void insertsort(vector<T> A)//直接插入排序

    for (inf i = 1; i < A.size(); i++)
    
        inf temp = A[i];
        inf j = i - 1;
        while (A[j]>temp&&j>=0) 
        
            A[j + 1] = A[j];
            j--;
        
        A[j + 1] = temp;
    
    

希尔排序

template <class T>
void shell_sort(vector<T> A)//希尔排序（二分插入排序）

    inf d=A.size()/2;
    while(d>0) 
    
        for(inf i=d;i<A.size();i++) 
        
           T x=A[i];
           inf j=i-d;
           while(j>=0&&x<A[j] )
           
               A[j+d]=A[j]; 
               j=j-d;
           
           A[j+d]=x;
        
        d=d/2;
      

直接选择排序

template <class T>
void select_sort(vector<T> A)//直接选择排序

    for (inf i = 0; i < A.size(); i++)
    
        T min = A[i];
        inf index = i;
        for (inf j = i + 1; j < A.size(); j++)
        
            if(A[j]<min)
            
                min = A[j];
                index = j;
            
        
        T temp = A[i];
        A[i] = min;
        A[index] = temp;
    
    

快速排序

template <class T>
void quicksort(inf left,inf right,vector<T> &A)//快速排序

    inf i,j,t,temp;
    if(left>right)
        return;
    temp=A[left];
    i=left;
    j=right;
    while(i!=j) 
    
        while(A[j]>=temp&&j>i)
            j--;
        while(A[i]<=temp&&j>i)
            i++;
        if(i<j) 
        
            t=A[i];
            A[i]=A[j];
            A[j]=t;
        
    
    A[left]=A[i];
    A[i]=temp;
 
    quicksort(left,i-1,A);
    quicksort(i+1,right,A);

template <class T>
void quicksort(vector <T> A)

    quicksort(0, A.size() - 1, A);

堆排序

template <class T>
void sift(vector<T> &A,inf begin,inf end)

    inf dad = begin;
    inf son = dad * 2 + 1;
    while (son <= end)
     
        if (son + 1 <= end && A[son] < A[son + 1]) 
            son++;
        if (A[dad] > A[son]) 
            return;
        else 
         
            swap(A[dad], A[son]);
            dad = son;
            son = dad * 2 + 1;
        
    


template <class T>
void heap_sort(vector<T> A,inf n)

    for (inf i = n / 2 - 1; i >= 0; i--)
    
        sift(A, i, n-1);
    
    for (inf i = n-1; i > 0; i--)
    
        swap( A[0],A[i]);
        sift(A, 0, i - 1);
    
    

两路归并排序

template <class T>
void Merge(vector<T> &Array, inf front, inf mid, inf end) 

    vector<T> LeftSubArray(Array.begin() + front, Array.begin() + mid + 1);
    vector<T> RightSubArray(Array.begin() + mid + 1, Array.begin() + end + 1);
    inf idxLeft = 0, idxRight = 0;
    LeftSubArray.insert(LeftSubArray.end(), numeric_limits<inf>::max());
    RightSubArray.insert(RightSubArray.end(), numeric_limits<inf>::max());
    for (inf i = front; i <= end; i++) 
    
        if (LeftSubArray[idxLeft] < RightSubArray[idxRight]) 
        
            Array[i] = LeftSubArray[idxLeft];
            idxLeft++;
         
        else 
        
            Array[i] = RightSubArray[idxRight];
            idxRight++;
        
    


template <class T>
void MergeSort(vector<T> &Array, inf front, inf end) //两路归并排序

    if (front >= end)
        return;
    inf mid = (front + end) / 2;
    MergeSort(Array, front, mid);
    MergeSort(Array, mid + 1, end);
    Merge(Array, front, mid, end);