笔试|蓝鸽|C++岗

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

---

前言

2022/4/14 vm

一、十六进制字符串转十进制整数

编写一个函数，函数接收一个字符串,是由十六进制数组成的一组字符串,函数的功能是把接到的这组字符串转换成十进制数字.并将十进制数字返回。

#include <iostream>
using namespace std;
// 十六进制字符串的最大长度
#define MAX_HEX_STR_LEN 8

bool hexToDec(char shex[], int & idec)
{
    size_t i = 0, len = 0;
    int mid = 0;
    len = strlen(shex);
    if (len > MAX_HEX_STR_LEN) {
        return false;
    }
    idec = 0;
    for (i = 0; i < len; i++) {
        mid = 0;
        if (shex[i] >= '0' && shex[i] <= '9') {
            mid = shex[i] - '0';
        } else if (shex[i] >= 'a' && shex[i] <= 'f') {
            mid = shex[i] - 'a' + 10;
        } else if (shex[i] >= 'A' && shex[i] <= 'F') {
            mid = shex[i] - 'A' + 10;
        } else {
            return false;
        }
        // 移位表示变为2的n次方倍
        mid <<= ((len - i - 1) << 2);
        idec += mid;
    }
    return true;
}


int main(int argc, char * argv[])
{
    int a = 0;
    char s[] = "fae3";
    hexToDec(s, a);
    cout << a << endl;
    return 0;
}

二、数组循环删

有一个数组，每隔两个数删掉一个数，到末尾又循环到开头继续进行，求最后一个被删除的数的原始下标位置

/**
 * 有一个数组a[N]，要求每隔两个数删掉一个数，到末尾则又循环到开头继续进行
 * 求最后一个被删掉的数的原始下标位置
 * 
 *  例如，一个数组：{0, 1, 2, 3, 4, 5, 6, 7} 
 *  0->1->2(第一遍，删除)->3->4->5(第一遍，删除)->6->7->
 *  0(第二遍，删除)->1->2(已删除)->3->4(第二遍，删除)->5(已删除)->6->7...
 *  循环直到数组中最后一个元素被删除
 *  
 *  当然，这里并未真正删除元素，只是用标志位表示已经被删除
 * 
 * @author Wll
 *
 */
public class DeleteEveryTwo {
	public static void main(String[] args) {
		int index = getLastDeletedIndex(8);
		System.out.println("The last index deleted is " + index);
	}
 
	/**
	 * 
	 * @param a
	 *            数组长度
	 * @return 最后被删除的数的原始下标
	 */
	public static int getLastDeletedIndex(int len) {
		if (len <= 0) { // 如果数组长度不满足要求则返回 -1
			return -1;
		}
 
		int[] arr = new int[len];
		for (int i = 0; i < len; i++) { // 初始化每个元素的值为当前下标
			arr[i] = len;
		}
 
		final int DELFLAG = len + 1; // 删除标志位
		int currentSize = len; // 记录数组当前有效长度（即未被置为删除标志的元素个数），最后变为 0
		final int STEP = 2; // 步长
		int count = 0; // 步长计数
		int lastDelIndex = 0; // 记录最后被删除的元素的下标
		int i = 0; // 循环下标
 
		while (currentSize != 0) {
			if (arr[i] != DELFLAG) { // 判读当前元素是否等于删除标志
				if (count++ == STEP) { // 当步长计数满足步长则
					arr[i] = DELFLAG; // 将元素置为删除标志位
					lastDelIndex = i; // 记录该处下标
					currentSize--; // 有效数组长度减 1
					count = 0; // 步长计数归零
					System.out.println("Deleted index is " + i % len);
				}
			}
			i = (i + 1) % len; // 下标取余实现循环下标
		}
		return lastDelIndex;
	}
}

三、 链表同data删除

有两个双向循环链表A，B，知道其头指针为：pHeadA,pHeadB，请写一函数将两链表中data值相同的结点删除

有双向循环链表结点定义为：

struct node
{ 
  int data;
  struct node *front,*next;
};
// 链表结点
template <typename T>
class dc_list_node
{
public:
    dc_list_node(const T &item = T(), dc_list_node<T> *p_front = NULL, dc_list_node<T> *p_next = NULL):
        m_item(item), mp_front(p_front), mp_next(p_next)
    {}
    
