软件工程10道题

1.爬楼梯：斐波那契数列的算法

class Solution {
public:
    /**
     * @param n: An integer
     * @return: An integer
     */

    int climbStairs(int n) {
        // write your code here
         int fib1=1;
         int fib2=2;
         if(n==0)
         {
             return 1;
         }
         if(n==1)
         {
         return 1;
         }
          if(n==2)
          {
        return 2;
          }
         if(n>1)
         {
         for(int i=2;i<n;i++)
         {
             fib2=fib1+fib2;
             fib1=fib2-fib1;
         }
         return fib2;
         }
    }    
};

2.排列序号：对原数组中的每一个位置,找到其后有多少个数比它小,由于字典排序是从小到大排列的，所以只需计算出第i位（从1开始）在它后面比它小的数进行(A.size()-k-1)!，最后相加即可。

class Solution {
public:
    /**
     * @param A an integer array
     * @return a long integer
    */

    long long permutationIndex(vector<int>& A) {
        // Write your code here
         int i,j;
        long n=1;
        for(i=0;i<A.size();i++)
        {
            for(j=i+1;j<A.size();j++)
            {
                if(A[i]>A[j])
                {
                    long m=1;
                    for(int k=i;A.size()-k-1>0;k++)
                    {
                       m=m*(A.size()-k-1);
                    }
                    n=n+m;
                }
            }
        }
        return n;
    }
};

3.合并排序数组：先将两个数组合并，然后将B数组里的元素与A里面的比较，然后将B的元素插入进去。

class Solution {
public:
    /**
     * @param A and B: sorted integer array A and B.
     * @return: A new sorted integer array
     */
    vector<int> mergeSortedArray(vector<int> &A, vector<int> &B) {
        // write your code here
        vector<int> C(A.size()+B.size(), 0);  
        int i,j;
        for(i=0;i<A.size();i++)
        {
            C[i]=A[i];
        }
        int f;
        f=i;
        for(j=0;j<B.size();j++)
        {
            C[i]=B[j];
            i++;
        }
        int p=0;
        for(f;f<i;f++)
        {
            for(j=0;j<A.size()+p;j++)
            {
            if(C[f]<C[j])
            {  
                int m,k;
                k=C[f];
                m=f;
                while(m>j)
                {
                C[m]=C[m-1];
                m--;
                }
               C[j]=k;
               p++;
            }
            } 
        }
            return C;
        
    }
};

4.翻转链表：翻转链表最简单的方式是改变链的链接顺序，把后一个节点的next变成前一节地址。

/**
 * Definition of ListNode
 * 
 * class ListNode {
 * public:
 *     int val;
 *     ListNode *next;
 * 
 *     ListNode(int val) {
 *         this->val = val;
 *         this->next = NULL;
 *     }
 * }
 */
class Solution {
public:
    /**
     * @param head: The first node of linked list.
     * @return: The new head of reversed linked list.
     */
    ListNode *reverse(ListNode *head) {
        // write your code here
                ListNode *prev=NULL;
        while(head!=NULL)
        {
            ListNode *t=head->next;
            head->next=prev;
            prev=head;
            head=t;
        }
        return prev;
    }
};

5.乘积最大子序列:用Min表示以nums[i]结尾乘积最小的连续子序列 因为有负数，所以保存这个是必须的

class Solution {
public:
    /**
     * @param nums: a vector of integers
     * @return: an integer
     */
    int maxProduct(vector<int>& nums) {
        // write your code here
        int Max = nums[0];  
        int Min = nums[0];  
        int allMax = nums[0];  
        for(int i=1;i<nums.size();i++)  
        {  
            int premax = Max;  
            int premin = Min;  
           Max = max(nums[i],max(nums[i]*premax,nums[i]*premin));  
           Min = min(nums[i],min(nums[i]*premax,nums[i]*premin));  
           allMax=max(allMax,Max);  
        }  
        return allMax;
    }
};

//自己写的第一种但复杂度过高

/*
int i,j,k,m;
        k=nums[0];
        for(i=0;i<nums.size();i++)
        {
            m=1;
            if(k<nums[i])
                {
                    k=nums[i];
                }
            for(j=i;j<nums.size();j++)
            {
                m=m*nums[j];
                if(k<m)
                {
                    k=m;
                }
            }
        }
return k;
*/

6.解码方法：斐波那契数列，我们用两个变量fib2, fib1来分别表示s[i-1]和s[i-2]的解码方法，然后我们从i=1开始遍历，也就是字符串的第二个字符，我们判断如果当前字符为'0'，说明当前字符不能单独拆分出来，只能和前一个字符一起,fib2=fib1，然后我们看前面的字符，如果前面的字符是1或者2时，我们就可以更新,fib2=fib2+fib1，其实fib1赋值为之前的fib2，如果不满足这些条件的话，那么fib1=fib2。

