leetcode刷题（c语言版）

链表

两数相加(中等难度)

给出两个 非空 的链表用来表示两个非负的整数。其中，它们各自的位数是按照 逆序 的方式存储的，并且它们的每个节点只能存储 一位 数字。
如果，我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。
您可以假设除了数字 0 之外，这两个数都不会以 0 开头。
实例

输入：(2 -> 4 -> 3) + (5 -> 6 -> 4)
输出：7 -> 0 -> 8
原因：342 + 465 = 807

代码

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode* addTwoNumbers(struct ListNode* l1, struct ListNode* l2){
    int bit = 0;  
    int l1num = 0; //我们没有用链表节点的成员直接相加，因为我们要做判断是否节点存在，如果不存在就是为0，就怕这种极端情况
    int l2num = 0;
    struct ListNode *newlist,*temp,*head;
    newlist = malloc(sizeof(struct ListNode));
    newlist->next = NULL;
    newlist->val = 0;
    head =newlist;
    while(l1 != 0 || l2 != 0 || bit != 0) //如果有节点不为空，或者节点都为空，我们的bit不为空，说明我们都要往后进一位，所以执行以下步骤
    {
        temp = malloc(sizeof(struct ListNode));  
        temp->next = NULL;
        temp->val = 0;
        if(l1 == 0){
            l1num = 0;
        }else{
            l1num = l1->val;
            l1 = l1->next;
        }
        if(l2 == 0){
            l2num = 0;
        }else{
            l2num = l2->val;
            l2 = l2->next;
        }
        temp->val = (l1num+l2num+bit)%10;
        bit = (l1num+l2num+bit)/10;
        newlist->next = temp;
        newlist = newlist->next;
    }
    head = head->next;
    return head;
}

思路，我们灵活运用c语言的%和/，我们先设置一个bit，意思就是相加大于9我们需要进一位所以bit为1，我们怎么去值？用我们的2个数相加再加bit/10，取个位数，怎么取bit的值？就是2个数相加再加上bit取10的模，取所有东西相加后的十位，比如10%10还是1，说明需要进一位。

有序链表变二叉查找树

给定一个单链表，其中的元素按升序排序，将其转换为高度平衡的二叉搜索树。本题中，一个高度平衡二叉树是指一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1。

分析：首先我们常规的生成二叉查找树很简单创建一个二叉查找树的函数，传进来一个节点的指针的指针（二级指针），然后判断这个指针的值是否为空（就是内层指针，指向树节点的，为空就创建节点（根节点，第一次插入结对会走这里），初始化，然后返回这个节点的指针，然后如果插入的二级指针内层指针不为空，就执行比较如果小于这个data就插入他左边（代码就是return 这个函数传参就是根的left的指针的指针），如果大于他就插入右边(和刚刚的步骤一样)

指针的指针。
因为树的结点要用指针描述。
如果只用指针，作形参传给建立结点的函数，这个指针值传给了函数栈中的内存，函数返回后，函数栈销毁，不能获得结点。
而用指针的指针，函数内修改了这个双重指针指向的值（即结点指针），在函数外也能获得结点。

但是这个题是叫我们把一个有序的数列变二叉排序树，如果我们按照传统的插法就会变成一个斜树，横过来看就是链表，就体现不了二叉树查找logn的速度，所以我们要先找根节点，谁为根最好？当然是大小最中间的树，那么根的左子树和右子树谁最好？肯定是已经被一分为二的链表的左边一段的中位数当根的左子树，已经被一分为二的链表的右边一段的中位数当根的右子树，这样我们有一个想法，在一个函数里用一个while，再用快慢法找到中位数，立中位数为根（判断条件就是next为null就终止），然后用迭代再找出左边一段的中位数（因为null为终止，我们上面已经弄了一个null）等那个迭代结束后再把中间的数接回去，再进行下一次对右边的迭代，这个迭代传入的就不是head，而是mid的后一位，代码如下

