【笔试】02

TCP

TCP（传输控制协议）是一种面向连接的、可靠的、基于字节流的传输层通信协议

它能够提供以下服务：

• 可靠传输
  通过序列号、确认应答、重传机制等确保数据完整、准确地从发送端传输到接收端。
  三次握手：
  
• 点对点
• 全双工
• 面向字节流
• 流量控制：通过滑动窗口机制，接收端可以控制发送端的发送速率，防止接收端来不及处理导致数据丢失。
• 拥塞控制：当网络出现拥堵时，TCP能够减少其数据传输速率，避免造成更严重的网络拥塞。
• 数据顺序控制：保证数据按照发送顺序到达接收端。
• 对比：

不能提供的服务：

• 时延和带宽保证
• 多播和广播：TCP是基于点对点的通信模式，不支持多播（一点对多点）和广播（一点对全点）通信。

HTTP

• 使用TCP传输
  TCP是一个传输协议，而HTTP全称是超文本传输协议，是在传输时使用TCP协议，HTTP是在应用层进行握手，即服务器上的运行的进程之间的通信
• HTTP不保留状态，或者说无状态stateless
• 消息格式
  • 发送：方法（GET POST）+URL+协议
  • 相应：协议+状态码+状态词
• 响应状态码：
  • 404 Not Found： 表示客户端能够与服务器通信，但服务器找不到请求的资源。
  • 200 OK：请求成功，服务器提供了请求的网页
  • 5XX - 服务器错误

字符数组初始化方法

• 直接赋值
  编译器会自动计算数组str的大小，包括字符串的结尾标识符\0。

char str[] = "Hello, World!";

• 指定大小赋值
  数组的大小必须足够大，以存储所有字符和末尾的\0。

char str[14] = "Hello, World!";

• 逐字符填充
  逐字符初始化时，必须包括字符串的结束符\0。
  如果你指定的大小大于实际初始化的字符数（包括必需的终止符\0），剩余的部分将自动用\0填充。

char str[] = {'H', 'e', 'l', 'l', 'o', ',', ' ', 'W', 'o', 'r', 'l', 'd', '!', '\0'};

• 二维数组也要注意/0

char str[4][6] = {"hello", "world"};

unsigned int 范围

int 在大多数系统上占用 4 个字节（32 位），其取值范围是从 -2147483648 到 2147483647
unsigned int 在大多数系统上占用 4 个字节（32 位），其取值范围为 0 到 4294967295。

冒泡排序

冒泡排序的基本思想是，重复地遍历待排序序列，每次比较相邻的两个元素，如果它们的顺序错误，则交换它们。通过每次遍历，将最大的元素“冒泡”到最后。

def bubble_sort(arr):
    n = len(arr)
    for i in range(n):
        for j in range(0, n-i-1):
            if arr[j] > arr[j+1]:
                arr[j], arr[j+1] = arr[j+1], arr[j]
    return arr

选择排序

选择排序的基本思想是，每次从待排序的元素中选择最小的元素，放置到已排序序列的末尾。

def selection_sort(arr):
    n = len(arr)
    for i in range(n):
        min_index = i
        for j in range(i+1, n):
            if arr[j] < arr[min_index]:
                min_index = j
        arr[i], arr[min_index] = arr[min_index], arr[i]
    return arr

补码

补码是一种用于表示有符号整数的编码方式，常用于计算机系统中。在补码表示法中，正整数的二进制表示与无符号整数相同，而负整数的表示稍有不同。

具体来说，对于一个 n 位的补码表示：

对于正整数，其补码与其原码（即二进制表示）相同。
对于负整数，先将其绝对值表示成二进制形式，然后取反（每一位取反），最后加 1。

在一个字节（8bit）的补码中，负数的表示范围是 -128 到 -1，而正数的表示范围是 0 到 127。

参数传递和内存分配

分析运行下面的Test函数会有什么样的结果，为什么？

void GetMemory1(char*p)
{
p = (char*)malloc(100);
}
void Testl(void)
{
char*str =NULL;
GetMemory1(str);
strcpy(str,"hello world");
printf(str);
}

GetMemory() 函数中的指针 p 是按值传递的，而不是按引用传递。在 GetMemory() 函数内部分配了内存，并将其地址存储在 p 中，但这个地址只是 GetMemory() 函数内部的局部变量，它并不会改变 Test() 函数中指针 str 的值。因此，Test() 函数中的 str 指针仍然是 NULL，没有指向任何有效的内存位置。
未定义行为导致程序崩溃，因为试图写入未分配的内存地址。

char *GetMemory2(void)
{
char p[] = "helloworld";
return p;
}
void Test2(void)
{
char *str =NULL;
str= GetMemory2();
printf(str);
}

输出乱码。

GetMemory() 函数中的局部数组 p 是在栈上分配的，它的生命周期仅限于 GetMemory() 函数的执行过程。当 GetMemory() 函数返回时，p 的内存将被释放，但 Test() 函数中的 str 指针仍然指向已释放的内存地址，这会导致未定义行为，可能会输出垃圾值，程序崩溃或其他意外行为。

