c 语言基础知识

1
2
3
4
5
6
7
8
9
10
11
#include <iostream>
#include <string>

#define STR(s) #s
#define CONV(a, b) (a##e##b)

int main() {
    std::cout << STR(12345) << std::endl;
    std::cout << CONV(2, 3) << std::endl;
    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
#include <iostream>

int trim_space(char* s) {
    if (s == nullptr) {
        return 0;
    }

    char* p = s;
    int space_cnt = 0;

    while (*s != '\0') {
        if (*s == ' ') {
            s++;
            space_cnt++;
        } else {
            if (p != s) {
                *p++ = *s++;
            }
        }
    }
    *p = '\0';
    return space_cnt;
}

int main() {
    char data[] = " 22 3  12";
    int num = trim_space(data);
    std::cout << "num: " << num << std::endl;
    std::cout << data << std::endl;
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
typedef struct node_s {
    int data;
    struct node_s* next;
} node_t;

node_t* reverse(node_t* head) {
    if (head == nullptr) {
        return nullptr;
    }
    node_t *prev = nullptr, *next = nullptr;
    while (head != nullptr) {
        next = head->next;
        head->next = prev;
        prev = head;
        head = next;
    }
    return prev;
}

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
#include <iostream>
#include <memory>

// 单链表，k 个节点组内的逆序
template <typename T>
class List {
   private:
    class Node;
    using NodePtr = std::shared_ptr<Node>;

    class Node {
       public:
        Node(const T& data, NodePtr next)
            : m_data(data), m_next(next) {
        }
        T m_data;
        NodePtr m_next = nullptr;
    };

    int m_size = 0;
    NodePtr m_head = nullptr;
    NodePtr m_tail = nullptr;

   public:
    List() {}

    void pushTail(const T& data) {
        auto node = std::make_shared<Node>(data, nullptr);
        if (m_tail) {
            m_tail->m_next = node;
            m_tail = node;
        } else {
            m_head = m_tail = node;
        }
        m_size++;
    }

    // 交换节点的个数。k = 2
    void reverseKGroup(int k) {
        if (m_head == nullptr || k <= 0) {
            return;
        }

        // 第一组是否满足条件。
        auto start = m_head;
        auto end = getkGroupEnd(start, k);
        if (end == nullptr) {
            return;
        }

        m_head = end;
        reverse(start, end);

        auto last_end = start;
        while (last_end->m_next != nullptr) {
            start = last_end->m_next;
            end = getkGroupEnd(start, k);
            if (end == nullptr) {
                return;
            }
            reverse(start, end);
            last_end->m_next = end;
            last_end = start;
        }
        m_tail = last_end;
    }

   private:
    // 反转链表区间
    void reverse(NodePtr start, NodePtr end) {
        if (start && end) {
            end = end->m_next;
            NodePtr cur = start, pre = nullptr, next = nullptr;
            while (cur != end) {
                next = cur->m_next;
                cur->m_next = pre;
                pre = cur;
                cur = next;
            }
            start->m_next = end;
        }
    }

    // 获取 k 个点的组
    NodePtr getkGroupEnd(NodePtr start, int k) {
        while (--k > 0 && start != nullptr) {
            start = start->m_next;
        }
        return start;
    }
};