struct TreeNode* sortedListToBST(struct ListNode* head){    
    if(!head){
        return  NULL;
    }
    struct ListNode *fast = head,*pre = head,*slow = head;  
    struct TreeNode *root;  
    /*这个就是快慢，设置2个指针，第一个慢的走1步第二个走2步，第二个永远是第一
    个的2倍，当第二个走到底，第一个就是中间勒*/
    while(fast->next && fast->next->next){
        pre = slow;  
        slow = slow->next;
        fast = fast->next->next;
    }
    root = malloc(sizeof(struct TreeNode));
    root->val = slow->val;  
    if(pre == slow){ //pre等于slow说明到底了（最边上），也就是叶子节点
        root->left = NULL;
    }else{
        pre->next = NULL; //设置一个终端，方便我们下次迭代，迭代找左边一半的中位数
        root->left = sortedListToBST(head);
        pre->next = slow;//恢复
    }
    root->right = sortedListToBST(slow->next); //记住这里传的是中间的下一个，再跌倒找中位数一定在上面找的的中位数的右边
    return root;
}

队列

统计二叉树每一层的平均数

给定一个非空二叉树, 返回一个由每层节点平均值组成的数组.

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */


/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
 #define MAXNUMBER 10000
 typedef struct queuerecord *queue;
 struct queuerecord{
     int front; 
     int rear; 
     struct TreeNode **arry;  
     int size;
 };
//初始化
 int queue_init(queue q){
     q->front = 0;
     q->rear = 0;
     q->size = 0;
     q->arry = (struct TreeNode **)malloc(sizeof(struct TreeNode *) * MAXNUMBER);
     return 0;
 }
//出队列
 struct TreeNode * pop(queue q){
    struct TreeNode * value;
    value = q->arry[q->front];
    q->front++;
    q->size--;
    return value;
 }
//进队列
int inqueue(struct TreeNode * value,queue q){
    q->arry[q->rear++] = value;
    q->size++;
    return 0;
}
//判断队列是否为空
int isspace(queue q){
    if(q->front == q->rear)
        return 0;
}


double* averageOfLevels(struct TreeNode* root, int* returnSize){
    //这个数组是要返回的
    double *avg = (double *)malloc(sizeof(double)*MAXNUMBER);
    double sum = 0.0;
    int size; 
    * returnSize = 0;
    queue q = (queue *)malloc(sizeof(struct queuerecord));
    //init
    if(!queue_init(q)){
        return 1;
    }
    //将跟节点放到队列里面
    if(!inqueue(root,q)){
        return 2;
    }
    //先把跟节点的val给avg的第一个元素，不然后面我们插入二叉树第二层的成员时候父节点被弹出就记录不了勒
    avg[*returnSize] = (q->arry[q->front])->val;
    //外循环用于遍历所有树,并且结算内循环的平均数
    while(!isspace(q)){
         //这个while用与将下一层加进来，并且将这一层的数字都加起来,并且弹出他们的父节点，
        size = p->size;
        while(size != 0){
            if((q->arry[q->front])->left){
                inqueue((q->arry[q->front])->left,q)
                sum += (q->arry[q->front])->left->val;
            }
            if((q->arry[q->front])->right){
                inqueue((q->arry[q->front])->left,q)
                sum += (q->arry[q->front])->left->val;
            }
            pop(q);
            size--;
        }
        //把我们要返回的数组索引加一
        (*returnSize)++;
        //把这一层的平均数传给这个数组
        avg[*returnSize] = sum/(p->size);
    }
    return avg;
}

二叉树

普通二叉树

判断2个二叉树是否相同

给定两个二叉树，编写一个函数来检验它们是否相同。

如果两个树在结构上相同，并且节点具有相同的值，则认为它们是相同的。
一下是我自己写的，自己构建勒一个队列，然后将2个2叉树以中序遍历的方法都放到队列中，然后一个一个对比，但是没有编译过不知道那里的问题，因为编译不了

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */

