牛客网算法学习记录-排序2

已知一个几乎有序的数组，几乎有序是指，如果把数组排好顺序的话，每个元素移动的距离可以不超过k，并且k相对于数组来说比较小。请选择一个合适的排序算法针对这个数据进行排序。

给定一个int数组A，同时给定A的大小n和题意中的k，请返回排序后的数组。

测试样例：

[2,1,4,3,6,5,8,7,10,9],10,2

返回：[1,2,3,4,5,6,7,8,9,10]

对于步长有限定的一般选用局部堆排序。基本有序的可以选用插入排序

//构建小根堆

void minHeap(vector<int> &B,int n){

        int i;
         if(n%2==0){
            i = (n-2)/2;
        }
        else{
            i = (n-1)/2;
        }
        
       
        for(;i>=0;i--){
            
            adjustHeap(B,i,n);
            
        }
        
    }

    

//注意vector和数组不同的是，参数要有&才能传递指针

//数组下标从0开始

    void adjustHeap(vector<int> &B,int i,int n){
        

        int j = 2 * i +1 ,flag = 1;

//注意边界

        while(2*i+1<n&&flag){
            
            if(2*i+1<n-1&& B[2*i+1]>B[2*i+2]){
                j =  2*i+2;
            }
            else{
                j = 2*i+1;
            }
            
            if(B[i]>B[j]){               
                int t = B[i];
                B[i] = B[j];
                B[j] = t;
                i = j;
            }
            else{
                flag = 0;
            }
        }
        
    }

    

    vector<int> sortElement(vector<int> A, int n, int k) {
        // write code here
        vector<int> B(k); //需要初始化
        for(int i = 0 ; i<k;i++){
            B[i] = A[i];
        }
        
        minHeap(B,k);
        for(int i = 0 ; i<n-k;i++){
            
            A[i] = B[0];
            B[0] = A[i+k];
            adjustHeap(B,0,k);
            
        }

        

//对最后的K个元素进行排序和小根堆的调整

         for(int j=n-k;j<n;j++)
            {
             A[j] =B[0];
            if(j==n-1)
                break;
            B[0]=B[--k];
            adjustHeap(B,0,k);
        }
        
        return A;
        

    }

请设计一个高效算法，判断数组中是否有重复值。必须保证额外空间复杂度为O(1)。

给定一个int数组A及它的大小n，请返回它是否有重复值。

测试样例：

[1,2,3,4,5,5,6],7

返回：true

空间复杂度为1 即只能用常数个辅助空间，一般就是堆排序或者插入排序之类的

bool checkDuplicate(vector<int> a, int n) {
        // write code here
        int flag = 0,count=0;
        minHeap(a,n);
        
        for(int i = n-1;i>=0;i--){
            int  t = a[0];
            a[0] = a[i];
            a[i] = t;
            count++;
            if(count>1){

//为了能提前退出
                if(a[i] == a[i+1]){
                    flag = 1;
                    break;
                }
            }
            adjustHeap(a,0,i);
            
        }
        
        if(flag){
            return true;
        }
        else{
            return false;
        }
        
    }
    
    void minHeap(vector<int> &a,int n){
        int i;
        if(n%2==0){
            i = (n -2)/2;
        }
        else{
            i = (n-3)/2;
        }
        
        for(;i>=0;i--){
            
            adjustHeap(a,i,n);
            
        }
    }
    
    void adjustHeap(vector<int> &a,int i ,int n){
        
        for(int j= i*2+1;j<n;j=j*2+1){
            if(j+1<n&&a[j]>a[j+1]){
                j = j+1;
            }
            if(a[i]>a[j]){
                int t = a[i];
                a[i] = a[j];
                a[j] = t;
                i=j;
            }
        }
        
    }

有两个从小到大排序以后的数组A和B，其中A的末端有足够的缓冲空容纳B。请编写一个方法，将B合并入A并排序。

给定两个有序int数组A和B，A中的缓冲空用0填充，同时给定A和B的真实大小int n和int m，请返回合并后的数组。

int* mergeAB(int* A, int* B, int n, int m) {
        // write code here
        if(m==0){
            return A;
        }
        
        if(n==0){
            return B;
        }
        
        int index = m+n-1;
        int i,j;
        for( i = n-1,j=m-1;i>=0&&j>=0;){      
            if(A[i]<B[j]){
                
                A[index] = B[j];
                j--;
                index--;
            }
            else{
                A[index] = A[i];
                i--;
                index--;
            }
        }
        if(j<0){
            for(;i>=0;i--){
                A[index] = A[i];
                index--;
            }
        }
        if(i<0){
            for(;j>=0;j--){
                A[index] = B[j];
                index--;
            }
        }
        return A;
    }