int removeElement(int* nums, int numsSize, int val) {
int fast=0;
int slow=0;
for(int fast=0;fast<numsSize;fast++)
{
if(nums[fast]!=val)
{
nums[slow]=nums[fast];
slow++;
}
}
return slow;
}
void resver(int*a,int left,int right)
{
while(left<right)
{
int tmp=a[left];
a[left]=a[right];
a[right]=tmp;
left++;
right--;
}
}
void rotate(int* nums, int numsSize, int k) {
k%=numsSize;
resver(nums,0,numsSize-k-1);
resver(nums,numsSize-k,numsSize-1);
resver(nums,0,numsSize-1);
}
int removeDuplicates(int* nums, int numsSize) {
int dev=0;
int rec=1;
while(rec<numsSize)
{
if(nums[rec]==nums[dev])
{
rec++;
}
else
{
dev++;
nums[dev]=nums[rec];
rec++;
}
}
return dev+1;
}
void merge(int* nums1, int nums1Size, int m, int* nums2, int nums2Size, int n) {
int end1=m-1;
int end2=n-1;
int end3=m+n-1;
while(end1>=0&&end2>=0)
{
if(nums1[end1]>nums2[end2])
{
nums1[end3--]=nums1[end1--];}
else
{
nums1[end3--]=nums2[end2--];}
}
while(end2>=0)
{
nums1[end3--]=nums2[end2--];}
}
struct ListNode* removeElements(struct ListNode* head, int val) {
struct ListNode*tail;
struct ListNode*phead;
tail=phead=(struct ListNode*)malloc(sizeof(struct ListNode));
phead->next=NULL;
struct ListNode* cur=head;
while(cur)
{
if(cur->val!=val)
{
tail->next=cur;
tail=tail->next;
}
cur=cur->next;
}
tail->next=NULL;
return phead->next;
free(phead);
}
struct ListNode* middleNode(struct ListNode* head) {
struct ListNode*fast=head;
struct ListNode*slow=head;
while(fast&&fast->next)
{
fast=fast->next->next;
slow=slow->next;
}
return slow;
}
struct ListNode* FindKthToTail(struct ListNode* pListHead, int k ) {
if(pListHead==NULL)
return NULL;
struct ListNode* fast= pListHead;
struct ListNode* slow= pListHead;
int num=k;
while(num)
{
if(fast==NULL)
return NULL;
fast=fast->next;
num--;
}
while(fast)
{
slow=slow->next;
fast=fast->next;
}
return slow;
}
bool hasCycle(struct ListNode *head) {
if(head==NULL)
return false;
struct ListNode * fast=head;
struct ListNode * slow=head;
while(fast&&fast->next)
{
fast=fast->next->next;
slow=slow->next;
if(fast==slow)
{
return true;}
}
return false;
}
struct ListNode *getIntersectionNode(struct ListNode *headA, struct ListNode *headB) {
int len1=0;
int len2=0;
struct ListNode*cur1=headA;
struct ListNode*cur2=headB;
while(cur1->next)
{
len1++;
cur1=cur1->next;
}
while(cur2->next)
{
len2++;
cur2=cur2->next;
}
if(cur1!=cur2)
{
return NULL;}
int count=abs(len1-len2);
struct ListNode*longlist=headA;
struct ListNode*shortlist=headB;
if(len2>len1)
{
longlist=headB;
shortlist=headA;
}
while(count)
{
longlist=longlist->next;
count--;
}
while(longlist!=shortlist)
{
longlist=longlist->next;
shortlist=shortlist->next;
}
return longlist;
struct ListNode *detectCycle(struct ListNode *head) {
struct ListNode *fast=head;
struct ListNode *slow=head;
while(fast&&fast->next)
{
fast=fast->next->next;
slow=slow->next;
if(slow==fast)
{
struct ListNode *meet=slow;
while(meet!=head)
{
meet=meet->next;
head=head->next;
}
return meet;
}
}
return NULL;
}
struct Node* copyRandomList(struct Node* head) {
struct Node*cur=head;
while(cur)
{
struct Node* newnode=(struct Node*)malloc(sizeof(struct Node));
if(newnode==NULL)
{
perror("malloc fail");}
newnode->val=cur->val;
newnode->next=cur->next;
cur->next=newnode;
cur=newnode->next;
}
cur=head;
while(cur)
{
struct Node*newnode=cur->next;
struct Node* next=newnode;
if(cur->random==NULL)
{
newnode->random=NULL;}
else
{
newnode->random=cur->random->next;
}
cur=next->next;
}
cur=head;
struct Node*copytail=NULL;
struct Node*copyhead=NULL;
while(cur)
{
struct Node*newnode=cur->next;
struct Node* next=newnode->next;
if(copytail==NULL)
{
copytail=copyhead=newnode;}
else
{
copytail->next=newnode;
copytail=copytail->next;
}
cur->next=next;
cur=next;
}
return copyhead;
}
class Partition {
public:
ListNode* partition(ListNode* pHead, int x) {
ListNode*tail1;
ListNode*tail2;
ListNode*head1;
ListNode*head2;
tail1=head1=(ListNode*)malloc(sizeof(ListNode));
tail2=head2=(ListNode*)malloc(sizeof(ListNode));
tail1->next=NULL;
tail2->next=NULL;
ListNode*cur=pHead;
while(cur)
{
if(cur->val<x)
{
tail1->next=cur;
tail1=tail1->next;
}
else
{
tail2->next=cur;
tail2=tail2->next;
}
cur=cur->next;
}
tail1->next=head2->next;
tail2->next=NULL;
return head1->next;
}
};
struct ListNode* reverseList(struct ListNode* head) {
if(head==NULL)
return NULL;
struct ListNode* n1=NULL;
struct ListNode* n2=head;
struct ListNode* n3=n2->next;
while(n2)
{
n2->next=n1;
n1=n2;
n2=n3;
if(n3)
n3=n3->next;
}
return n1;
}
ListNode* middleNode(ListNode* head) {
ListNode* fast = head;
ListNode* slow = head;
while (fast && fast->next) {
fast = fast->next->next;
slow = slow->next;
}
return slow;
}
ListNode* reverseList( ListNode* head) {
if (head == NULL)
return NULL;
ListNode* n1 = NULL;
ListNode* n2 = head;
ListNode* n3 = n2->next;
while (n2) {
n2->next = n1;
n1 = n2;
n2 = n3;
if (n3)
n3 = n3->next;
}
return n1;
}
class PalindromeList {
public:
bool chkPalindrome(ListNode* A) {
ListNode*mid=middleNode(A);
ListNode*start=reverseList(mid);
while(start)
{
if(A->val!=start->val)
{
return false;
}
A=A->next;
start=start->next;
}
return true;
}
};
typedef struct Stack
{
char* a;
int top;
int capacity;
}Stack;
void StackInit(Stack* ps)
{
assert(ps);
ps->a = NULL;
ps->capacity = ps->top = 0;
}
void StackPush(Stack* ps, int data)
{
assert(ps);
if (ps->capacity == ps->top)
{
int newcapcity = ps->capacity == 0 ? 4 : ps->capacity * 2;
char* newnode = (char*)realloc(ps->a,sizeof(char) * newcapcity);
assert(newnode);
ps->a = newnode;
ps->capacity = newcapcity;
}
ps->a[ps->top] = data;
ps->top++;
}
int StackEmpty(Stack* ps)
{
assert(ps);
return ps->top == 0;
}
void StackPop(Stack* ps)
{
assert(ps);
assert(!StackEmpty(ps));
ps->top--;
}
char StackTop(Stack* ps)
{
assert(ps);
assert(!StackEmpty(ps));
return ps->a[ps->top - 1];
}
int StackSize(Stack* ps)
{
assert(ps);
return ps->top;
}
void StackDestroy(Stack* ps)
{
assert(ps);
free(ps->a);
ps->a = NULL;
ps->capacity = ps->top = 0;
}
bool isValid(char* s) {
Stack st;
StackInit(&st);
while(*s)
{
if(*s=='['||*s=='{'||*s=='(')
{
StackPush(&st,*s);
s++;
}
else
{
if(StackEmpty(&st))
return false;
char top=StackTop(&st);
if(*s==']'&&top=='['||*s=='}'&&top=='{'||*s==')'&&top=='(')
{
StackPop(&st);
s++;
}
else
{
return false;}
}
}
int ret=StackEmpty(&st);
return ret;
StackDestroy(&st);
}
typedef struct QListNode
{
struct QListNode* next;
int data;
}QNode;
typedef struct Queue
{
QNode* front;
QNode* tail;
}Queue;
void QueueInit(Queue* q)
{
assert(q);
q->front = q->tail = NULL;
}
void QueuePush(Queue* q, int x)
{
assert(q);
QNode* newnode = (QNode*)malloc(sizeof(QNode));
assert(newnode);
newnode->data =x;
newnode->next = NULL;
if (q->tail == NULL)
{
q->tail = q->front = newnode;
}
else
{
q->tail->next = newnode;
q->tail = newnode;
}
}
bool QueueEmpty(Queue* q)
{
assert(q);
return q->front == NULL;
}
void QueuePop(Queue* q)
{
assert(q);
assert(!QueueEmpty(q));
if (q->front->next == NULL)
{
free(q->tail);
q->tail = q->front = NULL;
}
else
{
QNode* next = q->front->next;
free(q->front);
q->front = next;
}
}
int QueueFront(Queue* q)
{
assert(q);
assert(q->front);
return q->front->data;
}
int QueueBack(Queue* q)
{
assert(q);
assert(q->tail);
return q->tail->data;
}
int QueueSize(Queue* q)
{
assert(q);
int size = 0;
QNode* cur = q->front;
while (cur)
{
size++;
cur = cur->next;
}
return size;
}
void QueueDestroy(Queue* q)
{
assert(q);
QNode* cur = q->front;
while (cur)
{
QNode* next = cur->next;
free(cur);
cur = next;
}
q->front = q->tail = NULL;
}
typedef struct {
Queue n1;
Queue n2;
} MyStack;
MyStack* myStackCreate() {
MyStack* obj=(MyStack*)malloc(sizeof(MyStack));
if(obj==NULL)
{
perror("malloc fail");}
QueueInit(&obj->n1);
QueueInit(&obj->n2);
return obj;
}
bool myStackEmpty(MyStack* obj) {
return QueueEmpty(&obj->n1)&&QueueEmpty(&obj->n2);
}
void myStackPush(MyStack* obj, int x) {
if(!QueueEmpty(&obj->n1))
{
QueuePush(&obj->n1,x);
}
else
{
QueuePush(&obj->n2,x);
}
}
int myStackPop(MyStack* obj) {
Queue* nonempty=&obj->n1;
Queue* empty=&obj->n2;
if(!QueueEmpty(&obj->n2))
{
nonempty=&obj->n2;
empty=&obj->n1;}
while(QueueSize(nonempty)>1)
{
QueuePush(empty,QueueFront(nonempty));
QueuePop(nonempty);
}
int top=QueueFront(nonempty);
QueuePop(nonempty);
return top;
}
int myStackTop(MyStack* obj) {
if(!QueueEmpty(&obj->n1))
{
return QueueBack(&obj->n1);}
else
{
return QueueBack(&obj->n2);}
}
void myStackFree(MyStack* obj) {
QueueDestroy(&obj->n1);
QueueDestroy(&obj->n2);
free(obj);
}
typedef struct Stack
{
int* a;
int top;
int capacity;
}Stack;
void StackInit(Stack* ps)
{
ps->a = NULL;
ps->top = 0;
ps->capacity = 0;
}
void StackPush(Stack* ps, int data)
{
assert(ps);
if (ps->capacity == ps->top)
{
int newcapcity = ps->capacity == 0 ? 4 : ps->capacity * 2;
int* tmp = (int*)realloc(ps->a, sizeof(int) * newcapcity);
if (tmp == NULL)
{
perror("realloc fail");
}
else
{
ps->a = tmp;
ps->capacity = newcapcity;
}
}
ps->a[ps->top] = data;
ps->top++;
}
int StackEmpty(Stack* ps)
{
assert(ps);
return ps->top == 0;
}
void StackPop(Stack* ps)
{
assert(ps);
assert(!StackEmpty(ps));
ps->top--;
}
int StackTop(Stack* ps)
{
assert(ps);
assert(!StackEmpty(ps));
return ps->a[ps->top - 1];
}
int StackSize(Stack* ps)
{
assert(ps);
return ps->top;
}
void StackDestroy(Stack* ps)
{
assert(ps);
free(ps->a);
ps->a = NULL;
ps->top = ps->capacity = 0;
}
typedef struct {
Stack pushst;
Stack popst;
} MyQueue;
MyQueue* myQueueCreate() {
MyQueue*obj=(MyQueue*)malloc(sizeof(MyQueue));
if(obj==NULL)
{
perror("malloc fail");}
StackInit(&obj->pushst);
StackInit(&obj->popst);
return obj;
}
bool myQueueEmpty(MyQueue* obj) {
return StackEmpty(&obj->pushst)&&StackEmpty(&obj->popst);
}
void myQueuePush(MyQueue* obj, int x) {
StackPush(&obj->pushst, x);
}
int myQueuePop(MyQueue* obj) {
if(StackEmpty(&obj->popst))
{
while(StackSize(&obj->pushst))
{
StackPush(&obj->popst, StackTop(&obj->pushst));
StackPop(&obj->pushst);
}
}
int ret=StackTop(&obj->popst);
StackPop(&obj->popst);
return ret;
}
int myQueuePeek(MyQueue* obj) {
if(StackEmpty(&obj->popst))
{
while(StackSize(&obj->pushst))
{
StackPush(&obj->popst, StackTop(&obj->pushst));
StackPop(&obj->pushst);
}
}
int ret=StackTop(&obj->popst);
return ret;
}
void myQueueFree(MyQueue* obj) {
StackDestroy(&obj->popst);
StackDestroy(&obj->pushst);
free(obj);
}
typedef struct {
int* a;
int tail;
int head;
int k;
} MyCircularQueue;
MyCircularQueue* myCircularQueueCreate(int k) {
MyCircularQueue* obj = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
if (obj == NULL)
{
perror("malloc fail");
}
int* tmp = (int*)malloc(sizeof(int) * (k + 1));
if (tmp == NULL)
{
perror("malloc fail");
}
obj->a = tmp;
obj->tail = obj->head = 0;
obj->k = k;
return obj;
}
bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
return obj->head == obj->tail;
}
bool myCircularQueueIsFull(MyCircularQueue* obj) {
int next = obj->tail + 1;
if (next == obj->k + 1)
next = 0;
return next == obj->head;
}
bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
if (myCircularQueueIsFull(obj))
return false;
obj->a[obj->tail] = value;
obj->tail++;
if (obj->tail== obj->k + 1)
{
obj->tail = 0;
}
return true;
}
bool myCircularQueueDeQueue(MyCircularQueue* obj) {
if (myCircularQueueIsEmpty(obj))
return false;
obj->head++;
if (obj->head== obj->k + 1)
{
obj->head = 0;
}
return true;
}
int myCircularQueueFront(MyCircularQueue* obj) {
if (myCircularQueueIsEmpty(obj))
return -1;
return obj->a[obj->head];
}
int myCircularQueueRear(MyCircularQueue* obj) {
if (myCircularQueueIsEmpty(obj))
return -1;
int front = obj->tail - 1;
if (front == -1)
{
front = obj->k;
}
return obj->a[front];
}
void myCircularQueueFree(MyCircularQueue* obj) {
free(obj->a);
free(obj);
}
int maxDepth(struct TreeNode* root) {
if(root==NULL)
return 0;
int left=maxDepth(root->left);
int right=maxDepth(root->right);
return left>right?left+1:right+1;
}
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);
}
bool isUnivalTree(struct TreeNode* root) {
if(root==NULL)
return true;
if(root->left&&root->left->val!=root->val)
return false;
if(root->right&&root->right->val!=root->val)
return false;
return isUnivalTree(root->left)&&isUnivalTree(root->right);
}
int BinaryTreeSize(struct TreeNode* root)
{
return root==NULL?0:BinaryTreeSize(root->left)+BinaryTreeSize(root->right)+1;
}
void aapreorderTraversal(struct TreeNode* root, int* a,int*pi)
{
if(root==NULL)
return ;
a[(*pi)++]=root->val;
aapreorderTraversal(root->left,a,pi);
aapreorderTraversal(root->right,a,pi);
}
int* preorderTraversal(struct TreeNode* root, int* returnSize)
{
* returnSize=BinaryTreeSize(root);
int*a=(int*)malloc(*returnSize*sizeof(int));
int i=0;
aapreorderTraversal(root,a,&i);
return a;
}
struct TreeNode* invertTree(struct TreeNode* root) {
if(root==NULL)
return NULL;
struct TreeNode* left=invertTree(root->left);
struct TreeNode* right=invertTree(root->right);
root->left=right;
root->right=left;
return root;
}
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);
}
bool isSubtree(struct TreeNode* root, struct TreeNode* subRoot){
if(root==NULL)
return false;
if( isSameTree(root,subRoot))
return true;
return isSubtree(root->left, subRoot)||isSubtree(root->right, subRoot);
}
#include <stdio.h>
#include <stdlib.h>
typedef struct BinaryTreeNode {
char data;
struct BinaryTreeNode* left;
struct BinaryTreeNode* right;
} BTNode;
BTNode* BinaryTreeCreate(char* a, int* pi)
{
if(a[*pi]=='#')
{
(*pi)++;
return NULL;}
BTNode* newnode=(BTNode*)malloc(sizeof(BTNode));
newnode->data=a[(*pi)++];
newnode->left=BinaryTreeCreate(a,pi);
newnode->right=BinaryTreeCreate(a,pi);
return newnode;
}
void InOrder(BTNode* root)
{
if(root==NULL)
return ;
InOrder(root->left);
printf("%c ",root->data);
InOrder( root->right);
}
int main() {
char arr[100];
scanf("%s",arr);
int i=0;
BTNode*bk= BinaryTreeCreate(arr,&i);
InOrder(bk);
}
int BinaryTreeSize(struct TreeNode* root)
{
return root==NULL?0:BinaryTreeSize(root->left)+BinaryTreeSize(root->right)+1;
}
void aapostorderTraversal(struct TreeNode* root, int*a,int*pi)
{
if(root==NULL)
return ;
aapostorderTraversal(root->left,a,pi);
aapostorderTraversal(root->right,a,pi);
a[(*pi)++]=root->val;
}
int* postorderTraversal(struct TreeNode* root, int* returnSize)
{
*returnSize=BinaryTreeSize(root);
int *a=(int*)malloc(*returnSize*sizeof(int));
if(a==NULL)
{
perror("malloc fail");}
int i=0;
aapostorderTraversal(root, a,&i);
return a;
}
int BinaryTreeSize(struct TreeNode* root)
{
return root==NULL?0:BinaryTreeSize(root->left)+BinaryTreeSize(root->right)+1;
}
void aapostorderTraversal(struct TreeNode* root, int*a,int*pi)
{
if(root==NULL)
return ;
aapostorderTraversal(root->left,a,pi);
a[(*pi)++]=root->val;
aapostorderTraversal(root->right,a,pi);
}
int* inorderTraversal(struct TreeNode* root, int* returnSize) {
*returnSize=BinaryTreeSize(root);
int*a=(int*)malloc(*returnSize*sizeof(int));
if(a==NULL)
perror("malloc fail");
int i=0;
aapostorderTraversal(root,a,&i);
return a;
}
bool aaisSymmetric(struct TreeNode* rootleft,struct TreeNode* rootright)
{
if(rootleft==NULL&&rootright==NULL)
return true;
if(rootleft==NULL||rootright==NULL)
return false;
if(rootleft->val!=rootright->val)
return false;
return aaisSymmetric(rootleft->left,rootright->right)&&aaisSymmetric( rootleft->right, rootright->left);
}
bool isSymmetric(struct TreeNode* root) {
return aaisSymmetric(root->left,root->right);
}
int aaisBalanced(struct TreeNode* root)
{
if(root==NULL)
return 0;
int leftheight=aaisBalanced(root->left);
int rightheight=aaisBalanced(root->right);
if(leftheight==-1)
return -1;
if(rightheight==-1)
return -1;
if(abs(leftheight-rightheight)>1)
return -1;
else
return leftheight>rightheight?leftheight+1:rightheight+1;
}
bool isBalanced(struct TreeNode* root) {
return aaisBalanced(root)==-1?false:true;
}