# C Primer Plus
## Pointer
```c=
int main(int argc, char **argv)
{
int * pi; //pi is a pointer to integer variable
char * pc; //pc is a pointer to char variable
}
int main(int argc, char **argv)
{
int ref[4] = {8,4,0,2};
int *ptr,index;
for(index=0,ptr = ref;index<4;index++,ptr++)
printf("%d %p %p\n",*ptr,ptr,&ptr); // value ; point-to-address ; address of pointer itself
}
```
### Use pointer to exchange
```c=
#include <stdio.h>
#include <ctype.h>
#include <stdbool.h>
void interchange(int * u, int * v);
int main(int argc, char **argv)
{
int x=5,y=10;
interchange(&x,&y);
printf("%d",x);
}
void interchange(int * u, int * v)
{
int temp;
temp = *u;
*u = *v;
*v = temp;
}
```
### Point to multiDimensional array
```c=
// This is an example of declartion
int (* pz)[2]; // pz points to a two-dimension array
int * pz[2]; // pz is an array of two pointer-to-int
// Deal with two dimension array
int sum2d(int ar[][COLS]);
int main(int argc, char **argv)
{
int ar[3][COLS] = {
{1,2,3,4},
{5,6,7,8},
{9,1,6,5}
};
printf("%d",sum2d(ar));
}
int sum2d(int (* ar)[COLS])
{
int sum = 0;
for(int i=0;i<3;i++)
{
for(int j=0;j<COLS;j++)
{
sum+= (*(ar+i))[j];
printf("%d ",(*(ar+i))[j]);
}
printf("\n");
}
return sum;
}
```
```c=
// Compound literal
// use pointer to keep track of the compund literal declaration
int main(int argc, char **argv)
{
int * p;
p = (int [2]) {10,20}; // same as int ar[2] = {10,20};
printf("%d", *p++);
}
```
## String
### Some library
```c=
// this library is for char array
#include <ctype.h>
// The ctype.h header file of the C Standard
// Library declares several functions
// that are useful for testing and mapping characters.
char str[];
strlen(str); // return the length of string
strcat(str); // concantate two string and delare to fore one
strcmp(str1,str2); // compare two string , 0 match , !=0 unmatch
strcpy(str1,str2); // copy the string to fore one
```
### sprintf
```c=
int main(int argc, char **argv)
{
char str1[10] = "hello";
char str2[5] = "ncku";
char full[50];
sprintf(full, "%7s I am Li from %6s" , str1 , str2);
puts(full); // hello I am Li from ncku
}
```
## Structure
### Allocate memory
```c=
struct TreeNode* node = (struct TreeNode*)malloc(sizeof(struct TreeNode));
```
### Via pointer
```c=
struct name{
char firstName[];
char lastName[];
}
int main(int argc,char **argc)
{
struct name person = {
"Chen Wei",
"Li"
};
struct name * ptr = &person;
}
```
### Pass value
```c=
struct fund{
int value;
}
// use a constant pointer points to a structure
int sum(const struct fund * ptr);
```
## Bit
```c=
/*
* reverse a uint32_t value
*/
uint32_t reverseBits(uint32_t n) {
uint32_t bits[32];
uint32_t bin = 1; //0b00000000000000000000000000000001
uint32_t ret = 0;
// store all of the mask and reverse the mask
for(int i=0;i<32;i++){
bits[i] = (n&(bin<<i))>>i;
bits[i] <<= (31-i);
ret |= bits[i];
}
return ret;
}
/*
* 改良版
*/
uint32_t reverseBits(uint32_t n) {
uint32_t bin = 1 , ret = 0;
for(int i=0;i<32;i++){
ret |= ((n & (bin << i)) >> i ) << (31-i);
}
return ret;
}
```
## Sort
```c=
#include <stdio.h>
#include <stdlib.h>
void fillarray(double ar[], int n);
void showarray(const double ar[], int n);
int mycomp(const void* p1,const void * p2);
int main(int argc, char **argv)
{
double vals[10];
fillarray(vals,10);
showarray(vals,10);
qsort(vals,10,sizeof(double),mycomp);
showarray(vals,10);
}
void fillarray(double ar[], int n)
{
int index;
for(index = 0;index < n;index++)
ar[index] = (double)rand() / ((double)rand() + 0.1);
}
void showarray(const double ar[],int n)
{
int index;
for(index=0;index < n;index++)
{
printf("%9.4f",ar[index]);
}
putchar('\n');
}
int mycomp(const void * p1, const void * p2)
{
const double * a1 = (const double *) p1;
const double * a2 = (const double *) p2;
if(*a1 > *a2) // > 降序 ， < 升序
return -1;
else if(*a1 == *a2)
return 0;
else
return 1;
}
/*
*
* long long 長整數排序
*
*/
int _cmp(const void * a, const void * b)
{
if( *(long long int*)a - *(long long int*)b < 0 )
return -1;
if( *(long long int*)a - *(long long int*)b > 0 )
return 1;
return 0;
}
/*
* 簡化版 mycomp
* 升序排列
*/
static int _cmp(const int *l,const int *r){
return (*l - *r);
}
```
### Merge sort
### Heap sort
先將數組按binary tree順序放入堆疊中，若比父母節點大則向上移動
接著從根結點開始拿取，拿完和最右葉節點做交換，然後將此節點向下做排序(找大的)跟他換
### Quick sort
```c=
// Quick sort in C
#include <stdio.h>
// function to swap elements
void swap(int *a, int *b) {
int t = *a;
*a = *b;
*b = t;
}
// function to find the partition position
int partition(int array[], int low, int high) {
// select the rightmost element as pivot
int pivot = array[high];
// pointer for greater element
int i = (low - 1);
// traverse each element of the array
// compare them with the pivot
for (int j = low; j < high; j++) {
if (array[j] <= pivot) {
// if element smaller than pivot is found
// swap it with the greater element pointed by i
i++;
// swap element at i with element at j
swap(&array[i], &array[j]);
}
}
// swap the pivot element with the greater element at i
swap(&array[i + 1], &array[high]);
// return the partition point
return (i + 1);
}
void quickSort(int array[], int low, int high) {
if (low < high) {
// find the pivot element such that
// elements smaller than pivot are on left of pivot
// elements greater than pivot are on right of pivot
int pi = partition(array, low, high);
// recursive call on the left of pivot
quickSort(array, low, pi - 1);
// recursive call on the right of pivot
quickSort(array, pi + 1, high);
}
}
// function to print array elements
void printArray(int array[], int size) {
for (int i = 0; i < size; ++i) {
printf("%d ", array[i]);
}
printf("\n");
}
// main function
int main() {
int data[] = {8, 7, 2, 1, 0, 9, 6};
int n = sizeof(data) / sizeof(data[0]);
printf("Unsorted Array\n");
printArray(data, n);
// perform quicksort on data
quickSort(data, 0, n - 1);
printf("Sorted array in ascending order: \n");
printArray(data, n);
}
```
### HASH
```c
// UT_hash_handle 為必要聲明
struct hash_struct {
int id;
int value;
UT_hash_handle hh;
};
bool containsNearbyDuplicate(int* nums, int numsSize, int k){
// 建立空哈希表
struct hash_struct *map = NULL;
for(int i = 0 ; i < numsSize ;i++) {
struct hash_struct *tmp;
// 第二個參數一定要傳遞地址
HASH_FIND_INT(map, &nums[i], tmp);
if(tmp == NULL) {
// 宣告空間並賦值
tmp = (struct hash_struct*)malloc(sizeof(struct hash_struct));
tmp->id = nums[i];
tmp->value = i;
// 第二個參數添加鍵字段名稱 id
HASH_ADD_INT(map, id, tmp);
} else {
if((i - tmp->value) <= k)
return true;
else
tmp->value = i;
}
}
return false;
}
```
## Terms
- VLA
The length of an array is determined during run-time (not compile time)
-
## Some Questions
- How const works? A pointer can change the value of const array.
Sign in with Wallet
Connect another wallet