各种排序算法的C++实现

最新推荐文章于 2024-06-06 09:34:24 发布

njudongchen

最新推荐文章于 2024-06-06 09:34:24 发布

阅读量720

点赞数

分类专栏：编程练习文章标签： c语言

本文链接：https://blog.csdn.net/njudongchen/article/details/54965547

版权

编程练习专栏收录该内容

87 篇文章 0 订阅

订阅专栏

冒泡排序
两两交换，稳定排序
时间复杂度O(n²)
空间复杂度O(1)

class BubbleSort {
public:
    int* bubbleSort(int* A, int n) {
        for(int i=0;i!=n-1;++i)
            {
            for(int j=0;j!=n-1-i;++j)
                {
                if(A[j]>A[j+1])
                    {
                    int temp;
                    temp=A[j];
                    A[j]=A[j+1];
                    A[j+1]=temp;
                }
            }

        }
        return A;
    }

};

选择排序时间复杂度O(n²)
选择最小和第一个位置交换，之后第二个位置以后选择最小和第二个位置交换。
不稳定排序
空间复杂度O(1)

class SelectionSort {
public:
    int* selectionSort(int* A, int n) {
        int temp;
        int pos;
        for(int i=0;i!=n;++i)
            {
            temp=A[i];
            pos=i;
            for(int j=i+1;j!=n;++j)
            {
            if(temp>A[j])
                {
                temp=A[j];
                pos=j;
            }
        }
             if(pos!=i)
                 swap(A+pos,A+i);
        }
        return A;
        // write code here
    }
    void swap(int *a,int *b)
        {
        int temp;
        temp=*a;
        *a=*b;
        *b=temp;
    }
};

插入排序时间复杂度O(n²)
从后向前比较代码比较简单
稳定排序
空间复杂度O(1)

class InsertionSort {
public:
    int* insertionSort(int* A, int n) {
        for(int i=1;i!=n;++i)
            {
            if(A[i]<A[i-1])
                {
                int temp=A[i];
                int j=i-1;
                A[i]=A[i-1];
                int pos=i-1;
             while(j)
                 {
                 if(temp<A[j-1])
                     {
                     A[j]=A[j-1];
                     pos=j-1;
                 }                 
                 --j;
             }
             A[pos]=temp;                 
            }
        }
        return A;
        // write code here
    }
};

归并排序时间复杂度O(nlgn) 空间复杂度O(n)
稳定排序
空间复杂度O(n)

class MergeSort {
public:
    int* mergeSort(int* A, int n) {
        int *temp=new int[n];
        mergerecur(A,0,n-1,temp);
        return A;        
        // write code here
    }
    void mergerecur(int *input,int first,int end,int *temp)
        {
        if(end>first)
            {
            int mid=(first+end)/2;
            mergerecur(input,first,mid,temp);
            mergerecur(input,mid+1,end,temp);
            mergearray(input,temp,input+first,mid-first+1,input+mid+1,end-mid);
        }       
    }
    void mergearray(int *input,int *res,int *a,int lena,int *b,int lenb)
        {
        int first=a-input;
        int i=0;
        int j=0;
        int k=0;
       while(i!=lena&&j!=lenb)
            {
            if(a[i]<b[j])
                res[k++]=a[i++];
            else
                res[k++]=b[j++];             
            }
         while(j!=lenb)
            res[k++]=b[j++];           
         while(i!=lena)
            res[k++]=a[i++];
         for(int i=0;i!=k;++i)
            input[first++]=res[i];
    }
};

快速排序平均时间复杂度O(nlgn) 空间复杂度O(nlgn)
空间复杂度O(N)~O(logN)
不稳定排序

class QuickSort {
public:
    int* quickSort(int* A, int n) {
        sortrecur(A,0,n-1);
        return A;
        // write code here
    }
    void sortrecur(int *a,int l,int r)
        {

        if(l<r)
        {
        int mid=sortmove(a,l,r);
        sortrecur(a,l,mid-1);
        sortrecur(a,mid+1,r);
        }
    }
    int sortmove(int *a,int l,int r)
        {
        int i=l;
        int j=r;
        int x=a[i];
        while(i<j)
            {
           while(i<j&&a[j]>=x)
                  --j;
             a[i]=a[j];
           while(i<j&&a[i]<=x)
                  ++i;
             a[j]=a[i];
        }
        a[i]=x;
        return i;
    }
};

堆排序时间性能O(nlgn) 空间性能O(1)
不稳定排序
利用最大或最小堆进行排序
核心思想首先将序列构建成最大堆或者最小堆，之后选择最大堆顶部元素和最后一个元素交换
之后无序序列长度减1，重新构建最大堆最小堆，迭代上述步骤即可完成整个排序过程和选择排序有些类似，注意其有序序列从后端向前端生长。
空间复杂度O(1)

