编程题刷题笔记（包括leetcode和各种公司笔试题）

7/6：

    做的查找中的word_ladder，没做出来。

        学到了的知识点：

            unordered_set：

                定义为unordered_set<string>dict

                在集合中查找为dict.find(cur_front)，找没找到用if (dict.find(cur_front) != dict.end())

            queue：

                定义为queue<string>Q

                插入为Q.push(start)

                弹出为Q.pop()

                判断是否为空为Q.empty()

                查看长度为Q.size()

                取值为Q.front()

            在一个单词中替换单个字母为：

            for (int i = 0; i < size; i++){
                   char ch = cur_front[i];  //对队列头字符串每一个字符进行替换
                   for (int j = 0; j < 26; j++){
                       cur_front[i] = 'a' + j;//替换字符
                       if (cur_front == end)return res+1;//找到答案，退出
                       if (dict.find(cur_front) != dict.end()){
                           Q.push(cur_front);//变换在字典中找到了
                           dict.erase(cur_front);//从字典中删除
                       }
                   }
                   cur_front[i] = ch;//还原队列头字符串，因为有可能在字典中可以找到多个“近邻字符串”
               }

7/8:

    做的数组中的

best-time-to-buy-and-sell-stock

    理解出现了问题，还是挺容易的

7/10：

    做的数组中的

best-time-to-buy-and-sell-stock2

        一次过，没问题

    还做了字符串中的add-binary

        基本也是一遍过

        学到的知识点如下：

            栈的定义：stack< char > s;

                相关操作：

s.empty();         //如果栈为空则返回true, 否则返回false;
s.size();          //返回栈中元素的个数
s.top();           //返回栈顶元素, 但不删除该元素
s.pop();           //弹出栈顶元素, 但不返回其值
s.push();          //将元素压入栈顶

            给字符串赋值的一种方法：string s4(10, 'a');

            substr的用法：res = res.substr(1) //取res除了第一个字符的字符串

            char和int交融：

char a= 'a';
int b ;
b=a;
count>>n;

                结果是97

 

best-time-to-buy-and-sell-stock

best-time-to-buy-and-sell-stock

 

7-20:

    鸽了10天。。很难受。。做了一道

palindrome-number

    没做出来感觉是个数学问题，脑子没转过弯来

7-26：

    第一次做了图这一类的问题。前两天才学完图相关的东西

    题目是：clone-gragh

• BFS：广度优先便利需要借助队列queue
• map：一种类似于python中dict的容器

  • 定义是这样的

    map<UndirectedGraphNode *, UndirectedGraphNode *> mymap;

    第一个是key 后一个是value

  • 迭代器是这样的（包含初始化）

    map<UndirectedGraphNode *, UndirectedGraphNode *>::iterator iter = mymap.begin()

     

  • 插入数据是这样的

    mymap.insert(make_pair(front, newNode));

    这里front是key，newNode是value

  • 查找map中是否有这样一个key是这样的

    if (mymap.find(front->neighbors[i]) == mymap.end())

    此举是判断find括号中的那东西是不是在map中

  • 找到map中某个key或者value的内容是这样的

    iter->first->neighbors[i]
    iter->second->neighbors.push_back(mymap[ori]);

    iter是map的迭代器，指向map中的某一对key和value，first是这个key，second是指这个value

• 在图中创建一个新的节点结构（其实也就是创建一个新对象的方法）

  UndirectedGraphNode * newNode = new UndirectedGraphNode(front->label);

  new

7-29：

做了回溯中的

permutation-sequence

• 将int型转换成str型可以直接变：

          vector<string> init;
  		for (int i = 1; i <= n; i++) {
  			init.push_back(to_string(i));
  		}

   

• vector中删除一个元素是这样的

  left.erase(left.begin() + 6);

  这里是删除left中第7个元素

8-1:

今天我真牛逼，打完球11点还在寝室做了一道题学了点知识。阔以

做的哈希里的two-sum

• 用了unordered_map，其查找较快
  • 其定义和初始化如下

    unordered_map<int, int> hashtable;
            vector<int> result;
            for(int i=0; i<numbers.size(); i++){
                hashtable[numbers[i]] = i;
            }

    有点像python中的dict

  • 有像python中的str一样的find函数的用法，如下

    hashtable.find(diff) != hashtable.end()

     

8-3:

做了一道没什么意义的题，integer-to-roman

8-4:

做了

populating-next-right-pointers-in-each-node

挺简单的一道树的题被我想复杂了，鸭儿哟

8-6:

做了Maximum Subarray

没想到最简单的O(n)的解法，难受啊。

链接：https://www.nowcoder.com/questionTerminal/32139c198be041feb3bb2ea8bc4dbb01
来源：牛客网

public class Solution {
    public int maxSubArray(int[] A) {
        if(A.length == 0) return 0;
        int sum = 0, max = A[0];
        for(int i = 0; i < A.length; i++) {
            sum += A[i];
            if(max < sum) max = sum;
            if(sum < 0)  sum = 0;
        }
        return max;       
    }
}

记录一下

8-7:

做了same-tree。。也没什么，就是没像别人一样用递归导致写的很累，但是锻炼了思维把大概就是

8-8:

做了

unique-binary-search-trees

 

又是一道类似于脑经急转弯的问题，没搞赢没搞赢

8-9：

做了rotate-image：

会做，因为做俄罗斯方块那个游戏的时候用到过

• 函数的引用传递时，函数的形参要加&，调用时实参不用加&直接用就行

  void swap( int &front,int &back ){
          int tmp = front;
          front = back;
          back = tmp;
          return;
  }
  
  swap(matrix[i][j],matrix[n-1-i][j]);

   

• 返回值为void的函数甚至不用形式上最后写一个return

  void swap( int &front,int &back ){
          int tmp = front;
          front = back;
          back = tmp;
      }

   

8-12

鸽了两天，莫得办法，找了两天的课题，没心情做题。。今天做了balanced-binary-tree，就是花式递归，做出来了

做了两道题，还做了binaru-tree-inorder-traver