C语言练习用的一些常用结点和操作#

1
// 单列表结点
2
typedef struct
3
{
4
    int value;
5
    struct SNode* next;
6
}SinglyLinkedListNode,SLLNode,SNode;
7

8
/*
9
value：新单列表结点的值
10
return：新结点，next会被赋值为空
11
*/
12
SNode* createSNode(int value)
13
{
14
    SNode* node = (SNode*)malloc(sizeof(SNode));
15
    node->value = value;
16
    node->next = NULL;
17
    return node;
18
}
19

20
/*
21
targetNode：要在后面加结点的结点
22
newNode：要加的结点
23
*/
24
void addSNodeToTheNext(SNode* targetNode, SNode* newNode)
25
{
26
    newNode->next = targetNode->next;
27
    targetNode->next = newNode;
28
}
29

30
/*
31
targetNode：要在后面加结点的结点
32
sList：要加在后面的列表
33
*/
34
void addSListToTheNext(SNode* targetNode, SNode* sList)
35
{
36
    targetNode->next = sList;
37
}
38

39
/*
40
pastNode：要删除的结点的上一个结点
41
return：返回删除的结点，此结点next置空
42
*/
43
SNode* deleteNextSNode(SNode* pastNode)
44
{
45
    SNode* targetNode = pastNode->next;
46
    pastNode->next = targetNode->next;
47
    targetNode->next = NULL;
48
    return targetNode;
49
}
50

51
/*
52
arr：要创建列表的值
53
len：列表的长度
54
*/
55
SNode* createList(int* arr, int len)
56
{
57
    if(len <= 0)
58
    {
59
        return NULL;
60
    }
61

62
    SNode* node = createSNode(arr[0]);
63
    SNode* head = node;
64

65
    for(int i = 1; i < len; i ++)
66
    {
67
        addSNodeToTheNext(node, createSNode(arr[i]));
68
        node=node->next;
69
    }
70
    return head;
71
}
72

73
/*
74
head：要输出的列表的头
75
pattern：输出的格式
76
endstr： 输出结束后要输出的字符串
77
*/
78
void printSNodes(SNode* head, char* pattern, char* endstr)
79
{
80
    while(head != NULL)
81
    {
82
        printf(pattern, head->value);
83
        head = head->next;
84
    }
85
    printf(endstr);
86
}

1
// 双列表结点
2
typedef struct
3
{
4
    int value;
5
    struct DNode* past;
6
    struct DNode* next;
7

8
}DulNode,DNode;
9

10
// 创建双向链表
11
DNode* dNode_create(int value)
12
{
13
    DNode* node = (DNode*)malloc(sizeof(DNode));
14
    node->value = value;
15
    node->next = NULL;
16
    node->past = NULL;
17
    return node;
18
}
19

20
// 向Next添加一个结点
21
void dNode_addNext(DNode* node, DNode* newNode)
22
{
23
    newNode->past = node;
24
    newNode->next = node->next;
25
    if(node->next)
26
    {
27
        DNode* tmp = node->next;
28
        tmp->past = newNode;
29
    }
30
    node->next = newNode;
31
}
32

33
// 向Past添加一个结点
34
void dNode_addPast(DNode* node, DNode* newNode)
35
{
36
    newNode->next = node;
37
    newNode->past = node->past;
38
    if(node->past)
39
    {
40
        DNode* tmp = node->past;
41
        tmp->next = newNode;
42
    }
43
    node->past = newNode;
44
}
45

46
// 删除后一个结点
47
DNode* dNode_deleteNext(DNode* dNode)
48
{
49
    DNode* nextNode = dNode->next;
50
    dNode->next = nextNode->next;
51
    if(nextNode->next)
52
    {
53
        DNode* tmp = nextNode->next;
54
        tmp->past = dNode;
55
    }
56

57
    nextNode->next = NULL;
58
    nextNode->past = NULL;
59
    return nextNode;
60
}
61

62
// 删除前一个结点
63
DNode* dNode_deletePast(DNode* dNode)
64
{
65
    DNode* pastNode = dNode->past;
66
    dNode->past = pastNode->past;
67
    if(pastNode->past)
68
    {
69
        DNode* tmp = pastNode->past;
70
        tmp->next = dNode;
71
    }
72

73
    pastNode->next = NULL;
74
    pastNode->past = NULL;
75
    return pastNode;
76
}
77

78
// 输出双链表
79
void dNode_print(DNode* dNode, char* pattern_next, char* pattern_past)
80
{
81
    printf("next:");
82
    DNode* tmp = dNode;
83
    while(tmp)
84
    {
85
        printf(pattern_next, tmp->value);
86
        tmp = tmp->next;
87
    }
88
    printf("\npast:");
89
    tmp = dNode;
90
    while(tmp)
91
    {
92
        printf(pattern_past, tmp->value);
93
        tmp = tmp->past;
94
    }
95
}

1
// 二叉树结点
2
typedef struct
3
{
4
    int value;
5
    struct TreeNode* lchild;
6
    struct TreeNode* rchild;
7
}TreeNode;
8

9
// 创建树节点
10
TreeNode* createTreeNode(int value)
11
{
12
    TreeNode* node = (TreeNode*)malloc(sizeof(TreeNode));
13
    node->value = value;
14
    node->lchild = NULL;
15
    node->rchild = NULL;
16
}
17

18
// 添加孩子结点
19
void addTreeNodeChild(TreeNode* parent, TreeNode* chlid, char RorL)
20
{
21
    if(RorL == 'r')
22
    {
23
        parent->rchild = chlid;
24
    }
25
    else
26
    {
27
        parent->lchild = chlid;
28
    }
29
}
30

31
// 删除孩子结点
32
TreeNode* deleteTreeNodeChild(TreeNode* parent, char RorL)
33
{
34
    TreeNode* result;
35
    if(RorL == 'r')
36
    {
37
        result = parent->rchild;
38
        parent->rchild = NULL;
39
    }
40
    else
41
    {
42
        result = parent->lchild;
43
        parent->lchild = NULL;
44
    }
45

46
    return result;
47
}