【408_数据结构】历年真题代码大题

408数据结构历年真题代码大题

顺序表部分

• 后续可能会有其他章节，也许吧。。。

运行环境

• 408【数据结构】单链表_类模板_API模块-CSDN博客

• 408【数据结构】单链表_模板类_源码模块-CSDN博客

• 截图选自王道数据结构课后大题（侵权可删）

---

p17_10

/// @brief aux @b p17_10
/// @param beg 起始位置
/// @param end 末位置后一个位置
template<typename T>
void reverseRange(T* beg, T* end) {
	auto* tmp_beg = beg;
	auto* tmp_rbeg = end - 1;
	for(; tmp_beg <= tmp_rbeg; (void)++tmp_beg, (void)--tmp_rbeg)
		::swap(tmp_beg, tmp_rbeg);
}

/// @brief cskaoyan_data_structure_P17_10
template<typename T, std::int32_t Size>
void p17_10(T(&arr)[Size], size_t p) {
	reverseRange(arr + p, arr + Size);
	reverseRange(arr, arr + p);
	reverseRange(arr, arr + Size);
}

• $$\begin{gathered} Time:O(n) \\ Place:O(1) \end{gathered}$$

p17_11

• 1

/// @brief cskaoyan_data_structure_P17_11
/// @note TIME O(N) SPACE O(N)
/// s1 s2 必须等长
template<typename T, std::int32_t Size>
T p17_11(T(&s1)[Size], T(&s2)[Size]) {
	CHECK_N_PTR(s1);
	CHECK_N_PTR(s2);
	std::size_t n = Size << 1;
	T* tmp_arr = new T[n] {};
	CHECK_N_PTR(tmp_arr);
	T median {};
	std::size_t index(0), i(0), j(0);
	while(i != Size && j != Size) {
		if(s1[i] < s2[j])
			tmp_arr[index++] = s1[i++];
		else
			tmp_arr[index++] = s2[j++];
	}
	while(i != Size)
		tmp_arr[index++] = s1[i++];
	while(j != Size)
		tmp_arr[index++] = s2[j++];
	median = tmp_arr[(n >> 1) - 1];
	delete[] tmp_arr;
	tmp_arr = nullptr;
	return median;
}

• 2

/// @brief cskaoyan_data_structure_P17_11
/// @note TIME O(N) SPACE O(1)
/// s1 s2 必须等长
template<typename T, std::size_t Size>
T p17_11(T(&s1)[Size], T(&s2)[Size]) {
	CHECK_N_PTR(s1);
	CHECK_N_PTR(s2);
	std::size_t i(0), j(0);
	std::size_t count = 0;
	T median {};
	while(i != Size && j != Size) {
		if(s1[i] < s2[j]) {
			++count;
			median = s1[i];
			if(count != Size)
				++i;
			else
				break;
		} else {
			++count;
			median = s2[j];
			if(count != Size)
				++j;
			else
				break;
		}
	}
	return median;
}

p17_12

/// @brief cskaoyan_data_structure_P17_12
template<typename T, std::int32_t Size>
T p17_12(const T(&arr)[Size]) {
	T tmp {};
	std::size_t count = 0, mode_count = 0;
	for(std::size_t i = 0; i != Size; ++i) {
		if(count == 0)
			tmp = arr[i];
		if(arr[i] == tmp)
			++count;
		else
			--count;
	}
	//判断当前元素是否满足 M > N / 2
	for(std::size_t i = 0; i != Size; ++i) {
		if(arr[i] == tmp)
			++mode_count;
	}
	if(mode_count > (Size >> 1))
		return tmp;
	else
		return -1;
}

p18_13

/// @brief cskaoyan_data_structure_P18_13
template<typename T, std::int32_t Size>
T p18_13(T(&arr)[Size]) {
	//当前面没有空缺时，那么最小一定是最后一个元素
	T tmp_arr[Size + 1] {};
	std::int32_t index {};
	for(std::int32_t i = 0; i != Size; ++i) {
		if(arr[i] > 0)
			++tmp_arr[arr[i] - 1];
	}
	for(std::int32_t i = 0; i != Size + 1; ++i) {
		if(tmp_arr[i] == 0) {
			index = i;
			break;
		}
	}
	return index + 1;
}

