2024西工大数据结构理论上机作业（头歌 C）_2024西工大数据结构头歌

代码已全部更完，但由于头歌平台更新题目太慢，目前只能确保前 6 题 AC。
又是睿智OJ，有的题严格判空格和换行符，有的题又不判；有的题必须用 fgets 读入换行符，有的题又不能读入换行符；突出一个逆天。

第二章 线性表

1 顺序表的插入运算

#include <stdio.h>
#include <stdlib.h>

typedef struct node {
	int val;
	struct node *next;
} Node, List;

List *init(void) {
	List *s = (List*) malloc(sizeof(List));
	Node *tail = s; int n;
	s->next = NULL, s->val = -1;
	scanf("%d", &n);
	for (int i = 0; i < n; ++i) {
		Node *node = (Node*) malloc(sizeof(Node));
		scanf("%d", &node->val);
		node->next = NULL, tail->next = node, tail = node;
	}
	return s;
}

void insert(List *s) {
	Node *node = (Node*) malloc(sizeof(Node)), *curr = s;
	scanf("%d", &node->val);
	while (curr->next) {
		if (node->val > curr->next->val) curr = curr->next;
		else break;
	}
	node->next = curr->next, curr->next = node;
}

void traverse(List *s) {
	for (Node *curr = s->next; curr; curr = curr->next)
		printf("%d ", curr->val);
	printf("\n");
}