    T m_item;
    dc_list_node<T> *mp_front;
    dc_list_node<T> *mp_next;
private:
    dc_list_node(const dc_list_node<T> &);
    dc_list_node<T> &operator=(const dc_list_node<T> &);
};

有两个双向循环链表A，B，知道其头指针为：pHeadA,pHeadB，请写一函数将两链表中data值相同的结点删除。

用两个向量A_vec、B_vec分别存储链表A、B的元素值，将A_vec、B_vec排序，用类似归并排序的方法把A_vec、B_vec中值相同的元素放到向量common_vec中。分别遍历链表A、B，用二分查找法查看每个节点元素是否在common_vec中。

void dc_list_erase_node_with_equal_value(dc_list_node<int> *&p_headA, dc_list_node<int> *&p_headB)
{
    if (p_headA == NULL || p_headB == NULL)
        return;
    // A_vec存储链表A的元素值，B_vec存储链表B的元素值
    std::vector<int> A_vec, B_vec, common_vec;
    dc_list_node<int> *p_node;
    A_vec.push_back(p_headA->m_item);
    p_node = p_headA->mp_next;
    while (p_node != p_headA)
    {
        A_vec.push_back(p_node->m_item);
        p_node = p_node->mp_next;
    }
    B_vec.push_back(p_headB->m_item);
    p_node = p_headB->mp_next;
    while (p_node != p_headB)
    {
        B_vec.push_back(p_node->m_item);
        p_node = p_node->mp_next;
    }
    // 将A_vec和B_vec排序
    std::sort(A_vec.begin(), A_vec.end());
    std::sort(B_vec.begin(), B_vec.end());
    // 合并A_vec和B_vec相同的元素值到common_vec
    std::size_t i = 0, j = 0;
    while (i < A_vec.size() && j < B_vec.size())
    {
        if (A_vec[i] < B_vec[j])
            ++i;
        else if (A_vec[i] > B_vec[j])
            ++j;
        else
        {
            common_vec.push_back(A_vec[i]);
            ++i;
            ++j;
        }
    }
    // 分别遍历链表A和B，删除在元素值common_vec中的结点
    p_node = p_headA;
    for (i = 0; i < A_vec.size(); ++i)
    {
        if (std::binary_search(common_vec.begin(), common_vec.end(), p_node->m_item)) // 当前结点是值相同的结点
        {
            if (p_node == p_headA && p_node->mp_next == p_headA) // 链表中只有头结点一个结点
            {
                delete p_headA;
                p_headA = NULL;
                break;
            }
            else if (p_node == p_headA) // 当前结点是头结点
            {
                p_headA = p_node->mp_next;
                p_headA->mp_front = p_node->mp_front;
                p_node->mp_front->mp_next = p_headA;
                p_node = p_headA;
            }
            else
            {
                dc_list_node<int> *p_next = p_node->mp_next, *p_front = p_node->mp_front;
                p_next->mp_front = p_front;
                p_front->mp_next = p_next;
                delete p_node;
                p_node = p_next;
            }
        }
        else
            p_node = p_node->mp_next;
    }
    p_node = p_headB;
    for (i = 0; i < B_vec.size(); ++i)
    {
        if (std::binary_search(common_vec.begin(), common_vec.end(), p_node->m_item)) // 当前结点是值相同的结点
        {
            if (p_node == p_headB && p_node->mp_next == p_headB) // 链表中只有头结点一个结点
            {
                delete p_headB;
                p_headB = NULL;
                break;
            }
            else if (p_node == p_headB) // 当前结点是头结点
            {
                p_headB = p_node->mp_next;
                p_headB->mp_front = p_node->mp_front;
                p_node->mp_front->mp_next = p_headB;
                p_node = p_headB;
            }
            else
            {
                dc_list_node<int> *p_next = p_node->mp_next, *p_front = p_node->mp_front;
                p_next->mp_front = p_front;
                p_front->mp_next = p_next;
                delete p_node;
                p_node = p_next;
            }
        }
        else
            p_node = p_node->mp_next;
    }
}

---

总结

提示：这里对文章进行总结：
例如：以上就是今天要讲的内容，本文仅仅简单介绍了pandas的使用，而pandas提供了大量能使我们快速便捷地处理数据的函数和方法。