面试题

一、

Given a triangle, find the minimum path sum from top to bottom. Each step you may move to adjacent numbers on the row below.

For example, given the following triangle

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

 

The minimum path sum from top to bottom is11(i.e., 2 + 3 + 5 + 1 = 11).

解决方案：从第二行开始，triangle[i][j] = min(triangle[i - 1][j - 1], triangle[i - 1][j]), 然后两边的数字直接赋值上一行的边界值，由于限制了空间复杂度，所以我干脆直接就更新triangle数组，代码如下：

class Solution {
public:
    int minimumTotal(vector<vector<int> > &triangle) {
        int n = triangle.size();
        for (int i = 1; i < n; ++i) {
            for (int j = 0; j < triangle[i].size(); ++j) {
                if (j == 0) triangle[i][j] += triangle[i - 1][j];
                else if (j == triangle[i].size() - 1) triangle[i][j] += triangle[i - 1][j - 1];
                else {
                    triangle[i][j] += min(triangle[i - 1][j - 1], triangle[i - 1][j]);
                }
            }
        }
        int res = triangle[n - 1][0];
        for (int i = 0; i < triangle[n - 1].size(); ++i) {
            res = min(res, triangle[n - 1][i]);
        }
        return res;
    }
};

二、输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。

package com.test.algorithm;




class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}

public class Merge {
    
    public static ListNode Merge(ListNode list1,ListNode list2) {
        
        if(list1 == null && list2 == null)
            return null;
        if(list1 == null)
            return list2;
        if(list2 == null)
            return list1;
        
        ListNode newNode = new ListNode(0);
        ListNode tmp = new ListNode(0);
        tmp = newNode;
        if(list1.val < list2.val){
            newNode.val = list1.val;
            list1 = list1.next;
        }
        else{
            newNode.val = list2.val;
            list2 = list2.next;
        }
        //newNode.next = null;
        while(list1!=null && list2!=null){
            if(list1.val < list2.val){
                newNode.next = list1;
                newNode = newNode.next;
                newNode.val = list1.val;
                list1 = list1.next;
            }else{
                newNode.next = list2;
                newNode = newNode.next; 
                newNode.val = list2.val;    
                list2 = list2.next;
            }
        }
        if(list1!=null){
            newNode.next = list1;
            newNode = newNode.next;
            //list1 = list1.next;
        }
        if(list2!=null){
            newNode.next = list2;
            newNode = newNode.next;
            //list2 = list2.next;
        }
        
        return tmp;
    }

    public static void main(String[] args) {
        
        ListNode list1 = new ListNode(1);
        ListNode list2 = new ListNode(2);
        list1.next = null;
        list2.next = null;
        ListNode head1 = list1;
        ListNode head2 = list2;
        
        for(int i = 2 ; i <=8 ; i ++){
            if(i%2!=0)
            {
                ListNode temp = new ListNode(i);
                temp.next = list1.next;
                list1.next = temp;
                list1 = temp;
            }
        }
        for(int i = 4 ; i <=8 ; i ++){
            if(i%2==0)
            {
                ListNode temp = new ListNode(i);
                temp.next = list2.next;
                list2.next = temp;
                list2 = temp;
            }
        }
        
        ListNode newNode = Merge(head1,head2);
        for(int i = 1 ; i <= 8 ; i++){
            System.err.println(newNode.val);
            newNode = newNode.next;
        }
    }
}

三、输入一个复杂链表（每个节点中有节点值，以及两个指针，一个指向下一个节点，另一个特殊指针指向任意一个节点），返回结果为复制后复杂链表的head。（注意，输出结果中请不要返回参数中的节点引用，否则判题程序会直接返回空）

#include<iostream>
using namespace std;

struct RandomListNode {
    int label;
    struct RandomListNode *next, *random;
    RandomListNode(int x) :
            label(x), next(NULL), random(NULL) {
    }
};

class Solution {
public:
    RandomListNode* Clone(RandomListNode* pHead)
    {
        RandomListNode* ClonedHead=NULL;
        if(pHead) 
        {
            ClonedHead=new RandomListNode(pHead->label);//复制头指针

            RandomListNode* p=pHead;    //两个链表节点指针
            RandomListNode* pCopy=ClonedHead;
            while(p->next)             //复制链表每个节点
            {
                p=p->next;
                RandomListNode* CopyNode=new RandomListNode(p->label);
                pCopy->next=CopyNode;
                pCopy=pCopy->next;
            }

            p=pHead;     //从头开始复制每个节点的随机指针
            pCopy=ClonedHead;
            while(p)
            {
                RandomListNode* i=pHead;
                RandomListNode* j=ClonedHead;
                while( (p->random) != i )
                {
                    i=i->next;
                    j=j->next;
                }
                pCopy->random=j;
                pCopy=pCopy->next;
                p=p->next;
            }
        }
        return ClonedHead;
    }
};

三、

1、数据的逻辑结构分为线性结构和非线性结构。

常用的线性结构有：线性表，栈，队列，双队列，数组，串。

常见的非线性结构有：二维数组，多维数组，广义表，树(二叉树等)，图。

2、串是一种数据对象和操作都特殊的线性表

3、

哈弗曼树又叫做最优二叉树，是权值越大的点离根节点越近，导致整个树权值最小

方法：选择值最小的两个点作为左右节点，然后和作为父节点，在剩下的点以及父节点中选择最小的两个依次构造，形成哈弗曼树

左边数值是0，右边是1

哈弗曼编码是将各个点的值加起来最小

长度计算就是把各个点的值乘以路径长加起来

4、KMP算法时间复杂度为O(m+n)，空间复杂度为O(m)。 因为KMP算法涉及到next数组的存储，且next数组是基于模式串长度计算的。

5、常量字符串，在常量区，所以不能对其进行操作，可将其改为数组。