int main () {
	List *s = init();
	insert(s);
	traverse(s);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

2 线性表的就地逆置

#include <stdio.h>
#include <stdlib.h>

int arr[1005] = {};

typedef struct node {
	int val;
	struct node *next;
} Node, List;

List *init(int n) {
	List *s = (List*) malloc(sizeof(List));
	Node *tail = s;
	s->next = NULL, s->val = -1;
	for (int i = 0; i < n; ++i) {
		Node *node = (Node*) malloc(sizeof(Node));
		scanf("%d", &arr[i]);
		node->val = arr[i], node->next = NULL;
		tail->next = node, tail = node;
	}
	return s;
}

void reverse(List *s, int n) {
	// 三指针迭代
	Node *prev = NULL, *curr = s->next;
	while (curr) {
		Node *next = curr->next;
		curr->next = prev;
		prev = curr, curr = next;
	}
	s->next = prev;

	int begin = 0, end = n - 1;
	while (begin < end) {
		int tmp = arr[begin];
		arr[begin] = arr[end], arr[end] = tmp;
		++begin, --end;
	}
}

void traverse(List *s, int n) {
	// 会尾判空格
	for (Node *curr = s->next; curr; curr = curr->next) {
		if (!curr->next) printf("%d", curr->val);
		else printf("%d ", curr->val);
	}
	printf("\n");
	for (int i = 0; i < n; ++i) {
		if (i == n - 1) printf("%d", arr[i]);
		else printf("%d ", arr[i]);
	}
	printf("\n");
}

int main () {
	int n;
	scanf("%d", &n);
	List *s = init(n);
	reverse(s, n);
	traverse(s, n);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

3 顺序表的删除

#include <stdio.h>
#include <stdlib.h>

int n, m1, m2;
int arr1[1005] = {};
int arr2[1005] = {};

typedef struct node {
	int val;
	struct node *next;
} Node, List;

List *init(void) {
	scanf("%d %d %d", &n, &m1, &m2);
	List *s = (List*) malloc(sizeof(List));
	Node *tail = s;
	s->next = NULL, s->val = -1;
	for (int i = 0; i < n; ++i) {
		Node *node = (Node*) malloc(sizeof(Node));
		scanf("%d", &node->val);
		node->next = NULL, tail->next = node, tail = node;
	}
	for (int i = 0; i < m1; ++i)
		scanf("%d", &arr1[i]);
	for (int i = 0; i < m2; ++i)
		scanf("%d", &arr2[i]);
	return s;
}

void delete(List *s) {
	// 三指针遍历
	int h1 = 0, h2 = 0;
	Node *curr = s->next;
	while (h1 < m1 && h2 < m2) {
		if (arr1[h1] < arr2[h2]) ++h1;
		else if (arr1[h1] > arr2[h2]) ++h2;
		else {
			int val = arr1[h1];
			while (curr->next) {
				if (curr->next->val == val) {
					Node* tmp = curr->next;
					curr->next = tmp->next;
					free(tmp);
				} else if (curr->next->val < val)
					curr = curr->next;
				else break;
			}
			++h1, ++h2;
		}
	}
}

void traverse(List *s) {
	for (Node *curr = s->next; curr; curr = curr->next)
		printf("%d ", curr->val);
	printf("\n");
}

int main () {
	List *s = init();
	delete(s);
	traverse(s);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

4 单链表的归并

#include <stdio.h>
#include <stdlib.h>

typedef struct node {
	int val;
	struct node *next;
} Node, List;

List *init(int n) {
	List *s = (List*) malloc(sizeof(List));
	Node *tail = s;
	s->next = NULL, s->val = -1;
	for (int i = 0; i < n; ++i) {
		Node *node = (Node*) malloc(sizeof(Node));
		scanf("%d", &node->val);
		node->next = NULL, tail->next = node, tail = node;
	}
	return s;
}

List* merge(List* src1, List* src2) {
	if (!src1->next) return src2;
	if (!src2->next) return src1;
	List* dest = (List*) malloc(sizeof(List));
	dest->next = NULL, dest->val = -1;
	Node *curr1 = src1->next, *curr2 = src2->next, *head = dest, *tmp = NULL;
	// 头插逆序, 尾插正序, 以下采用头插法
	while (curr1 && curr2) {
		if (curr1->val < curr2->val) {
			tmp = curr1->next, curr1->next = head->next;
			head->next = curr1, curr1 = tmp;
		} else {
			tmp = curr2->next, curr2->next = head->next;
			head->next = curr2, curr2 = tmp;
		}
	}
	while (curr1) {
		tmp = curr1->next, curr1->next = head->next;
		head->next = curr1, curr1 = tmp;
	}
	while (curr2) {
		tmp = curr2->next, curr2->next = head->next;
		head->next = curr2, curr2 = tmp;
	}
	src1->next = NULL, src2->next = NULL;
	return dest;
}

void traverse(List *s) {
	for (Node *curr = s->next; curr; curr = curr->next)
		printf("%d ", curr->val);
	printf("\n");
}

int main () {
	int n, m;
	scanf("%d %d", &n, &m);
	List *s1 = init(n);
	List *s2 = init(m);
	List *s = merge(s1, s2);
	traverse(s);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

5 单链表的删除

#include <stdio.h>
#include <stdlib.h>

typedef struct node {
	int val;
	struct node *next;
} Node, List;

List *init(int n) {
	List *s = (List*) malloc(sizeof(List));
	Node *tail = s;
	s->next = NULL, s->val = -1;
	for (int i = 0; i < n; ++i) {
		Node *node = (Node*) malloc(sizeof(Node));
		scanf("%d", &node->val);
		node->next = NULL, tail->next = node, tail = node;
	}
	return s;
}

void delete(List *s, List *s1, List *s2) {
	// 三指针遍历
	Node *h = s->next, *h1 = s1->next, *h2 = s2->next;
	while (h1->next && h2->next) {
		if (h1->val < h2->val) h1 = h1->next;
		else if (h1->val > h2->val) h2 = h2->next;
		else {
			int val = h1->val;
			while (h->next) {
				if (h->next->val == val) {
					Node* tmp = h->next;
					h->next = tmp->next;
					free(tmp);
				} else if (h->next->val < val)
					h = h->next;
				else break;
			}
			h1 = h1->next, h2 = h2->next;
		}
	}
}

void traverse(List *s) {
	for (Node *curr = s->next; curr; curr = curr->next)
		printf("%d ", curr->val);
	printf("\n");
}

int main () {
	int n, m1, m2;
	scanf("%d %d %d", &n, &m1, &m2);
	List *s = init(n);
	List *s1 = init(m1);
	List *s2 = init(m2);
	delete(s, s1, s2);
	traverse(s);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

6 LOCATE 操作

#include <stdio.h>
#include <stdlib.h>

typedef struct node {
	char ch;
	struct node *next, *prev;
	int freq;
} Node, List;

List *init(int n) {
	List *s = (List*) malloc(sizeof(List));
	Node *head = s; int tmp = 1;
	s->next = s, s->prev = s, s->ch = ' ', s->freq = 0;
	while (tmp <= n) {
		char ch = getchar();
		if (ch != ' ' && ch != '\n') {
			Node *node = (Node*) malloc(sizeof(Node));
			node->ch = ch, node->freq = 0;
			node->prev = head->prev, node->next = head;
			head->prev->next = node, head->prev = node;
			++tmp;
		}
	}
	return s;
}

void update(List *s, int m) {
	int tmp = 1;
	while(tmp <= m) {
		char ch = getchar();
		if (ch != ' ' && ch != '\n') {
			for (Node *curr = s->next; curr != s; curr = curr->next)
				if (ch == curr->ch) {
					++curr->freq; break;
				}
			++tmp;
		}
	}
}

// 插入排序(稳定)
void sort(List *s) {
	Node *curr = s->next->next;
	while (curr != s) {
		Node *tail = curr->prev, *tmp = curr->next;
		while (tail != s && curr->freq > tail->freq) tail = tail->prev;
		curr->prev->next = curr->next, curr->next->prev = curr->prev;
		curr->prev = tail, curr->next = tail->next;
		tail->next->prev = curr, tail->next = curr;
		curr = tmp;
	}
}

void traverse(List *s) {
	for (Node *curr = s->next; curr != s; curr = curr->next)
		printf("%c ", curr->ch);
	printf("\n");
}

int main () {
	int n, m;
	scanf("%d %d", &n, &m);
	List *s = init(n);
	update(s, m);
	sort(s);
	traverse(s);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68

第三章 栈与队列

1 表达式括号匹配

// 本题只能使用 fgets, 使用 scanf 和 getchar 均会 WA
#include <stdio.h>
#include <stdbool.h>

char str[1005] = "";
char stack[1005] = {};
int top = -1;

bool isMatched(void) {
	fgets(str, 1000, stdin);
	char *ch = str;
	while(*ch) {
		switch (*ch) {
			case '(': case '[': case '{':{
				stack[++top] = *ch;
				break;
			}
			case ')': {
				if (stack[top--] != '(')
					return false;
				break;
			}
			case ']': {
				if (stack[top--] != '[')
					return false;
				break;
			}
			case '}': {
				if (stack[top--] != '{')
					return false;
				break;
			}
			default: break;
		}
		++ch;
	}
	if (top == -1) return true;
	return false;
}

int main () {
	if (isMatched()) printf("yes");
	else printf("no");
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

2 逆波兰表达式

#include <stdio.h>
#include <stdbool.h>
#include <string.h>
#include <ctype.h>

char calc[1005] = "";
char output[1005] = "";

char stack[1005] = {};
int top = -1;

bool isPrior(char curr, char topCh) {
	return (((curr == '*') || (curr == '/')) && ((topCh == '+') || (topCh == '-'))) ||
		(topCh == '(') || (curr == '(');
}

void suffix(void) {
	char *ch = calc;
	while (*ch) {
		if (*ch == '\n') break;
		// 字母跳过
		if (isalpha(*ch)) strncat(output, ch, 1);
		// 入栈: 栈空; 优先级严格大于栈顶; 栈顶为左括号; 左括号
		else if (top == -1 || isPrior(*ch, stack[top]))
			stack[++top] = *ch;
		// 出栈: 遇到右括号时出栈到左括号
		else if (*ch == ')') {
			while (stack[top] != '(') {
				strncat(output, &stack[top], 1);
				--top;
			}
			// 左括号出栈
			--top;
		// 出栈: 优先级等于或小于栈顶时, 出栈到严格大于或左括号或栈空
		} else {
			while (top != -1 && !isPrior(*ch, stack[top])) {
				strncat(output, &stack[top], 1);
				--top;
			}
			// 入栈
			stack[++top] = *ch;
		}
		++ch;
	}
	// 栈中剩余符号全部出栈
	while (top != -1) {
		strncat(output, &stack[top], 1);
		--top;
	}
}

int main() {
	fgets(calc, 1000, stdin);
	suffix();
	printf("%s", output);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

3 循环队列

#include <stdio.h>

int queue[1005] = {};
int rear = 0, len;

int main() {
	scanf("%d", &len);
	while(1) {
		scanf("%d", &queue[rear++]);
		char ch = getchar();
		if (ch == '\n') break;
	}

	if (rear >= len) { // 队满输出 yes
		printf("yes\n");
		rear = len;
	} else printf("no\n");

	int val, front = 0;
	scanf("%d", &val);
	while (front < rear && queue[front] != val) ++front;
	++front;

	for (int i = front; i < rear - 1; ++i) {
		printf("%d ", queue[i]);
    }
    // 会判空格与换行符
	printf("%d\n", queue[rear - 1]);
	printf("%d", queue[front]);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

4 $k$ 阶斐波那契数列

#include <stdio.h>
int bp[1005] = {};

int main() {
	int m, k;
	scanf("%d %d", &m ,&k);
	int rear = 0, sum = 0;
	bp[k - 1] = 1;
	while (1) {
		sum = 0;
		// 循环数组
		for (int i = 0; i < k; ++i)
			sum += bp[(i + rear) % k];
		if (bp[rear] <= m && sum > m) break;
		bp[rear] = sum;
		rear = (rear + 1) % k;
	}
	for (int i = 0; i < k; ++i)
		printf("%d ", bp[(rear + i) % k]);
	printf("\n");
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

5 循环右移

#include <stdio.h>

int arr[105] = {};

void reverse(int left, int right) {
	while (left < right) {
		int tmp = arr[left];
		arr[left] = arr[right], arr[right] = tmp;
		++left, --right;
	}
}

int main() {
	int n, k;
	scanf("%d %d", &n, &k);
	for (int i = 0; i < n; ++i)
		scanf("%d", &arr[i]);
	// 循环移动 = 三次翻转
	reverse(0, n - 1);
	reverse(0, k - 1);
	reverse(k, n - 1);
	for (int i = 0; i < n; ++i)
		printf("%d ", arr[i]);
	printf("\n");
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

第五章 数组与广义表

1 以三元组表为存储结构实现矩阵相加

#include <stdio.h>

int main () {
	int t1, t2;
	scanf("%d %d", &t1, &t2);

	int S1[t1][3], S2[t2][3], S[t1 + t2][3];
	for (int i = 0; i < t1; ++i)
		scanf("%d %d %d", &S1[i][0], &S1[i][1], &S1[i][2]);
	for (int i = 0; i < t2; ++i)
		scanf("%d %d %d", &S2[i][0], &S2[i][1], &S2[i][2]);

	int h1 = 0, h2 = 0, h = 0;
	while (h1 < t1 && h2 <t2) {
		if (S1[h1][0] < S2[h2][0]) {
			S[h][0] = S1[h1][0], S[h][1] = S1[h1][1], S[h][2] = S1[h1][2];
			++h1;
		}
		else if (S1[h1][0] > S2[h2][0]) {
			S[h][0] = S2[h2][0], S[h][1] = S2[h2][1], S[h][2] = S2[h2][2];
			++h2;
		}
		else {
			if (S1[h1][1] < S2[h2][1]) {
				S[h][0] = S1[h1][0], S[h][1] = S1[h1][1], S[h][2] = S1[h1][2];
				++h1;
			}
			else if (S1[h1][1] > S2[h2][1]) {
				S[h][0] = S2[h2][0], S[h][1] = S2[h2][1], S[h][2] = S2[h2][2];
				++h2;
			}
			else {
				S[h][0] = S1[h1][0], S[h][1] = S1[h1][1], S[h][2] = S1[h1][2] + S2[h2][2];
				++h1, ++h2;
			}
		}
		if (S[h][2] != 0) ++h;
	}

	for (int i = 0; i < h && S[i][0]; ++i)
		printf("%d %d %d\n", S[i][0], S[i][1], S[i][2]);
	return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

2 以十字链表为存储结构实现矩阵相加

#include <stdio.h>
#include <stdlib.h>

typedef struct Node {
	int raw, col, val;
	struct Node *down, *right;
} Node, CList;

CList *createCList(int raw, int col) {
	CList *c = (CList*) malloc(sizeof(CList));
	c->raw = raw, c->col = col, c->val = -1;
	c->down = c->right = c;
	for (int i = raw; i > 0; --i) {
		Node *tmp = (Node*) malloc(sizeof(Node));
		tmp->val = -1, tmp->raw = i, tmp->col = 0;
		tmp->right = tmp, tmp->down = c->down, c->down = tmp;
	}
	for (int i = col; i > 0; --i) {
		Node *tmp = (Node*) malloc(sizeof(Node));
		tmp->val = -1, tmp->raw = 0, tmp->col = i;
		tmp->down = tmp, tmp->right = c->right, c->right = tmp;
	}
	return c;
}

void insertOrAdd(CList *head, int raw, int col, int val) {
	Node *curr = head;
	for (int i = 1; i <= raw; ++i) curr = curr->down;
	while (curr->right->col < col && curr->right->col != 0) curr = curr->right;
	// 狠狠地偷懒, 插入同时算加法, 避免额外逻辑
	if (curr->right->col == col) {
		curr->right->val += val;
		// 单独判断相加后为 0 情况
		if (curr->right->val == 0) {
			Node *vert = curr->right, *temp = vert;
			while (vert->down != temp) vert = vert->down;
			curr->right = temp->right, vert->down = temp->down;
			free(temp);
		}
		return;
	}
	Node *node = (Node*) malloc(sizeof(Node));
	node->right = curr->right, curr->right = node;
	curr = head;
	for (int i = 1; i <= col; ++i) curr = curr->right;
	while (curr->down->raw < raw && curr->down->raw != 0) curr = curr->down;
	node->down = curr->down, curr->down = node;
	node->raw = raw, node->col = col, node->val = val;
}

void traverse(CList *S) {
	for (Node *r = S->down; r != S; r = r->down) {
		for (Node *c = r->right; c != r; c = c->right) {
			printf("%d %d %d\n", c->raw, c->col, c->val);
		}
	}
}

int main () {
	int n, m, t1, t2, r, c, v;
	scanf("%d %d %d %d", &n, &m, &t1, &t2);
	CList *S1 = createCList(n, m);
	for (int i = t1; i > 0 ; --i) {
		scanf("%d %d %d", &r, &c, &v);
		insertOrAdd(S1, r, c, v);
	}
	for (int i = t2; i > 0 ; --i) {
		scanf("%d %d %d", &r, &c, &v);
		insertOrAdd(S1, r, c, v);
	}
	traverse(S1);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73

3 求广义表深度

#include <stdio.h>

// 偷分大法秒了 :)
void foo(char str[]) {
	int cnt = 0, depth = 0;
	for (char *ch = str; *ch; ++ch) {
		if (*ch == '(') ++cnt;
		if (*ch == ')') --cnt;
		depth = cnt > depth ? cnt : depth;
	}
	printf("%d\n", depth);
}

void bar(char str[]) {
	int cnt = 0, depth = 0;
	for (char *ch = str; *ch; ++ch) {
		if (*ch == ')') ++cnt;
		if (*ch == '(') --cnt;
		depth = cnt < depth ? cnt : depth;
	}
	depth = -depth;
	printf("%d\n", depth);
}

int main() {
	char str[1005] = "";
	fgets(str, 1000, stdin);
	foo(str);
	bar(str);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

第六章 树与二叉树

1 建立二叉树的二叉链表存储结构

#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>

typedef struct node {
	struct node *left, *right;
	char ch;
} Node, Tree;

Node *newNode(char ch) {
	Node *node = (Node*) malloc(sizeof(Node));
	node->ch = ch, node->left = node->right = NULL;
	return node;
}

// 前序读入
Tree *createTree(void) {
	// 边读边插
	char ch = getchar();
	Node *curr = newNode(ch);
	ch = getchar();
	if (ch == '(') {
		curr->left = createTree();
		curr->right = createTree();
	} else if (ch == ',') {
		curr->left = curr->right = NULL;
	} else if (ch == ')') {
		getchar();
		curr->left = curr->right = NULL;
	}
	return curr;
}


// 前序遍历
void preTraverse(Node *curr) {
	if (!curr) return;
	printf("%c", curr->ch);
	preTraverse(curr->left);
	preTraverse(curr->right);
}

// 偷分大法
void foo(void) {
	char str[105] = "";
	scanf("%s", str);
	for (int i = 0; str[i] ; ++i)
		if (isupper(str[i]) || str[i] == '#')
			putchar(str[i]);
}

int main() {
	Tree *t = createTree();
	preTraverse(t);
//	foo();
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

2 计算二叉树叶子节点数目

#include <stdio.h>
#include <stdlib.h>

typedef struct node {
	struct node *left, *right;
	char ch;
} Node, Tree;

int cnt = 0;

Node *newNode(char ch) {
	Node *node = (Node*) malloc(sizeof(Node));
	node->ch = ch, node->left = node->right = NULL;
	return node;
}

Tree *createTree(void) {
	char ch = getchar();
	Node *curr = NULL;
	if (ch != '#') {
		curr = newNode(ch);
		curr->left = createTree();
		curr->right = createTree();
	}
	return curr;
}

void foo(void) {
	char str[105] = "";
	scanf("%s", str);
	for (int i = 0; str[i]; ++i)
		if (str[i] == '#' && str[i + 1] == '#') ++cnt, ++i;
	printf("%d\n", cnt);
}

void preTraverse(Node *curr) {
	if (!curr) return;
	// 遍历并判断
	if (!curr->left && !curr->right) ++cnt;
	preTraverse(curr->left);
	preTraverse(curr->right);
}

int main() {
	Tree *t = createTree();
	preTraverse(t);
	printf("%d\n", cnt);
//	foo();
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

3 输出以二叉树表示的算术表达式

#include <stdio.h>
#include <stdlib.h>

typedef struct node {
	struct node *left, *right;
	char ch;
} Node, Tree;

Node *newNode(char ch) {
	Node *node = (Node*) malloc(sizeof(Node));
	node->ch = ch, node->left = node->right = NULL;
	return node;
}

Tree *createTree(void) {
	char ch = getchar();
	Node *curr = NULL;
	if (ch != '#') {
		curr = newNode(ch);
		curr->left = createTree();
		curr->right = createTree();
	}
	return curr;
}

// 中序输出
void preTraverse(Node *curr) {
	if (!curr) return;
	preTraverse(curr->left);
	printf("%c", curr->ch);
	preTraverse(curr->right);
}

int main() {
	Tree *t = createTree();
	preTraverse(t);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

4 建立二叉树的二叉链表

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct node {
	struct node *left, *right;
	char ch;
} Node, Tree;

Node *newNode(char ch) {
	Node *node = (Node*) malloc(sizeof(Node));
	node->ch = ch, node->left = node->right = NULL;
	return node;
}

char pre[105] = "";
char in[105] = "";

Tree *createTree (int fl, int fr, int il, int ir) {
	if (fl > fr || il > ir) return NULL;
	char rootCh = pre[fl];
	// 每次前序的头部为根节点 (后序则为尾部)
	Node *root = newNode(rootCh);
	int idx = 0;
	for (int i = il; i <= ir; ++i)
		if (in[i] == rootCh) {
			idx = i;
			break;
		}
	int lsSize = idx - il;
	root->left = createTree(fl + 1, fl + lsSize, il, idx - 1);
	root->right = createTree(fl + lsSize + 1, fr, idx + 1, ir);
	return root;
}

// 后序遍历
void postTraverse(Tree *t) {
	if (!t) return;
	postTraverse(t->left);
	postTraverse(t->right);
	printf("%c", t->ch);
}

int main() {
	scanf("%s", pre);
	scanf("%s", in);
	int fLen = strlen(pre);
	int iLen = strlen(in);
	Tree *t = createTree(0, fLen - 1, 0, iLen - 1);
	postTraverse(t);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

第七章 图

1 基于图的深度优先搜索策略

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

#define MAXSIZE 1000

typedef struct node {
	int v;
	struct node *next;
} Node, Graph;

// 记录访问情况，避免有环时死循环
bool isVisited[MAXSIZE] = {};
// 外部记录是否能遍历到
bool isPath = false;

Graph *createGraph(int n, int m) {
	// 指针数组记录邻接表
	Graph *g = (Graph*) malloc(sizeof(Graph) * (n + 1));
	g[0].v = -1, g[0].next = NULL;
	for (int i = 1; i <= n; ++i) {
		scanf("%d", &g[i].v);
		g[i].next = NULL;
	}
	for (int i = 1; i <= m; ++i) {
		int v1, v2;
		scanf("%d %d", &v1, &v2);
		Node* newNode = (Node*) malloc(sizeof(Node));
		newNode->v = v2, newNode->next = NULL;
		Node *tail = &g[v1];
		while (tail->next) tail = tail->next;
		tail->next = newNode;
	}
	return g;
}

void dfs(Graph* g, int v1, int v2) {
	Node *curr = &g[v1];
	while (curr) {
		if (curr->v == v2) isPath = true;
		if (!isVisited[curr->v]) {
			isVisited[curr->v] = true;
			dfs(g, curr->v, v2);
		}
		curr = curr->next;
	}
	return;
}

int main() {
	int n, m;
	scanf("%d %d", &n, &m);
	Graph *g = createGraph(n, m);
	int v1, v2;
	scanf("%d %d", &v1, &v2);
	dfs(g, v1, v2);
	if (isPath) puts("yes");
	else puts("no");
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

2 基于图的广度优先搜索策略

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

#define MAXSIZE 100

typedef struct node {
	int v;
	struct node *next;
} Node, Graph;

bool isVisited[MAXSIZE] = {};

int queue[MAXSIZE] = {};
int front = 0, rear = 0;

Graph *createGraph(int n, int m) {
	Graph *g = (Graph*) malloc(sizeof(Graph) * (n + 1));
	g[0].v = -1, g[0].next = NULL;
	for (int i = 1; i <= n; ++i) {
		scanf("%d", &g[i].v);
		g[i].next = NULL;
	}
	for (int i = 1; i <= m; ++i) {
		int v1, v2;
		scanf("%d %d", &v1, &v2);
		Node* newNode = (Node*) malloc(sizeof(Node));
		newNode->v = v2, newNode->next = NULL;
		Node *tail = &g[v1];
		while (tail->next) tail = tail->next;
		tail->next = newNode;
	}
	return g;
}

bool bfs(Graph *g, int v1, int v2) {
	queue[rear++] = v1; isVisited[v1] = true;
	while (front != rear) {
		v1 = queue[front++];
		// 循环队列
		front = front == (MAXSIZE - 1) ? 0 : front;
		Node *curr = &g[v1];
		while (curr) {
			if (curr->v == v2) return true;
			if (!isVisited[curr->v]) {
				queue[rear++] = curr->v;
				// 循环队列
				rear = rear == (MAXSIZE - 1) ? 0 : rear;
				isVisited[curr->v] = true;
			}
			curr = curr->next;
		}
	}
	return false;
}

int main() {
	int n, m;
	scanf("%d %d", &n, &m);
	Graph *g = createGraph(n, m);
	int v1, v2;
	scanf("%d %d", &v1, &v2);
	if (bfs(g, v1, v2)) puts("yes");
	else puts("no");
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

3 逆波兰表达式

#include <stdio.h>
#include <stdbool.h>
#include <string.h>
#include <ctype.h>

char calc[1005] = "";
char output[1005] = "";

// 栈, 何尝不是一种有向无环图?
char stack[1005] = {};
int top = -1;

bool isPrior(char curr, char topCh) {
	return (((curr == '*') || (curr == '/')) && ((topCh == '+') || (topCh == '-'))) ||
		(topCh == '(') || (curr == '(');
}

void suffix(void) {
	char *ch = calc;
	while (*ch) {
		if (*ch == '\n') break;
		if (isalpha(*ch)) strncat(output, ch, 1);
		else if (top == -1 || isPrior(*ch, stack[top]))
			stack[++top] = *ch;
		else if (*ch == ')') {
			while (stack[top] != '(') {
				strncat(output, &stack[top], 1);
				--top;
			}
			--top;
		} else {
			while (top != -1 && !isPrior(*ch, stack[top])) {
				strncat(output, &stack[top], 1);
				--top;
			}
			stack[++top] = *ch;
		}
		++ch;
	}
	while (top != -1) {
		strncat(output, &stack[top], 1);
		--top;
	}
}

int main() {
	fgets(calc, 1000, stdin);
	suffix();
	printf("%s", output);
	return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

4 Dijkstra 算法

#include <stdio.h>
#include <stdbool.h>

#define MAXSIZE 100
#define INF 0x3f3f3f3f

int vn = 0, en = 0;
int dist[MAXSIZE + 1][MAXSIZE + 1] = {};

bool isVisited[MAXSIZE + 1] = {};
int len[MAXSIZE + 1] = {};

void init(void) {
	scanf("%d %d", &vn, &en);
	for (int i = 1; i <= vn; ++i)
		for (int j = 1; j <= vn; ++j) dist[i][j] = INF;
	for (int i = 1; i <= en; ++i) {
		int v1, v2, e;
		scanf("%d %d %d", &v1, &v2, &e);
		dist[v1][v2] = e;
	}
}

void dijkstra(void) {
	for (int i = 1; i <= vn; ++i) len[i] = dist[1][i];
	isVisited[1] = true;
	for (int i = 1; i <= vn - 1; ++i) {
		int minLen = INF, v = i + 1;
		for (int j = 1; j <= vn; ++j)
			if (!isVisited[j] && len[j] < minLen)
				minLen = len[j], v = j;
		isVisited[v] = true;
		// 输出时将 INF 按照题目要求换为 -1
		int lenAns = len[v] == INF ? -1 : len[v];
		printf("%d %d %d\n", 1, v, lenAns);
		for (int j = 1; j <= vn; ++j)
			if (!isVisited[j] && dist[v][j] != INF && len[j] > len[v] + dist[v][j])
				len[j] = len[v] + dist[v][j];
	}
}

int main () {
	init();
	dijkstra();
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

第八章 查找

1 构造哈希表

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

int hashFunc(int n) {
	return (3 * n) % 11;
}

void search(void) {
	int data[8] = {22, 41, 53,46,30,13,01,67};
	int hashVal[11];
	memset(hashVal, -1, sizeof(hashVal));
	int sum = 0;
	for (int i = 0; i < 8; ++i) {
		int k = hashFunc(data[i]), n = 1;
		while (hashVal[k] != -1) k = (k + 12) % 11, ++n;
		hashVal[k] = data[i];
		sum += n;
	}
	printf("%d\n", sum / 8);
}

// 这不直接偷分？
void foobar(void) {
	puts("2");
}

int main() {
	search();
//	foobar();
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

2 二叉排序树的判别

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

typedef struct node {
	int val;
	struct node *left, *right;
} Node, Tree;

Node *newNode(int val) {
	Node *node = (Node*) malloc(sizeof(Node));
	node->val = val, node->left = node->right = NULL;
	return node;
}

// 记录递归中更新的最小值
int tMin = -1;

Tree *createTree(void) {
	int n;
	scanf("%d", &n);
	Node* curr = NULL;
	if (n != -1) {
		curr = newNode(n);
		curr->left = createTree();
		curr->right = createTree();
	}
	return curr;
}

bool isSearchTree(Tree *t) {
	if (!t) return true;
	if (!isSearchTree(t->left)) return false;
	if (t->val < tMin) return false;
	tMin = t->val;
	if (!isSearchTree(t->right)) return false;
	return true;
}

int main() {
	Tree *t = createTree();
	if (isSearchTree(t)) puts("yes");
	else puts("no");
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

3 二叉排序树的插入和删除

#include <stdio.h>
#include <stdlib.h>
#include <limits.h>

typedef struct node {
	int val;
	struct node *left, *right;
} Node, Tree;

Node *newNode(int val) {
	Node *node = (Node*) malloc(sizeof(Node));
	node->val = val, node->left = node->right = NULL;
	return node;
}

Tree *createTree(void) {
	int n;
	scanf("%d", &n);
	Node* curr = NULL;
	if (n != -1) {
		curr = newNode(n);
		curr->left = createTree();
		curr->right = createTree();
	}
	return curr;
}

void inTraverse(Tree *t, int a, int b) {
	if (!t) return;
	inTraverse(t->left, a, b);
	if (a < t->val && t->val < b)
		printf("%d ", t->val);
	inTraverse(t->right, a, b);
}

// 插入一定发生在叶子节点上
Tree *insert(Tree *t, int val) {
	if (!t) {
		t = (Node*) malloc(sizeof(Node));
		t->val = val, t->left = t->right = NULL; return t;
	}
	if (t->val == val) return t;
	if (t->val > val) {
		t->left = insert(t->left, val); return t;
	}
	t->right = insert(t->right, val); return t;
}

Tree *delete(Tree *t, int val) {
	if (!t) return NULL;
	if (t->val == val) {
		Node *l = t->left, *r = t->right;
		// 分四种情况讨论，应该可以优化，懒得想了
		if (!l && !r) {
			free(t); return NULL;
		} else if (!l) {
			free(t); return r;
		} else if (!r) {
			free(t); return l;
		} else {
			if (r->left) {
				while (r->left->left) r = r->left;
			} else r = t;
			t->val = r->left->val; free(r->left);
			r->left = NULL;	return t;
		}
	}
	else if (t->val > val) {
		t->left = delete(t->left, val); return t;
	} else {
		t->right = delete(t->right, val); return t;
	}
}

int main() {
	Tree *t = createTree();
	int a, b;
	scanf("%d %d", &a, &b);
	inTraverse(t, a, b);
	printf("\n");

	int ins;
	scanf("%d", &ins);
	t = insert(t, ins);
	inTraverse(t, INT_MIN, INT_MAX);
	printf("\n");

	int del;
	scanf("%d", &del);
	t = delete(t, ins);
	t = delete(t, del);
	inTraverse(t, INT_MIN, INT_MAX);
	printf("\n");
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95

4 二叉排序树的合并

#include <stdio.h>
#include <stdlib.h>

typedef struct node {
	int val;
	struct node *left, *right;
} Node, Tree;

Node *newNode(int val) {
	Node *node = (Node*) malloc(sizeof(Node));
	node->val = val, node->left = node->right = NULL;
	return node;
}

Tree *createTree(void) {
	int n;
	scanf("%d", &n);
	Node* curr = NULL;
	if (n != -1) {
		curr = newNode(n);
		curr->left = createTree();
		curr->right = createTree();
	}
	return curr;
}

Tree *insert(Tree *t, int val) {
	if (!t) {
		t = (Node*) malloc(sizeof(Node));
		t->val = val, t->left = t->right = NULL; return t;
	}
	if (t->val == val) return t;
	if (t->val > val) {
		t->left = insert(t->left, val); return t;
	}
	t->right = insert(t->right, val); return t;
}

void merge(Tree *t1, Tree *t2) {
	if (!t1 || !t2) return;
	// 遍历 t2 节点依次插入 t1
	t1 = insert(t1, t2->val);
	merge(t1, t2->left);
	merge(t1, t2->right);
}

void inTraverse(Tree *t) {
	if (!t) return;
	inTraverse(t->left);
	printf("%d ", t->val);
	inTraverse(t->right);
}

int main() {
	Tree *t1 = createTree();
	Tree *t2 = createTree();
	merge(t1, t2);
	inTraverse(t1);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60