suitaox26456的博客

#define HASH_SIZE 10009typedef enum { Legitimate, Empty, Deleted } Entry_type;struct hash_entry{ int val; Entry_type info;};typedef struct { int size; struct hash_entry* cells;} MyHashSet;int hash_function(MyHashSet* obj, int key){ retur.

void swap(int* a, int* b){ int temp = *a; *a = *b; *b = temp;}int removeElement(int* nums, int numsSize, int val){ if (numsSize == 1) { if (nums[0] == val) { return 0; } else { return 1; } } for (int i = 0; i < numsSize -.

void swap(int* a, int* b){ int temp = *a; *a = *b; *b = temp;}void moveZeroes(int* nums, int numsSize){ if (numsSize == 1) { return; } for (int i = 0; i < numsSize - 1; i++) { if (nums[i] == 0) { int j; for (j = i + 1; j <.

#define MAX_DATE 10000typedef struct heap_type* Heap;struct heap_type{ int capacity; int size; int* elements;};Heap create(int max_size){ Heap h = malloc(sizeof(struct heap_type)); h->elements = malloc((max_size + 1) * sizeof(int)); h.

#define MIN_DATE -1typedef struct heap_type* Heap;struct heap_type{ int capacity; int size; int* elements;};Heap create(int max_size){ Heap h = malloc(sizeof(struct heap_type)); h->elements = malloc(sizeof(int) * (max_size + 1)); h->.

struct node{ int val; struct node* next;};typedef struct { struct node* first;} MyLinkedList;MyLinkedList* myLinkedListCreate(){ MyLinkedList* obj = malloc(sizeof(MyLinkedList)); obj->first = NULL; return obj;}int myLinkedListGet(MyLin.

struct TreeNode* create(){ struct TreeNode* t = malloc(sizeof(struct TreeNode)); t = NULL; return t;}struct TreeNode* insert(int* nums, int left, int right){ int mid = (left + right) / 2; struct TreeNode* new_node = malloc(sizeof(struct TreeNode.

int node_height(struct TreeNode* root, bool* balance){ if (root == NULL) { return -1; } int left_height = node_height(root->left, balance); int right_height = node_height(root->right, balance); if (left_height - right_height > 1 || rig.

typedef int Item;typedef struct stack_type* Stack;struct node { Item val; struct node* next;};struct stack_type { struct node* top;};static void terminate(const char* message){ printf("%s\n", message); exit(EX.

typedef int Item;typedef struct stack_type* Stack;struct node { Item val; struct node* next;};struct stack_type { struct node* top;};static void terminate(const char* message){ printf("%s\n", message); exit(EX.

typedef char Item;typedef struct stack_type* Stack;struct node { Item val; struct node* next;};struct stack_type { struct node* top;};static void terminate(const char* message){ printf("%s\n", message); exit(EX.

struct node{ int val; struct node* next;};typedef struct { struct node* top; struct node* min_stack_top;} MinStack;MinStack* minStackCreate(){ MinStack* obj = malloc(sizeof(MinStack)); obj->top = obj->min_stack_top = NULL; return obj;.

struct TreeNode* find_max(struct TreeNode* root){ if (root == NULL) { return NULL; } if (root->right != NULL) { return find_max(root->right); } else { return root; }}struct TreeNode* deleteNode(struct TreeNode* root, int key){ .

struct TreeNode* insertIntoBST(struct TreeNode* root, int val) { if (root==NULL) { root = malloc(sizeof(struct TreeNode)); root->val = val; root->left = root->right = NULL; } if (val<root->val) { root->left = insertIntoBST.

//递归struct TreeNode* searchBST(struct TreeNode* root, int val){ if (root == NULL) { return NULL; } if (val < root->val) { return find(root->left, val); } else if (val > root->right) { return find(root->right, val); } e.

void inorder(struct TreeNode* root, int* a, int* i){ if (root == NULL) { return; } if (root != NULL) { inorder(root->left, a, i); a[*i] = root->val; *i += 1; inorder(root->right, a, i); }}bool isValidBST(struct TreeNode* root).

bool check(struct TreeNode* root, int targetSum, int sum){ if (root == NULL) { return false; } sum += root->val; if (root->left == NULL && root->right == NULL) { if (sum == targetSum) { return true; } else { retu.

bool is_same(struct TreeNode* root1, struct TreeNode* root2){ if (root1 == NULL && root2 == NULL) { return true; } else if (root1 != NULL && root2 != NULL) { if (root1->val != root2->val) { return false; } else {.

int depth(struct TreeNode* root, int dep){ int left_dep, right_dep; if (root == NULL) { return dep; } if (root != NULL) { dep++; left_dep = depth(root->left, dep); right_dep = depth(root->right, dep); } return left_dep > right_.

void postorder(struct TreeNode* root, int* returnSize, int* a){ if (root == NULL) { return; } if (root != NULL) { postorder(root->left, returnSize, a); postorder(root->right, returnSize, a); a[*returnSize] = root->val; (*returnSi.

void preorder(struct TreeNode* root, int* returnSize, int* a){ if (root == NULL) { return; } if (root != NULL) { a[*returnSize] = root->val; (*returnSize)++; preorder(root->left, returnSize, a); preorder(root->right, returnSize, .

//栈typedef struct stack_type* Stack;struct node{ int val; struct node* next;};struct stack_type{ struct node* first;};//Myqueuetypedef struct { struct stack_type* s1; struct stack_type* s2;} MyQueue;//栈的操作bool is_empty(Stack s){ if (.

int search(int* nums, int numsSize, int target) { if (numsSize == 1) { if (nums[0] == target) { return 0; } else { return -1; } } int i, j, n; int* a = malloc(numsSize * sizeof(int)); for (i = 1; i < numsSize; i++) { if (nu.

int guessNumber(int n){ int low=1,high=n,mid; while(low<=high) { mid=low+(high-low)/2; if(guess(mid)==-1) { high=mid-1; }else if (guess(mid)==1) { low=mid+1; }else .

int search(int* nums, int numsSize, int target){ int low=0,high=numsSize-1; while(low<=high) { int mid=low+(high-low)/2; if(nums[mid]>target) { high=mid-1; }else if (nums[mid]<target) .

#include<stdio.h>#include<stdlib.h>#include<stdbool.h>typedef struct queue_type* Queue;struct node{ int val; struct node* next;};struct queue_type{ struct node* first; struct node* last;};//MyStacktypedef struct{ stru.

void in_oreder(struct TreeNode* root, int* res, int* returnSize){ if (root==NULL) { return; } if (root!=NULL) { in_oreder(root->left, res, returnSize); res[*returnSize] = root->val; (*returnSize)++; in_oreder(root->right, res, ret.

{ //快慢指针法：开始时快，慢指针都指向第一个元素，快指针一次走两步，慢指针一次走一步。 //当快指针指向未结点时，慢指针恰好指向中间结点 struct ListNode* slow = head; struct ListNode* fast = head; while (fast!=NULL&&fast->next!=NULL) { slow = slow->next; fast = fast->next->next; } return .

int missingNumber(int* nums, int numsSize){ //首先判断数组首元素或末元素是否缺失 if (nums[0]!=0) { return 0; } if (nums[numsSize-1]!=numsSize) { return numsSize; } //如果首，末元素都不缺失，就用二分查找去数组中寻找 int left = 0; int right = numsSize - 1; int mid; while (left&lt.

struct ListNode* removeElements(struct ListNode* head, int val) { //首先，判断链表是否为空，若为空直接返回 if (head==NULL) { return head; } //其次，判断第一个结点是否需要删除，如果需要删除，则把head指针移动到下一个结点，不断循环，直到第一个结点不需要删除为止 while (head->val==val) { //这里需要判断一下该结点是否为最后一个元素，如果是最后一个.

int thirdMax(int* nums, int numsSize) { //首先将元素从大到小排序 for (int i = 0; i < numsSize; i++) { for (int j = i; j >0 && nums[j-1]<nums[j]; j--) { int temp = nums[j-1]; nums[j - 1] = nums[j]; nums[j] = temp; } } //其次寻找第三大的.

int missingNumber(int* nums, int numsSize){ //首先，将元素从小到大排序 for (int i = 0; i < numsSize; i++) { for (int j = i; j > 0 && nums[j - 1] > nums[j]; j--) { int temp = nums[j - 1]; nums[j - 1] = nums[j]; nums[j] = temp; } }.

bool containsDuplicate(int* nums, int numsSize) { //首先，将元素从小到大依次排序 for (int i = 0; i < numsSize; i++) { for (int j = i; j > 0 && nums[j - 1] > nums[j]; j--) { int temp = nums[j - 1]; nums[j - 1] = nums[j]; nums[j] = temp;.

//首先将元素从小到大排列，因为多数元素存在，则numsSize/2一定为多数元素int majorityElement(int* nums, int numsSize) { for (int i = 0; i < numsSize; i++) { for (int j = i; j >0&&nums[j-1]>nums[j]; j--) { int temp = nums[j - 1]; nums[j - 1] = nums[j]; n.

void merge(int* nums1, int nums1Size, int m, int* nums2, int nums2Size, int n){ //首先排除特殊情况：nums2为空的情况（即n==0) if (n == 0) { return; } //其次将nums2合并到nums1中去 for (int i = m, j = 0; i < m + n && j < n; i++, j++) { nums1[i] = nums2[j].

struct ListNode* getKthFromEnd(struct ListNode* head, int k) { int n = 1; struct ListNode* cnt = head; while (cnt->next!=NULL) { cnt = cnt->next; n++; } int i = n - k; struct ListNode* list = head; while (i>0 && list->nex.

int mySqrt(int x) { if (x==0) { return 0; } if (x==1) { return 1; } int low = 1; int high = x / 2; while (low<=high) { int mid = (low + high) / 2; if (x/mid==mid) { return mid; } else if (x/mid>mid) { low = mid + 1.

int searchInsert(int* nums, int numsSize, int target){ int low = 0; int high = numsSize - 1; while (low<=high) { int mid = (low + high) / 2; if (nums[mid]==target) { return mid; } else if (nums[mid]>target) { high = mid - 1;.

/** * Definition for singly-linked list. * struct ListNode { * int val; * struct ListNode *next; * }; */struct ListNode* addTwoNumbers(struct ListNode* l1, struct ListNode* l2) { struct ListNode* l3 = NULL; struct ListNode* curr =.

//生成一个链表struct ListNode { int val; struct ListNode* next;};struct ListNode* head = NULL;//方法一：遍历链表struct ListNode* deleteDuplicates(struct ListNode* head){ int a[201] = { false }; struct ListNode* prev = NULL; struct ListNode* curr = head; .