leetcode（4）

1，给定一个二叉树，返回它的中序 遍历。

示例:

输入: [1,null,2,3]
1

2
/
3

输出: [1,3,2]

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */
/**
 * Return an array of size *returnSize.
 * Note: The returned array must be malloced, assume caller calls free().
 */
typedef struct stack
{
    int data[100];
    int top;
    int num;
}stack;
void init(stack **S)
{
    (*S)=(stack *)malloc(sizeof(stack));
    (*S)->top=-1;
    (*S)->num=0;
}
void Push(stack *S,int e)
{
    S->top++;
    S->data[S->top]=e;
    S->num++;
}
void store(stack *S,int *array)
{
    for(int i=0;i<=S->top;i++)
    {
        array[i]=S->data[i];
    }
}
void inorder(struct TreeNode *root,stack *S)
{
    if(root)
    {
        inorder(root->left,S);
        Push(S,root->val);
        inorder(root->right,S);
    }
}
int length(struct TreeNode *root)
{
    if(root==NULL)return 0;
    return length(root->left)+length(root->right)+1;
}
int* inorderTraversal(struct TreeNode* root, int* returnSize)
{
    *returnSize=length(root);
    int *ans=(int *)malloc((*returnSize)*sizeof(int));
    stack *S;
    init(&S);
    inorder(root,S);
    store(S,ans);
    return ans;
}

方法二（评论）

void InOrder(struct TreeNode* root, int* returnSize, int* ans)
{
    if(root != NULL)
    {

        InOrder(root -> left, returnSize, ans);
        ans[(*returnSize)++] = root -> val;
        InOrder(root -> right, returnSize, ans);

    }
}
int TreeSize(struct TreeNode* root)
{
    if(root == NULL) return 0;
    
    return TreeSize(root -> left) + TreeSize(root -> right) + 1;
}
int* inorderTraversal(struct TreeNode* root, int* returnSize) {
    int size = TreeSize(root);
    int* ans = (int*)malloc(sizeof(int)*size);
    *returnSize = 0;
    InOrder(root, returnSize, ans);
    
    return ans;
}

2.给定一个排序数组，你需要在原地删除重复出现的元素，使得每个元素只出现一次，返回移除后数组的新长度。

不要使用额外的数组空间，你必须在原地修改输入数组并在使用 O(1) 额外空间的条件下完成。

示例 1:

给定数组 nums = [1,1,2],

函数应该返回新的长度 2, 并且原数组 nums 的前两个元素被修改为 1, 2。

你不需要考虑数组中超出新长度后面的元素。
1.官方
数组完成排序后，我们可以放置两个指针 iii 和 jjj，其中 iii 是慢指针，而 jjj 是快指针。只要 nums[i]=nums[j]nums[i] = nums[j]nums[i]=nums[j]，我们就增加 jjj 以跳过重复项。
当我们遇到 nums[j]≠nums[i]nums[j] \neq nums[i]nums[j]̸​=nums[i] 时，跳过重复项的运行已经结束，因此我们必须把它（nums[j]nums[j]nums[j]）的值复制到 nums[i+1]nums[i + 1]nums[i+1]。然后递增 iii，接着我们将再次重复相同的过程，直到 jjj 到达数组的末尾为止。

public int removeDuplicates(int[] nums) {
    if (nums.length == 0) return 0;
    int i = 0;
    for (int j = 1; j < nums.length; j++) {
        if (nums[j] != nums[i]) {
            i++;
            nums[i] = nums[j];
        }
    }
    return i + 1;
}

2.哈希表（不重复放入）

int removeDuplicates(int* nums, int numsSize) {
   int min=100;
    int max=-100;
    int i=0;
    for(i=0;i<numsSize;i++)
    {
        if(nums[i]<min)
            min=nums[i];
    }
    for(i=0;i<numsSize;i++)
    {
        if(nums[i]>max)
            max=nums[i];
    }
    int len=max-min+1;
    if(max==-100||min==100)return 0;
    int *hash=(int *)malloc(len*sizeof(int));
    for(i=0;i<len;i++)
    {
        hash[i]=-1;
    }
    int m=0;
    int *ans=(int *)malloc(numsSize*sizeof(int));
    int *end=ans;
    for(i=0;i<numsSize;i++)
    {
        if(hash[nums[i]-min]!=-1)continue;
        else
        {
            hash[nums[i]-min]=1;
            m++;
            (*ans)=nums[i];
            ans++;
        }
    }
    for(i=0;i<m;i++)
    {
        nums[i]=end[i];
    }
    return m;
}