1. 单选

auto可以修饰函数的返回值，但是auto不能修饰函数参数。
一个指向浮点数组的指针定义为float (*ptr)[]。
(1) 结构体的字节对齐问题遵循的规则：
1. 分配单位：由结构体中最大的基本类型长度确定。
2. 成员的起始位置的偏移量：是成员的基本类型长度的整数倍。
3. 结构体总大小==分配单位的整数倍。
(2) 伪指令#pragma pack()
1. 什么是伪指令：用于告诉汇编程序如何进行汇编的指令。
2. #pragma pack(n)的作用：改变编译器的内存对齐方式，使编译器按照n个字节对齐。
3. 若#pragma pack(n)中指定的n大于结构体中最大成员类型的size，则其不起作用。

A. 有环的单向链表和无环的单向链表不能相交，因为当相交的时候，无环的单向链表也会被迫存在一个环，只不过这个环的”起点“可能不是原来单向链表的头结点。

B. 单链表的没个节点都具有唯一的前驱节点和唯一的后继节点，所以当两个单链表存在相交的节点时，这两个链表则同时拥有这个节点，以及这个节点的所有后继节点，当这个公共节点是尾节点时，他们则只含有公共一个节点——尾节点。

C. 快慢指针是判断单链表是否有环的一种方法：两个指针，每次移动的步长为2叫做快指针，每次移动步长为1的指针叫做慢指针。快慢指针同时从头结点出发，当快指针率先到达NULL的时候，则说明此单链表中不存在环，当快指针追上慢指针的时候，说明此单链表中存在环。

D. 两个单向链表之间相交可以存在环。

故选D。

选C。

const char*和char* const的区别

const char*; // 解读为：p是一个指针，指向const char 这就意味着char*是不可以改变的，所以以下语句是错误的：

char str[] = "hello world";
const char *ptr = str;
ptr[0] = 'h';

因为ptr指向const char，即str，str是const类型，如果ptr[0]被赋值，那就说明str[0]被更改，这是无法编译过的。

但是ptr可以不指向str，而是指向其他变量，比如：

char ss[] = "good game";
ptr = ss;

这个语句是成立的。

char* const p; // 解读为：p是一个const指针，指向char*

这种写法说明p是一个const类型的指针，它的指向只能是char*(在第一个例子中就是str)，就不能被赋值为ss了。

但是，ptr[0] = ‘h’;是可以成立的，因为这种写法是改变str的值，str是一个char*，没有被声明为const，所以可以改变。

2. 编程题

1. LeetCode 82. 删除排序链表中的重复元素 II

class Solution {
public:
    ListNode* deleteDuplicates(ListNode* head) {
        if (head == nullptr || head->next == nullptr) return head;

        ListNode* dummy = new ListNode(-1);
        dummy->next = head;
        ListNode* curr = dummy;

        while (curr->next != nullptr && curr->next->next != nullptr)
        {
            if (curr->next->val == curr->next->next->val)
            {
                int val = curr->next->val;
                while (curr->next != nullptr && curr->next->val == val)
                {
                    curr->next = curr->next->next;
                }
            }
            else
            {
                curr = curr->next;
            }
        }
        return dummy->next;
    }
};

LeetCode 83. 删除排序链表中的重复元素

class Solution {
public:
    ListNode* deleteDuplicates(ListNode* head) {
        ListNode* p = head;
        while (p && p->next)
        {
            if (p->val == p->next->val)
            {
                p->next = p->next->next;
            }
            else
            {
                p = p->next;
            }
        }
        return head;
    }
};

2. 已知顶点坐标求多边形的面积

#include <vector>
#include <iostream>
#include <cmath>
using namespace std;

struct Point
{
    int x;
    int y;
    Point(int xx, int yy) : x(xx), y(yy) { }
};

double getPolygonArea(vector<Point>& pos)
{
    int n = pos.size();
    cout << n << "w" << endl;
    double s = 0.0;
    for (int i = 0; i < n; ++i)
    {
        s += (pos[i].x * pos[(i+1)%n].y - pos[(i+1)%n].x * pos[i].y) / 2.0;
        cout << pos[(i+1)%n].x << "a" << endl;
    }
    return abs(s);
}

int main()
{
    Point p1(0, 0);
    Point p2(2, 0);
    Point p3(0, 2);
    vector<Point> pos{ p1, p2, p3 };
    cout << getPolygonArea(pos) << endl;
}

3. LeetCode 1710. 卡车上的最大单元数

解法：贪心

class Solution {
public:
    int maximumUnits(vector<vector<int>>& boxTypes, int truckSize) {
        sort (boxTypes.begin(), boxTypes.end(), [](vector<int> a, vector<int> b){
            return a[1] > b[1];     // 每一行的第二个元素从大到小排序
        });
        int res = 0;
        int i = 0;
        while (truckSize > 0)
        {
            if (i >= boxTypes.size()) break;    // 箱子耗尽
            int cnt = min(boxTypes[i][0], truckSize);   // 可以装载第i类箱子的个数
            res += boxTypes[i++][1] * cnt;
            truckSize -= cnt;
        }
        return res;
    }
};

要点：

使用 sort (boxTypes.begin(), boxTypes.end(), [](vector<int> a, vector<int> b){ return a[1] > b[1]; });对每一行的第二个元素从大到小排序。
要使总的单元总数最大，选择箱子装入卡车时，应该选择单元总数最大的箱子装入卡车。

记录2022.8.21中望软件笔试