class HeapSort {
public:
    int* heapSort(int* A, int n) {
        // write code here
        sortrecur(A,n);
        return A;
    }

    void sortrecur(int *a,int lena)
        {
        if(lena>1){
        buildheap(a,lena);
        swapnum(a,a+lena-1);
        sortrecur(a,lena-1);
        }
    }
    void buildheap(int *a,int lena)
        {
        if(lena<2)
            return;
        for(int i=(lena-2)/2;i>=0;--i)
            {
            if(a[i]<a[2*i+1])
                swapnum(a+i,a+2*i+1);
            if(2*i+2<lena)
                {
                if(a[i]<a[2*i+2])
                    swapnum(a+i,a+2*i+2);
            }
        }
    }

    void swapnum(int *a,int *b)
        {
        int temp;
        temp=*a;
        *a=*b;
        *b=temp;
    }
};

希尔排序
希尔增量时间复杂度为O(n²)，而Hibbard增量的希尔排序的时间复杂度为O(n^3/2)，希尔排序时间复杂度的下界是n*log2n。
空间复杂度O(1)
不稳定排序

class ShellSort {
public:
    int* shellSort(int* A, int n) {
        sortrecur(A,n,n/2);
        return A;

        // write code here
    }
    void sortrecur(int *a,int n,int dk)
        {
        if(dk>0){
          shellinsert(a,n,dk); 
          dk=dk/2;
          sortrecur(a,n,dk);
        }      
    }
    void shellinsert(int *a,int n,int dk)
        {
        for(int i=0;i<dk;++i) //所有组数
            {
                for(int j=i+dk;j<n;j+=dk) //插入排序
                    {
                    int k=j;
                    int temp=a[k];                  
                    while(k-dk>=i&&temp<a[k-dk])//先判断下标再比较大小，否则还会内存越界
                        {
                         a[k]=a[k-dk];
                         k=k-dk;
                    }
                    a[k]=temp;
                }

        }
    }

};

计数排序
桶排序的一种时间复杂度O(n),空间复杂度O(M)（取决于桶的个数）
适合数字在一定范围内的排序。
稳定排序

class CountingSort {
public:
    int* countingSort(int* A, int n) {

        int max=A[0];
        int min=A[0];
        for(int i=0;i!=n;++i)
            {
            if(min>A[i])
                min=A[i];
            if(max<A[i])
                max=A[i];
        }

        int *bucket=new int[max-min+1];
        memset(bucket,0,(max-min+1)*sizeof(int));
        for(int i=0;i!=n;++i)
            {
            ++(*(bucket+A[i]-min));
        }
        int pos=0;
        for(int i=0;i!=max-min+1;++i)
            {
            int k=*(bucket+i);
            while(k--)
                {
                *(A+pos)=i+min;
                ++pos;
            }
        }
        return A;
        // write code here
    }
};

基数排序
其时间复杂度为O (nlog(r)m)，其中r为所采取的基数，而m为堆数，
稳定排序

class RadixSort {
public:
    int* radixSort(int* A, int n) {
        vector<queue<int>> vec_pos(10,queue<int>{});
        vector<queue<int>> vec_neg(10,queue<int>{});
        int max=abs(A[0]);
        for(int i=0;i!=n;++i)
            {
            if(max<abs(A[i]))
                max=abs(A[i]);
        }
        int i=1;

        while(max/10)
               {
                   ++i;
                   max=max/10;
               }

        int k=i;
        while(i--)
            {

            int div=1;
            int num=k-i-1;
            while(num--)
                div=div*10;               
            for(int j=0;j!=n;++j)
                {
                if(A[j]>=0)
                vec_pos[(A[j]/div)%10].push(A[j]);
                else
                {
                vec_neg[(0-(A[j])/div)%10].push(A[j]);  
                }
            }

            int pos=0;
            for(int neg_iter=vec_neg.size()-1;neg_iter>=0;--neg_iter)
            {
                while(!vec_neg[neg_iter].empty())
                {
                A[pos]=vec_neg[neg_iter].front();
                vec_neg[neg_iter].pop();
                ++pos;
                }          
            }
           for(int pos_iter=0;pos_iter!=10;++pos_iter)
               {
                while(!vec_pos[pos_iter].empty())
                {
                A[pos]=vec_pos[pos_iter].front();
                vec_pos[pos_iter].pop();
                ++pos;
                }
            }

        // write code here
    }
        return A;
    }
};

njudongchen

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
各种排序算法的C++实现

冒泡排序两两交换，稳定排序时间复杂度O(n2)class BubbleSort {public: int* bubbleSort(int* A, int n) { for(int i=0;i!=n-1;++i) { for(int j=0;j!=n-1-i;++j) {
复制链接

扫一扫

专栏目录