p18_14

/// @brief 判断 @b a 是否是最小
bool is_min(int a, int b, int c) {
	return a <= b && a <= c;
}

/// @brief cskaoyan_data_structure_P18_14
/// @param arr1 第一组
/// @param size1 第一组大小
/// @param arr2 第二组
/// @param size2 第二组大小
/// @param arr3 第三组
/// @param size3 第三组大小
/// @return min D
int p18_14(int* arr1, int size1,
			int* arr2, int size2,
			int* arr3, int size3) { //
	int i = 0, j = 0, k = 0, d_min = INT32_MAX, d = 0;
	while(i != size1 && j != size2 && k != size3) {
		d = abs(arr1[i] - arr2[j])
			+ abs(arr2[j] - arr3[k])
			+ abs(arr3[k] - arr1[i]);
		if(d < d_min)
			d_min = d;
		if(is_min(arr1[i], arr2[j], arr3[k]))
			++i;
		else if(is_min(arr2[j], arr1[i], arr3[k]))
			++j;
		else
			++k;
	}
	return d_min;
}

• #include"link_list.hpp"

p39_22

/// @brief cskaoyan_data_structure_P39_22
int p39_22(int k, const LinkList<int>& li) {
	return li.back(k);
}

p39_23

/// @brief cskaoyan_data_structure_P39_23
int p39_23(const LinkList<int>& li1,
				const LinkList<int>& li2) {//
	const_pointer_type<int> head1 = li1.headNode(), head2 = li2.headNode();
	const_pointer_type<int> p = head1, q = head2;
	while(p != q) {
		if(p->next)
			p = p->next;
		else
			p = head2;
		if(q->next)
			q = q->next;
		else
			q = head1;
	}
	if(q)
		return q->data;
	return -1;
}

• test_data

void test() {
    LinkList<int> li1 {1,3,5,7,9};
    LinkList<int> li2 {0,2,4};
    pointer_type<int> p = li1.midPtr();
    li2.link(p);
    cout << p39_23(li1, li2) << "\n";
    p = nullptr;
    li2.link(p);
}

p40_24

/// @brief aux p40_24
/// @return 元素是否在hash表中存在
bool hashSearch(std::unordered_map<int, int>& hash, int target) {
	return hash[target] == 1;
}

/// @brief cskaoyan_data_structure_P40_24
void p40_24(LinkList<int>& x) {
	using pointer = LinkList<int>::pointer_type;
	pointer head = x.headNode();
	pointer prev = head, curr(nullptr);
	std::unordered_map<int, int> hash;
	//init hash table
	while(prev->next) {
		curr = prev->next;
		if(hashSearch(hash, abs(curr->data))) {
			curr = x.erease(curr);
			prev->next = curr;
		} else {
			hash[abs(curr->data)] = 1;
			prev = curr;
		}
	}
}

p40_25

/// @brief cskaoyan_data_structure_p40_25
void p40_25(LinkList<int>& lis) {
	pointer_type<int> mid_p = lis.midPtr();
	lis.reverse(mid_p);
	pointer_type<int> prev = lis.headNode()->next,
						curr = nullptr;
	while(mid_p->next) {
		curr = mid_p->next;
		mid_p->next = curr->next;
		curr->next = prev->next;
		prev->next = curr;
		prev = curr->next;
	}
}

void p40_25(LinkList& lis) {
pointer_type mid_p = lis.midPtr();
lis.reverse(mid_p);
pointer_type prev = lis.headNode()->next,
curr = nullptr;
while(mid_p->next) {
curr = mid_p->next;
mid_p->next = curr->next;
curr->next = prev->next;
prev->next = curr;
prev = curr->next;
}
}