class Solution {
public:
    /**
     * @param s a string,  encoded message
     * @return an integer, the number of ways decoding
     */
    int numDecodings(string& s) {
        // Write your code here
        int fib1=1,fib2=1;
         if (s.empty()||s.front()=='0') 
         {
         return 0;
         }
         for(int i=1;i<s.size();i++)
         {
             if(s[i]=='0')
             {
                 if(s[i-1]=='1'||s[i-1]=='2')
                 {
                     fib2=fib1;
                 }
                 else
                 return 0;
             }
             else if(s[i-1]=='1'||(s[i-1]=='2'&&s[i]<='6'))
             {
                 int t;
                 t=fib2;
                 fib2=fib2+fib1;
                 fib1=t;
             }
             else
             {
                 fib1=fib2;
             }
         }
         return fib2;
    }
};

7.两个链表的交叉：利用栈。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    /**
     * @param headA: the first list
     * @param headB: the second list
     * @return: a ListNode
     */
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        // write your code here
        stack<ListNode *> A,B;
        ListNode *x=NULL;
        if(headA==NULL||headB==NULL)
        {
            return NULL;
        }
        else
        {
        for(;headA!=NULL;headA=headA->next)
        {
            A.push(headA);
        }
         for(;headB!=NULL;headB=headB->next)
        {
            B.push(headB);
        }
        for(;A.top()!=NULL&&B.top()!=NULL;)
        {
            if(A.top()==B.top())
            {
                x=A.top();
                A.pop();
                B.pop();
            }
            else
            {
                break;
            }
        }
         return x;   
        }
    }
};

8.N皇后问题：

class Solution {
public:
    /**
     * Get all distinct N-Queen solutions
     * @param n: The number of queens
     * @return: All distinct solutions
     * For example, A string '...Q' shows a queen on forth position
     */

    vector<vector<string> > solveNQueens(int n) {
        // write your code here
        vector<vector<string> > ret;
        search(0,n,ret);
        return ret;
    }
    int c[20];
    void search(int r,int &n, vector<vector<string>> &ret)
    {
    if(r == n)
    {
     vector<string> v;
    for(int i=0; i<n; ++i)
    {
        string s ="";
        for(int j=0; j<n; j++)
        {
            if(j==c[i])
            {
            s+='Q';
            }
            else
            {
            s+='.';
            }
        }
        v.push_back(s);
    }
        ret.push_back(v);
    }
    for(int i=0; i<n; i++){
        c[r] = i;
        int ok = 1;
        for(int j=0; j<r; j++)
            if(c[r]==c[j] || r-j==c[r]-c[j] || r-j==c[j]-c[r]){
                ok = 0;
                break;
            }
        if(ok) search(r+1,n,ret);
    }
}
};

9.全排列：可以理解为每个数在开头时后面所有数的全排列，以此类推进行递归。

class Solution {
public:
    /**
     * @param nums: A list of integers.
     * @return: A list of permutations.
     */
    vector<vector<int> > permute(vector<int> nums) {
        // write your code here
        vector<vector<int> > result;
        int size = nums.size();
        permute(nums, 0, size, result);
        return result;
    }
    void permute(vector<int> &nums, int begin, int end, vector<vector<int> > &result) 
    {
        if(begin == end)
        {
            result.push_back(nums);
        }
        else 
        {
            for(int i=begin; i<end; i++) 
            {
                int temp = nums[i];          
                nums[i] = nums[begin];
                nums[begin] = temp;
                permute(nums, begin+1, end, result);
                temp = nums[i];
                nums[i] = nums[begin];
                nums[begin] = temp;
            }
        }
    }
};

10.翻转字符串：定义两个整形变量，如果s[i]不为空其中一个减一，另一个不变，变量之差即为单词长度。

class Solution {
public:
    /**
     * @param s : A string
     * @return : A string
     */
    string reverseWords(string s) {
        // write your code here
         string word, line;
       int size=s.size();
       int i=size-1, j, wordbegin=size-1, wordend=size-1;
        if(s.empty())
        {
            return s;
        }
         for(;i>=0;)  
         {
             for(;s[i]==' '&&i>=0;i--) 
             {
                 wordbegin--;
                 wordend--;
             }
             for(;s[i]!=' '&&i>=0;i--)  
             {
                 wordbegin--;
             }
             word.resize(0);
             for(j=wordbegin+1; j<=wordend; j++)
             {
                 word.append(1,s[j]);
             }
            if(wordbegin==0)
            {
                 line=line+word;
            }
             else
             {
                 line=line+word+" ";
             }
             wordend =wordbegin;
         }
         return line;


    }
        
};

转载于:https://www.cnblogs.com/qhdxzwp/p/7363538.html