#define MAXNUM 10000
typedef struct TreeNode *treenode;
typedef struct queuecord *queue;
struct queuecord {
    int * arry;
    int front;
    int rear; 
    int size;
};

int queue_init(queue q){
    q->arry = (int *)malloc(sizeof(int)*MAXNUM);
    q->front = 0;
    q->rear = 0;
    q->size = 0;
    return 0;
}

int queue_pop(queue q){
    int pop;
    pop = q->front;
    q->front++;
    q->size--;
    return pop;
}

int queue_in(int value,queue q){
    q->size++;
    q->arry[q->rear] = value;
    q->rear++;
    return 0;
}

void tree_mid_ergodic(treenode t,queue q){
    if(t != 0){
        tree_mid_ergodic(t->left,q);
        queue_in(t->val,q);
        tree_mid_ergodic(t->right,q); 
    }
}

bool compare(queue q1,queue q2){
    if(q1->size != q2->size){
        return false;
    }else{
        int size = q1->size;
        int i;
        for(i = 0;i < size;i++){
            if(q1->arry[i] == q2->arry[i]){
                continue;
            } else{
                return false;
            }
        }
        }
    return true;
}


bool isSameTree(struct TreeNode* p, struct TreeNode* q){
    queue q1 = (queue)malloc(sizeof(struct queuecord));
    queue q2 = (queue)malloc(sizeof(struct queuecord));
    //init 
    if(queue_init(q1) == 0) return 1;
    if(queue_init(q2) == 0) return 1;
    //将二叉树以中序遍历的方法入队列
    tree_mid_ergodic(p,q1);
    tree_mid_ergodic(q,q2);
    //比较返回
    return compare(q1,q2);

}

一下是看了别人的代码直接进行中序遍历递推,可以编过去
别人的思想很简单，就是先判断节点是否都为空，为空就返回true（不用担心最后的返回是一个&&形式，必须2侧都为true最终才返回true），如果有一个为true另一个不为true就返回false，他们的节点值不一样就返回false，最后一个迭代（先序遍历）

bool isSameTree(struct TreeNode* p, struct TreeNode* q){
    if( p == NULL && q == NULL) return true;
    if( p == NULL || q == NULL) return false;
    if( p->val != q->val) return false;
    return isSameTree(p->left,q->left)&&isSameTree(p->right,q->right);
}

判断一个随机二叉树是不是对称

这个题目感觉不是很难，就是给定一个二叉树，以根做铅直线，此铅直线为y轴，二叉树是否关于y粥对称
解题思路就是中序遍历二叉树，我们会得到一个值对称的list，然后这个list为奇数并且一一对称就通过，如果是偶数，或者为奇数且不一一对称就不通过，但是他对一些特殊的二叉树就不行，比如完全二叉树，这个方法就不行了，我写的代码如下

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */
#define MAXNUM 100000

typedef struct queuestruct * queue;
struct queuestruct{
    int rear;
    int front;
    int size;
    int * value;
};

int
init(queue q){
    q->rear = 0;
    q->front = 0;
    q->size = 0;
    q->value = (int *)malloc(sizeof(int)*MAXNUM);
    return 0;
}

int 
push(int value,queue q){
    q->value[q->rear] = value;
    q->rear++;
    q->size++;
    return 0;
}

int 
inorder(struct TreeNode *treenode,queue q){
    if(!treenode){
       return 0; 
    }else{
        inorder(treenode->left,q);
        push(treenode->val,q);
        inorder(treenode->right,q);
    }
    return 0;
}

bool 
compare(queue q){
    int size = (q->size) - 1;
    int i = 0;
    if(q->size % 2 != 1){
        return false;
    } else{
        while(i != size){
            if(q->value[i] == q->value[size]){
                size--;
                i++;
                continue;
            }else{
                return false;
            }
        }
        return true;
        }
    }

