劍指offer 雜題2

（1）調整數組順序使技術位於偶數前

藉助輔助數組會簡單很多.

class Solution {
public:
    void reOrderArray(vector<int> &array) {
        int len=array.size();
        int ji=0,ou=0;
        vector<int> temparray;
        for(int i=0;i<len;i++)
        {
            if(array[i]%2)temparray.push_back(array[i]);
        }
        for(int i=0;i<len;i++)
        {
            if(array[i]%2==0)temparray.push_back(array[i]);
        }
        for(int i=0;i<len;i++)
        {
            array[i]=temparray[i];
        }
        
    }
};

但是有大佬說這題考的就不是這種意思..但我實在不想寫n方的方法....

（2）醜數

class Solution {
public:
    int GetUglyNumber_Solution(int index) {
        if(index<7)return index;
        vector<int> ans(index);
        ans[0]=1;
        int a,b,c;
        a=b=c=0;
        for(int i=1;i<index;i++)
        {
            ans[i]=min(2*ans[a],min(3*ans[b],5*ans[c]));
            if(ans[a]*2==ans[i])a++;
            if(ans[b]*3==ans[i])b++;
            if(ans[c]*5==ans[i])c++;
                      
        }
                       
        return ans[index-1];
    }
};

一開始想到了，但是寫的時候很痛苦，可能還是寫的不夠多，..

(3)連續子數組的最大和

class Solution {
public:
    int FindGreatestSumOfSubArray(vector<int> array) {
        int len=array.size();
        int max=array[0];
        for(int i=1;i<len;i++)
        {
            array[i]=array[i-1]>0?array[i-1]+array[i]:array[i];
            max=array[i]>max?array[i]:max;
        }
        return max;
        
    }
};

這是一個很典型的dp問題，很容易構造出遞推 dp[i]=max(0,dp[i-1])+dp[i];

（4）最小的k個數

這裏很容易的想到大頂堆.然後每次插入之後調整位置就好.

class Solution {
public:
    vector<int> heap;
    void insert(int val)
    {
        heap.push_back(val);
        int index=heap.size()-1;
        int father=(index-1)/2;
        while(index>0)
        {
            if(heap[index]>heap[father])
            {
                
                swap(heap[index],heap[father]);
                index=father;father=(index-1)/2;
                continue;
            }
            break;
        }
    }
    void pop(int val)
    {
        int k=heap.size();
        int index=0;
        heap[0]=val;
        int left;int right;
        while(index<k-1)
        {
            left=2*index+1;
            right=2*index+2;
            if(left>=k)break;
            if(right==k)
            {
                if(heap[left]>heap[index])
                {
                    swap(heap[left],heap[index]);
                    index=left;continue;
                }else break;
            }
            else
            {
                int bigger=heap[left]>=heap[right]?left:right;
                if(heap[index]<heap[bigger])
                {
                    swap(heap[index],heap[bigger]);
                    index=bigger;
                }
                else break;
            }
            
            
        }
    }
    vector<int> GetLeastNumbers_Solution(vector<int> input, int k) {
        if(k<= 0 || k > input.size())return heap;
        for(int i=0;i<k;i++)
        {
            insert(input[i]);
        }
        for(int i=k;i<input.size();i++)
        {
            if(heap[0]>input[i])
            {
                pop(input[i]);
            }
        }
        return heap;
    }
};