c语言链表查找结点

好的，以下是C语言链表查找节点的示例代码：

typedef struct Node {
    int data;
    struct Node* next;
} Node;

Node* search(Node* head, int target) {
    Node* current = head;
    while (current != NULL) {
        if (current->data == target) {
            return current;  // 找到目标节点，返回该节点的指针
        }
        current = current->next;
    }
    return NULL;  // 没有找到目标节点，返回空指针
}

以上代码中，我们定义了一个链表节点结构体 `Node`，包含了一个数据域 `data` 和一个指向下一个节点的指针 `next`。接下来定义了一个 `search` 函数，该函数接收链表头节点的指针 `head` 和目标值 `target`，返回找到的目标节点的指针，如果没有找到则返回空指针。

在函数内部，我们定义了一个 `current` 指针，指向当前遍历的节点，初始值为链表头节点。我们使用一个 `while` 循环来遍历链表，如果当前节点的数据域等于目标值，就返回该节点的指针；否则将 `current` 指针指向下一个节点。如果遍历完整个链表都没有找到目标节点，则返回空指针。

希望对您有所帮助！

相关问题

链表插入结点(在查找到的结点之后插入)C语言

链表插入结点的基本思路是：先找到要插入的位置（即要插入结点的前一个结点），然后将插入结点链接到该位置的下一个结点，同时将该位置的指针指向插入结点。下面是在查找到的结点之后插入结点的C语言代码实现：

typedef struct Node {
    int data;          // 数据域
    struct Node *next; // 指针域
} Node;

// 在链表中查找指定值的结点
Node* searchNode(Node *head, int value) {
    Node *p = head->next;
    while (p != NULL) {
        if (p->data == value) {
            return p; // 返回查找到的结点
        }
        p = p->next;
    }
    return NULL; // 没有找到，返回NULL
}

// 在查找到的结点之后插入结点
void insertAfter(Node *pNode, int value) {
    Node *newNode = (Node*)malloc(sizeof(Node));
    newNode->data = value;
    newNode->next = pNode->next;
    pNode->next = newNode;
}

int main() {
    Node *head = (Node*)malloc(sizeof(Node)); // 创建头结点
    head->next = NULL; // 初始化为空链表

    // 尾插法创建链表
    Node *tail = head;
    for (int i = 1; i <= 5; i++) {
        Node *newNode = (Node*)malloc(sizeof(Node));
        newNode->data = i;
        newNode->next = NULL;
        tail->next = newNode;
        tail = newNode;
    }

    // 在链表中查找指定值的结点
    Node *pNode = searchNode(head, 3);
    if (pNode != NULL) {
        // 在查找到的结点之后插入结点
        insertAfter(pNode, 6);
    }

    // 遍历链表
    Node *p = head->next;
    while (p != NULL) {
        printf("%d ", p->data);
        p = p->next;
    }

    // 释放链表内存
    Node *pNode = head->next;
    while (pNode != NULL) {
        Node *temp = pNode;
        pNode = pNode->next;
        free(temp);
    }
    free(head);

    return 0;
}

上述代码中，先通过 `searchNode` 函数在链表中查找指定值的结点，然后调用 `insertAfter` 函数在查找到的结点之后插入新结点。最后，通过遍历链表输出每个结点的值，然后释放链表内存。

C语言链表实现二叉树

链表实现二叉树是一种常见的数据结构，可以用于存储和操作树形结构的数据。下面是C语言链表实现二叉树的方法：

定义结构体：

typedef struct TreeNode {
    int data;
    struct TreeNode *left;
    struct TreeNode *right;
} TreeNode;

初始化：

TreeNode *root = NULL;

先序遍历创建二叉树方法一：

void createTree(TreeNode **node) {
    int data;
    scanf("%d", &data);
    if (data == -1) {
        *node = NULL;
    } else {
        *node = (TreeNode *)malloc(sizeof(TreeNode));
        (*node)->data = data;
        createTree(&((*node)->left));
        createTree(&((*node)->right)));
    }
}

测试：

int main() {
    createTree(&root);
    return 0;
}

方法二：根据所给的字符串序列创建

void createTree(TreeNode **node, char *str, int *index) {
    if (str[*index] == '\0' || str[*index] == '#') {
        *node = NULL;
        (*index)++;
    } else {
        *node = (TreeNode *)malloc(sizeof(TreeNode));
        (*node)->data = str[*index] - '0';
        (*index)++;
        createTree(&((*node)->left), str, index);
        createTree(&((*node)->right), str, index);
    }
}

其他方法：

- 树的结点大小

int size(TreeNode *node) {
    if (node == NULL) {
        return 0;
    } else {
        return size(node->left) + 1 + size(node->right);
    }
}

- 树的高

int height(TreeNode *node) {
    if (node == NULL) {
        return 0;
    } else {
        int leftHeight = height(node->left);
        int rightHeight = height(node->right);
        return (leftHeight > rightHeight) ? (leftHeight + 1) : (rightHeight + 1);
    }
}

- 判断树是否为空

int isEmpty(TreeNode *node) {
    return node == NULL;
}

- 找某个结点的左孩子和右孩子

TreeNode *leftChild(TreeNode *node) {
    if (node == NULL) {
        return NULL;
    } else {
        return node->left;
    }
}

TreeNode *rightChild(TreeNode *node) {
    if (node == NULL) {
        return NULL;
    } else {
        return node->right;
    }
}

- 找某个结点的父节点

TreeNode *parent(TreeNode *root, TreeNode *node) {
    if (root == NULL || root == node) {
        return NULL;
    } else if (root->left == node || root->right == node) {
        return root;
    } else {
        TreeNode *p = parent(root->left, node);
        if (p != NULL) {
            return p;
        } else {
            return parent(root->right, node);
        }
    }
}

- 查找元素

TreeNode *find(TreeNode *node, int data) {
    if (node == NULL) {
        return NULL;
    } else if (node->data == data) {
        return node;
    } else {
        TreeNode *p = find(node->left, data);
        if (p != NULL) {
            return p;
        } else {
            return find(node->right, data);
        }
    }
}

- 拷贝树

TreeNode *copy(TreeNode *node) {
    if (node == NULL) {
        return NULL;
    } else {
        TreeNode *newNode = (TreeNode *)malloc(sizeof(TreeNode));
        newNode->data = node->data;
        newNode->left = copy(node->left);
        newNode->right = copy(node->right);
        return newNode;
    }
}

- 清空树

void clear(TreeNode **node) {
    if (*node != NULL) {
        clear(&((*node)->left));
        clear(&((*node)->right));
        free(*node);
        *node = NULL;
    }
}