数据结构（3）—— 链表和二叉树

1 链表

对链式存储结构进行系列操作的代码—链表，为了简化链式存储结构的使用而提出和编写的数据结构。
带头结点的单链表是最简单的链表，单链表中每个节点都只有一个指针。

/*链表练习*/
#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>

typedef struct node{
    int num;
    struct node *p_next;
}node;
node head;//借用头结点是一个很妙的处理

//初始化
void init(){
    head.p_next = NULL;
}

//销毁
void destroy(){
    while (head.p_next){
        node *p_tmp = head.p_next;
        head.p_next = p_tmp->p_next;
        free(p_tmp);
        p_tmp = NULL;
    }
}

//在末尾扩展新节点
void append(int num){
    node *p_tmp = &head;
    node *p_node = (node *)malloc(sizeof(node));
    if (!p_node){
        return;
    }
    p_node->num = num;
    p_node->p_next = NULL;
    while (p_tmp->p_next){
        p_tmp = p_tmp->p_next;
    }
    p_tmp->p_next = p_node;
}

//删除第一个有效节点
void remove_head(){
    node *p_tmp = head.p_next;
    if (p_tmp){
        head.p_next = p_tmp->p_next;
        free(p_tmp);
        p_tmp = NULL;
    }
}

//获得有效节点个数
int get_size(){
    node *p_tmp = head.p_next;
    int size = 0;
    while (p_tmp){
        size++;
        p_tmp = p_tmp->p_next;
    }
    return size;
}

//根据编号获得有效数字
int get_number(int pos){
    node *p_tmp = head.p_next;
    int size = 0;
    while (p_tmp){
        size++;
        if (size == pos){
            return p_tmp->num;
        }
        p_tmp = p_tmp->p_next;
    }
    return -1;
}

//把一个新数字插入在指定的编号位置上
bool insert_at_pos(int pos,int num){
    node *p_tmp = &head;
    int loop = 0;
    for (;loop < pos - 1;loop++){
        p_tmp = p_tmp->p_next;
        if (!p_tmp){
            break;
        }
    }
    if (p_tmp){
        node *p_node = (node *)malloc(sizeof(node));
        p_node->num = num;
        p_node->p_next = p_tmp->p_next;
        p_tmp->p_next = p_node;
        return true;
    }
    else {
        return false;
    }
}

int main(){
    init();
    printf("个数是%d\n",get_size());
    append(1);
    append(2);
    append(3);
    insert_at_pos(3,4);
    printf("编号为2的数字是%d\n",get_number(2));
    printf("有效节点个数是%d\n",get_size());
    remove_head();
    printf("编号为2的数字是%d\n",get_number(2));
    printf("个数是%d\n",get_size());
    destroy();
    return 0;
}

　　我有一次去深圳的一家小公司进行面试，然后人家给你提供了一台电脑，纯Linux环境，就一终端，一黑板的屏，要你写一个链表的操作，三个程序，一个头文件，一个实现文件，一个测试文件，然后再写一个Makefile来编译，最后再用gdb来进行调试，感觉还是一道不错的题。

---

2 二叉树

　　树状逻辑结构通常采用链式存储方式实现。树状结构中每个数据使用一个结构体变量表示，两个数据之间的关系使用一个指针变量表示，每个指针变量记录在上一个数据的结构体变量中。

　　两个直接相关的节点中，靠上的节点叫父节点，另外一个叫子节点，根节点是树中最靠上的节点。

二叉树中每个节点都最多有两个子节点。
二叉树的数据部分包括结构体声明和根指针声明。

二叉树操作的三种遍历方式：
　　1、前序遍历（根节点，左子树，右子树）
　　2、中序遍历（左子树，根节点，右子树）
　　3、后序遍历（左子树，右子树，根节点）
对二叉树的操作分成三个部分：对根节点本身的操作、对节点左子树的操作、对节点右子树的操作，所以，对树的操作，递归思想很重要。

/*树练习*/
#include<stdio.h>
#include<stdlib.h>

typedef struct node{
    int num;
    struct node *p_left;
    struct node *p_right;
}node;
node *p_root;//根指针

//初始化函数
void init(node **pp_root){
    *pp_root = NULL;
}

//销毁函数
void destroy(node **pp_root){
    /*if (!*pp_root){
        return;
    }
    if ((*pp_root)->p_left){
        destroy(&((*pp_root)->p_left));
    }
    if ((*pp_root)->p_right){
        destroy(&((*pp_root)->p_right));
    }
    free(*pp_root);
    *pp_root = NULL;*/
    if (*pp_root){    //这个代码原理和上面一样，但更简洁
        destroy(&((*pp_root)->p_left));
        destroy(&((*pp_root)->p_right));
        free(*pp_root);
        *pp_root = NULL;
    }
}

//有序显示
void show(node *p_r){
    /*if (!p_r){
        return ;
    }
    if (p_r->p_left){
        show(p_r->p_left);
    }
    printf("%-5d",p_r->num);
    if (p_r->p_right){
        show(p_r->p_right);
    }*/
    if (p_r){  //这也是上面代码的简化
        show(p_r->p_left);
        printf("%-5d ",p_r->num);
        show(p_r->p_right);
    }
}

//查找合适的插入位置
node **find(node **pp_r,int num){
    if (!(*pp_r) || num == (*pp_r)->num){
        return pp_r;
    }
    else {
        if (num > (*pp_r)->num){
            return find(&((*pp_r)->p_right),num);
        }
        else {
            return find(&((*pp_r)->p_left),num);
        }
    }
}

//插入数据
void insert(node **pp_r,int num){
    node **pp_tmp = find(pp_r,num);
    if (!(*pp_tmp)){
        *pp_tmp = (node *)malloc(sizeof(node));
        (*pp_tmp)->num = num;
        (*pp_tmp)->p_left = NULL;
        (*pp_tmp)->p_right = NULL;
    }
}

//删除某个节点
void removenode(node **pp_root,int num){
    node **pp_tmp = find(pp_root,num);
    if (*pp_tmp){
        node *p_tmp = *pp_tmp;
        if (!(p_tmp->p_left)){
            *pp_tmp = p_tmp->p_right;
        }
        else if (!(p_tmp->p_right)){
            *pp_tmp = p_tmp->p_left;
        }
        else {
            node **pp_tmp1 = find(&(p_tmp->p_right),
                    p_tmp->p_left->num);
            *pp_tmp1 = p_tmp->p_left;
            *pp_tmp = p_tmp->p_right;
        }
        free(p_tmp);
        p_tmp = NULL;
    }
}

int main(){
    init(&p_root);
    insert(&p_root,50);
    insert(&p_root,30);
    insert(&p_root,20);
    insert(&p_root,70);
    insert(&p_root,80);
    insert(&p_root,60);
    insert(&p_root,90);
    insert(&p_root,100);
    removenode(&p_root,70);
    show(p_root);
    printf("\n");
    destroy(&p_root);
    return 0;
}