void GetMemory(char** p, int num)
{
	*p = (char*)malloc(num);
}
void Test(void)
{
	char* str = NULL;
	GetMemory(&str, 100);
	strcpy(str, "hello");
	printf(str);
}

正确打印了hello。利用二级指针做函数形参，成功把str变成分配的大小为100字节连续空间的的起始地址。但是没有用free进行内存释放，造成内存泄漏。

void Test(void)
{
	char* str = (char*)malloc(100);
	strcpy(str, "hello");
	free(str);
	if (str != NULL)
	{
		strcpy(str, "world");
		printf(str);
	}
}

虽然调用了 free(str) 释放了内存，但并没有将 str 指针置为 NULL。因此，在 if (str != NULL) 中，虽然 str 已经指向了一片已经释放的内存，但由于 str 本身并不是 NULL，所以条件成立，进入了 if 分支。所以正常进行strcpy(str, “world”);，最后打印world。对已经释放的内存进行操作，也可能导致未定义行为。

函数的继承派生、虚函数

这段代码的输出结果是什么

class Ca
{
public:
	Ca() {strcpy(m_info,"fa");printf("Ca”);}
	virtual void f() {printf(m info);}
	void f1(){printf("fa1”);}
	void f2(int i=3){ this->f();printf("%d”,i);}
	
	char m info[10];
};
class Cb:public Ca
{
public:
	Cb (){printf("cb”);}
	void f(){printf("fb”);}
	void f1(){printf("fb1”);}
	void f2(int i=5){ this->f();printf("%d”,i);}
};
int main()
{
	Ca* p=NULL;
	Ca a;
	Cb b;
	p = &a;
	p->f();
	p->f1();
	p->f2();
	p = &b;
	p->f();
	p->f1();
	p->f2();
}

**通过基类指针只能访问派生类的成员变量，但是不能访问派生类的成员函数。**为了消除这种尴尬，让基类指针能够访问派生类的成员函数，C++ 增加了虚函数（Virtual Function）。有了虚函数，基类指针指向基类对象时就使用基类的成员（包括成员函数和成员变量），指向派生类对象时就使用派生类的成员。换句话说，基类指针可以按照基类的方式来做事，也可以按照派生类的方式来做事，它有多种形态，或者说有多种表现方式，我们将这种现象称为多态（Polymorphism）。

Ca
Ca
Cb
fa
fa1
fa3
fb
fa1
fb3

模拟题

两个字符串 start 和 target，长度均为n。每个字符串 仅 由字符’L’、‘R’ 和’_‘组成，其中:字符"L’ 和’R’ 表示片段，其中片段"L’只有在其左侧直接存在一个 空位 时才能向 左 移动，而片段’R’ 只有在其右侧直接存在一个 空位 时才能向 右 移动。字符’'表示可以被 任意 ‘L’或’R’ 片段占据的空位。如果在移动字符串 start 中的片段任意次之后可以得到字符串 target ，返回 true ;否则，返回 false 。
示例 1:
输入:start=“L___R___R”,target="L______RR"输出:true

示例 2:
输入:start=“R_L _”,target=" __LR"
输出:false解释:字符串 start 中的’R’ 片段可以向右移动一步得到"RL"但是，在这一步之后，不存在可以移动的片段，所以无法从字符串 start 得到 target 。
示例 3:输入:start="R",target="R"输出:false解释:字符串 start 中的片段只能向右移动，所以无法从字符串 start 得到 target 。
实现函数
bool canChange(char* start, char* target)，并说明思路

class Solution {
public:
    bool canChange(string start, string target) {
        if(start.size()!=target.size())return false;
        vector<pair<char,int>>s,t;
        for(int i=0;i<start.size();i++){
            if(start[i]!='_'){
                s.push_back(make_pair(start[i],i));
            }
            if(target[i]!='_'){
                t.push_back(make_pair(target[i],i));
            }
        }
        if(s.size()!=t.size())return false;
        for(int i=0;i<s.size();i++){
            if(s[i].first=='L' && s[i].second<t[i].second)return false;
            else if(s[i].first=='R' && s[i].second>t[i].second)return false;
            else if(s[i].first!=t[i].first)return false;
        }
        return true;
    }
};

将start和target数组里面的非’_'元素全存到vector<pair<char,int>>容器中，然后比较这两个容器，如果相同位置内容不同，则返回false；如果start代表的容器的’L’的下标位置小于target的位置，由于L不能右移，故返回false；同理start的R的位置大于target的R的位置则返回false；其他情况都是返回true。

链表题

leetcode 24 两两交换链表中的节点
https://leetcode.cn/problems/swap-nodes-in-pairs/description/?envType=study-plan-v2&envId=top-100-liked

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        ListNode* dummy=new ListNode(0);
        dummy->next=head;
        ListNode* cur=dummy;
        ListNode* pre=dummy;
        
        while(cur->next!=NULL && cur->next->next!=NULL)
        {
            pre=cur;
            cur=cur->next;

            ListNode* tmp=cur->next;
            cur->next=cur->next->next;
            tmp->next=cur;
            pre->next=tmp;   
        }

        ListNode* res=dummy->next;
        delete dummy;
        return res;
    }
};