密笈？！

咳咳咳...

===比數字===

int comp(const void *a , const void *b)

{

    return (*(int *)a - *(int*)b);

}

 qsort((void *)coins,coinsSize,sizeof(int),comp);

===比字串===

int comp (const void *a , const void *b)

{

    return strcmp((char *)a, (char *)b);

}

qsort(s,len,sizeof(char),comp);

===比數字的二維陣列===

int comp(const void *a, const void *b)  

{  

    int *A= *(int **)a;

    int *B= *(int **)b;

    return A[0]-B[0];

}

qsort((void *)points, pointsSize, sizeof(points[0]), comp);

(另一種？！)

int comp(const void *a, const void *b)

{

    int* p1 = *(int **)a;

    int* p2 = *(int **)b;

    return p1[1]-p2[1];

}

qsort(intervals, intervalsSize, sizeof (int*), comp);

如果數字相減會overflow，就改成比大小後回傳0, 1, -1

int comp(const void *a, const void *b)

{

    int *A= *(int**)a;

    int *B= *(int**)b;

    if (A[1]==B[1])

        return 0;

    else 

        return (A[1] > B[1]) ? (1) : (-1);

}

qsort((void *)points, pointsSize,sizeof (int**), comp);

===malloc===

char* str = malloc (sizeof(char)*(maxLen+2));

int* ret = malloc (sizeof(int)*numsSize);

===calloc===

char *ret = calloc(len, sizeof(char));

數字初始化為零

int *count = calloc (len,sizeof(int)*(len));

===memset & memcpy===

memcpy(dest,source,sizeof(int)*numsSize);

memset(stack, 0, sizeof(char) * (maxLen *maxLen));

（二維）memcpy 如果宣告時是 ** 則 :

輸入為 **grid ,  m x n 大小

int **rotate = calloc (m, sizeof(int *));

for (int i=0;i<m; i++)

    rotate[i]= calloc (n, sizeof(int));

memcpy(rotate, grid, sizeof(int*)*m);

此時sizeof(int) 是4 , sizeof (int*) 跟sizeof(int**) 跟sizeof (grid)都是8

但是此方法有可能有copy到garbage的情況？！ 建議還是兩個for 下去複製......QQ

(沒時間debug XD 或是歡迎知道原因的人在下面留言(?))

使用memcmp看了一下，使用memcpy確實是兩組一樣的。反而assign的話會變成兩者不同！

（大驚）

再度推測，因為grid 是傳進來的，因此可能？！（好吧真的沒時間了，這問題先停在這Orz）

若是用[] [] 方式則 （用 2x3舉例）

    int TEST[2][3]={{4,3,2},{4,3,2}};

    int OUT[2][3]={{1,2,3},{1,2,3}};

    memcpy(OUT, TEST, sizeof(int)*(2*3));

===quick sort 例子===

void swap(int *a, int *b)

{

    int tmp;

    tmp = *a;

    *a=*b;

    *b=tmp;

}

void qqsort(int* nums,int low, int right)

{

    int l=low, r=right;

    int mid = (l+r)/2;

    int pivot= nums[mid];

    while (l<=r)

    {

        while (nums[l]< pivot)

            l++;

        while (nums[r]>pivot)

            r--;

        if (l<=r)

        {

            swap(&nums[l],&nums[r]);

            l++;

            r--;

        }

    }

    if (low<r)

        qqsort(nums,low,r);

    if (l<right)    

        qqsort(nums,l,right);

}

void merge(int* nums1, int nums1Size, int m, int* nums2, int nums2Size, int n){

    if (n==0 && m==1)

        return;

    if (n==1 && m==0)

    {

        nums1[0]=nums2[0];

        return;

    }

    for (int i =m;i< m+n;i++)

        nums1[i]=nums2[i-m];

    qqsort(nums1,0,nums1Size-1);

}

=====binary search=====

    

int search(int* nums, int numsSize, int target){

    int left=0,right=numsSize-1;

    int mid=(left+right)/2;

    while (left<=right)

    {

        mid=(left+right)/2;

        if (nums[mid] < target)

            left=mid+1;

        else if (nums[mid]> target)

            right=mid -1;

        else

            return mid;

    }

    return -1;

}

=====新版 malloc & return column=====

int** permute(int* nums, int numsSize, int* returnSize, int** returnColumnSizes){

    int count= factorial(numsSize);

    *returnSize = count;

    int **ret = malloc(sizeof(int*)* (count));

    *returnColumnSizes= malloc (sizeof(int)*(count));

    for (int i=0;i<(count);i++)

    {

        ret[i]=malloc(sizeof(int)*numsSize);

        (*returnColumnSizes)[i]= numsSize;

    }

    count=0;

    myPermute(nums, numsSize,&count,0,numsSize-1,ret);

    return ret;    

}

要用到的時候再calloc / malloc 就好了，不用一定要先用for 回圈跑起來初始化

例子: 

int checkSum(struct TreeNode* root, int **ret, int **returnColumnSizes, int *data)

{

    ret[o_idx]=calloc(idx+1, sizeof(int)); //宣告 ret[i][j]的 j的部分

    o_idx = checkSum(root->left, target, idx+1,o_idx, ret, returnColumnSizes,data);

}

int** pathSum(struct TreeNode* root, int targetSum, int* returnSize, int** returnColumnSizes) {

    int** ret = calloc (5000, sizeof(int*)); //宣告全部的size

    *returnSize = checkSum(root, returnColumnSizes, data);

    return ret;

}

=====C的hash table 怎麼用=====

(好像要include東西，但看起來leetcode裡面有包 XD）

struct hash_struct{

    int id;

    int value;

    UT_hash_handle hh;

};

struct hash_struct *hash=NULL; //整個hash table

struct hash_struct *tmp=NULL;  //要新建的時候拿來當做tmp pointer

//（建table)

HASH_FIND_INT( hash, &nums[i], tmp );  //先看這個element 在不在裡面，用id找

if (tmp == NULL)

{

    tmp=malloc (sizeof (struct hash_struct)*1);

    tmp->id= nums[i];

    tmp->value=i;

    HASH_ADD_INT(hash, id ,tmp);  //不在的話加進去。第二個參數"id"是欄位的名字"id",就是這樣寫XD

}

=====宣告一個function pointer=====

回傳值是int , 參數是一個int

int (*a)(int);