bool isSymmetric(struct TreeNode* root){
    queue q = (queue)malloc(sizeof(struct queuestruct));
    if(init(q) != 0){
        printf("init fail");
        return 1;
    }
    if(inorder(root,q) != 0){
        printf("inorder fail");
        return 2;
    }
    return compare(q);
}

虽然说我写的代码不正确，但是还是要记录一下滴，下面时我看了别人的代码，构想出来的
首先想解决这个题目，就要判断根节点的左子树和右子树是不是对称的，但是想知道左子树是不是对称还要知道左子树的左子树，左子树的右子树是不是对称，右子树同理，这里我们遇到一个问题想解决问题A，就必须要使用问题A解决后的答案，这里毫无疑问就是迭代，而且这个就是迭代点，而且除了这些，我们还要对比左子树的左子树是否等于右子树的右子树，这里我们就要注意，代码如下

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */

bool compare(struct TreeNode *root1,struct TreeNode *root2){
/*在函数中主要是先判断2个是否存在，如果都不存在就直接返回true，如果只有一个存在就返回错误*/
    if(!root1 && !root2) return true;
    if(!root1 || !root2) return false;
/*这里先判断传进来的2个节点的值是否相等，这个值随着我们后面的迭代一直变*/
    return (root1->val == root2->val) && 
/*这里就开始迭代，我们上面是判断值是否相等，那么我们就将节点的左子树和右节点的右子树放进去，这样一直迭代到最左边的叶子节点和最右边的叶子节点没然后判断相等*/
    compare(root1->left,root2->right) &&
/*如果最左边的叶子节点和最右边的叶子节点结束迭代返回上一个函数就开始再迭代比对倒数第二层的最左边的节点的右孩子，和倒数第二层的最右变的节点的左子树*/
    compare(root1->right,root2->left);
}

bool isSymmetric(struct TreeNode* root){
    if(!root){
        return true;
    }else{
        return compare(root->left,root->right);
    }
}

二叉排序树

我们有一个二叉排序树，此时我们想将其按照从小到大的顺序变成链表，这个链表是以下的形式，就是二叉排序树最坏的状态

 1
/ \
    2
   / \
      3
     / \
        4 
        ...
        ...
        ...

这个题目我的想法是中序遍历二叉排序树得到的数字就是按照从小到大的顺序排列的，难点是遍历后得到的数怎么放进一个新的最坏情况的二叉排序树中去，这里有一个不成熟的想法，定义2个treenode，然后一个为所谓的头节点，还有一个不断的生成右节点，，，，，代码如下

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */


//定义一个全局TreeNode的指针，这个指针用与返回斜二叉搜索树的根
struct TreeNode *treehead;
//定义一个全局TreeNode指针，这个用于建立斜二叉搜索树的子节点
struct TreeNode *treerear; 

//进斜二叉搜索树
void 
tiltBST(struct TreeNode *node){
/**
这个分支用于建立斜二叉树根节点，将传进来的二叉树节点左子树设为null
(因为这个二叉树的节点是中序遍历得到，先遍历最左边的节点也是最小的，
然后中右，所以顺序不用担心，而且左子树为空不影响原二叉排序树)
**/
	if(!treehead){
		node->left = NULL;
		treehead = node;
		treerear = treehead;
	}

/**
这个分支用treerear后见斜二叉树后面的节点
**/	
	else{
		node->left = NULL; //将左节点变为null，因为这个节点要变成斜二叉排序树的子节点
		treerear->right = node;
		treerear = node;//便于下一次建立斜二叉树
	}
}

void 
inorder(struct TreeNode * node){
	if(node){
		inorder(node->left);
		tiltBST(node);
		inorder(node->right);
	}
}

struct TreeNode* convertBiNode(struct TreeNode* root){
    treehead = NULL;
    inorder(root);
    return treehead;
}