C語言練習題二

原創 会跑路的300块 2019-08-22 21:56 
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>

#include<stdio.h>
////使用宏實現兩個數中求較大值

//#define MAX(a,b) (a)>(b)?(a):(b)
//
//int main()
//{
//	int max = MAX(3,4);
//	printf("max = %d",max);
//	return 0;
//}



////寫一個宏可以將一個數字的奇數位和偶數位交換

//#define SWAP(a,b,c)  (c = a) ; (a = b); (b = c)
//int main()
//{
//	int i = 0;
//	int a = 0;
//	int j = 0;
//	int m = 0;
//	int n = 0;
//	int tmp = 0;
//	scanf("%d",&a);
//	for(i=31;i>=0;i-=2)
//	{
//		j = i;
//		m = (a>>j)&1;
//		n = (a>>(j-1))&1;
//		//tmp = m;
//		//m = n;
//		//n = tmp;
//		SWAP(m,n,tmp);      //(() = ();() = ();()=());
//		printf("%d%d",m,n);
//	}
//	return 0;
//}


//#define SWAP(num) (num = ((num & 0xaaaaaaaa) >> 1) | ((num & 0x55555555) << 1))
//int main()
//{
//	int num = 30;
//	SWAP(num);
//	printf("%d\n",num);
//	return 0;
//}

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>

////編寫函數： 
////unsigned int reverse_bit(unsigned int value); 
////這個函數的返回 值value的二進制位模式從左到右翻轉後的值。 
////
////如： 
////在32位機器上25這個值包含下列各位： 
////00000000000000000000000000011001 
////翻轉後：（2550136832） 
////10011000000000000000000000000000 
////程序結果返回： 
////2550136832 

//typedef unsigned int unit;
//#include<math.h>
//unsigned int reverse_bit(unsigned int value)
//{
//	int i = 0;
//	unsigned int num = 0;
//	for(i=0;i<32;i++)
//	{
//		//num = (unit)(num + ((value >> i) & 1) * pow(2,32-i-1));
//		num |= ((value >> i) & 1) << (31 - i);       //效率更高 (拿到那一位將它左移到對應位，進行或等就會得到翻轉的值)
//
//	}
//	return num;
//}
//
//int main()
//{
//	unsigned int i = 0;
//	unsigned int ret = 0;
//	scanf("%d",&i);         //不能寫成 scanf("%u",%i); 程序會崩潰
//	ret = reverse_bit(i);
//	printf("%u\n",ret);
//	//printf("%d\n",sizeof(unit));
//	return 0;
//}



////不使用（a+b）/2這種方式，求兩個數的平均值

////方法一

//int Average(int x, int y)
//{
//	return y+(x-y)/2;
//}

////方法二
//00001010     10
//00010100     20
//
//00000000     & 
//00011110     ^
//00001111     ^ >>1

////首先，&得到的數字位，只有兩個1纔得到1，就是進位的1，
////而本該向前進一位的1待在了本位。實際上
////應該讓得到的結果左移1（讓進位的1進到合適的位置），
////然後再右移1（除以2），得到進位的平均數。
////然後，^得到的數字位，實際得到的是本位得到的結果（不包括進位），
////讓他右移1，得到本位的平均數。
////兩個平均數相加，得到整個數完整的平均數。

//#include<math.h>
//int Average(int x, int y)
//{
//	return (x & y) + ((x ^ y) >> 1);    //(x&y) x和y相同位的平均值  (x^y)>>1 x和y不同位的平均值
//}
//
//int main()
//{
//	int a = 25;
//	int b = 15;
//	int ret = 0;
//	ret = Average(a,b);
//	printf("%d\n",ret);
//	return 0;
//}


////編程實現： 
////一組數據中只有一個數字出現了一次。其他所有數字都是成對出現的。 
////請找出這個數字。（使用位運算） 

//int look_out(int *a, int len)
//{
//	int i = 0;
//	int ret = 0;
//	for(i=0;i<len;++i)
//	{
//		ret ^= a[i];     //用異或操作
//	}
//	return ret;
//}
//
//int main()
//{
//	int arr[] = {1,2,3,4,5,6,7,8,9,2,3,4,5,6,7,8,9};
//	int len = sizeof(arr)/sizeof(arr[0]);
//	int ret = 0;
//	ret = look_out(arr,len);
//	printf("%d\n",ret);
//	return 0;
//}


////有一個字符數組的內容爲:"student a am i",請你將數組的內容改爲"i am a student". 
////要求： 
////不能使用庫函數。只能開闢有限個空間（空間個數和字符串的長度無關）

////求字符串長度
//int my_strlen(const char *dst)
//{
//	int count = 0;
//	while(*dst != '\0')
//	{
//		dst++;
//		count++;
//	}
//	return count;
//}
//
//
//////逆序函數
//void Reverse(char arr[], int left, int right)
//{	
//	while(left<right)
//	{
//		char tmp = arr[left];
//		arr[left] = arr[right];
//		arr[right] = tmp;
//		left++;
//		right--;
//	}
//}
//
//
//////逆序字符串
//char* reverse_str(char arr[])
//{
//	int left = 0;
//	int right = my_strlen(arr) - 1;
//	int i = 0;
//	//先逆序整個字符串
//	Reverse(arr,left,right);
//	//逐個逆序單詞
//	while(arr[i] != '\0')
//	{
//		left = i;
//		//逆序一個單詞
//		while((arr[i] != ' ') && arr[i] != '\0')    //條件重點理解
//		{
//			i++;
//		}
//		right = i - 1;             //i是空格的下標
//		Reverse(arr,left,right);
//		if(arr[i] == ' ')         //判斷不能少，不然會跳過\0，程序崩潰,   也不能寫成 !=
//		{
//			i++;
//		}
//	}
//	return arr;
//}
//
//
//int main()
//{
//	char arr[] = "chao li";
//	reverse_str(arr);
//	printf("%s\n",arr);
//	
//	return 0;
//}


#define _CRT_SECURE_NO_WARNINGS 1

//#include<stdio.h>

////遞歸和非遞歸分別實現求第n個斐波那契數

////遞歸的方法
/*int Fib(int n)
{
        if(n<=2)
        {
                return 1;
        }
        else
        {
                return Fib(n-1)+Fib(n-2);
        }       
}

int main()
{
        int n = 0;
        int ret = 0;
        scanf("%d",&n);
        ret = Fib(n);
        printf("ret = %d\n",ret);
        return 0;
}*/


//// 循環的方法

/*int Fib(int n)
{
        int a = 1;
        int b = 1;
        int c = 1;
        while(n>2)
        {
                c = a+b;
                a = b;
                b = c;
                n--;
        }
        return c;
}


int main()
{
        int n = 0;
        int ret = 0;
        scanf("%d",&n);
        ret = Fib(n);
        printf("ret = %d\n",ret);
        return 0;
}*/

////編寫一個函數實現n^k，使用遞歸實現 

////n^k = n*n^k-1
/*int second_party(int n ,int k)
{
        if(k>0)
        {
                return second_party(n,k-1)*n;
        }
        else
        {
                return 1;
        }

}

int main()
{
        int n = 0;
        int k = 0;
        int ret = 0;
        scanf("%d %d",&n,&k);
        ret = second_party(n,k);
        printf("n的k次方是:%d\n",ret);
        return 0;
}*/



////寫一個遞歸函數DigitSum(n)，輸入一個非負整數，返回組成它的數字之和，例如，調用DigitSum(1729)，則應該返回1+7+2+9，它的和是19 

/*int dig_itsum(int n)
{
        if((n/10)>0)
        {
                return n%10 + dig_itsum(n/10);  
        }
        
}

int main()
{       
        int n = 0;
        int ret = 0;
        scanf("%d",&n);
        ret = dig_itsum(n);
        printf("ret = %d\n",ret);
        return 0;
}*/



////遞歸和非遞歸分別實現strlen 

////非遞歸
/*#include<assert.h>
int my_strlen(char *p)
{
        int count = 0;
        assert(p != NULL);
        while(*p != '\0')
        {
                count++;
                *p++;   
        }
        return count;
}

int main()
{
        char *ch = "abcdefg";  // 錯誤的寫法char = "abcdef";
        int i = 0;
        i = my_strlen(ch);
        printf("%d\n",i);
        return 0;
}*/

////遞歸

/*#include<assert.h>
int my_strlen(char *p)
{
        assert(p != NULL);
        if(*p != '\0')
        {
                return 1 + my_strlen(p+1);//錯誤的寫法(*p+1)
        }
        else
        {
                return 0;
        }
}

int main()
{
        char *ch = "abcdefgh";
        int i = 0;
        i = my_strlen(ch);
        printf("%d\n",i);
}*/


////遞歸和非遞歸分別實現求n的階乘 

////非遞歸 

/*int Fun(int n)
{
        int i = 0;
        int ret = 1;
        for(i = 1;i<=n;i++)
        {
                ret = ret * i;
        }
        return ret;
}       
int main()
{       
        int n = 0;
        int ret = 0;
        scanf("%d",&n);
        ret = Fun(n);
        printf("%d\n",ret);
        return 0;
}*/

////遞歸

/*int Fun(int n)
{
        if(n<2)
        {       
                return 1;
        }
        else
        {
                return n * Fun(n-1);
        }
}

int main()
{       
        int n = 0;
        int ret = 0;
        scanf("%d",&n);
        ret = Fun(n);
        printf("%d\n",ret);
        return 0;
}*/


////遞歸方式實現打印一個整數的每一位 

/*void Fun(int num)
{
        if(num >9)
        {
                Fun(num/10);   // printf()不能寫到 if語句的裏面
        }       
        printf("%d ",num%10);
        
}

int main()
{       
        int num = 0;
        scanf("%d",&num);
        Fun(num);
        return 0;
}*/



////編寫一個函數reverse_string(char * string)（遞歸實現） 
////實現：將參數字符串中的字符反向排列。 
////要求：不能使用C函數庫中的字符串操作函數。 
//#include<assert.h>
//void reverse_string(const char *p)
//{
//        assert(p != NULL);
//        if(*p != '\0')
//        {
//                reverse_string(p+1);
//        }
//        printf("%c ",*p);
//}
//
//int main()
//{
//        char *ch = "abcdef";
//        reverse_string(ch);
//        return 0;
//}


#define _CRT_SECURE_NO_WARNINGS 1
//#include<stdio.h>

////一個數組中只有兩個數字是出現一次，其他所有數字都出現了兩次。 
////找出這兩個數字，編程實現。 

//int Find(int sz, int arr[])
//{	
//	int i = 0;
//	int ret = 0;
//	for(i=0;i++;i<sz)
//	{
//		ret = arr[i] ^ ret;
//	}
//
//	return ret;
//}
//
//int main()
//{
//	int arr[] = {1,1,2,2,3,3,4,4,5};
//	int sz = sizeof(arr)/sizeof(arr[0]);
//	int ret = Find(sz,arr);
//	printf("%d\n",ret);
//	//printf("%d\n",sz);
//	return 0;
//}


////喝汽水，1瓶汽水1元，2個空瓶可以換一瓶汽水，給20元，可以多少汽水。編程實現

//int Exchange(int money)
//{
//	int bottle = 0;
//	int water = 0;
//	bottle = money;
//	water = money;
//	while(bottle>1)
//	{
//		water = water + bottle/2;
//		bottle = bottle/2+bottle%2;		
//	}
//	return water;
//	//return money*2-1;
//}
//int main()
//{
//	int i = 0;
//	int ret = 0;
//	scanf("%d",&i);
//	ret = Exchange(i);
//	printf("%d\n",ret);
//	return 0;
//}


////模擬實現strcpy 

//#include<assert.h>

//char *my_strcpy(char *dst, const char *src)
//{	
//	char *ret = dst;
//	assert(dst != NULL);
//	assert(src != NULL);
// 
//	while(*src != '\0')
//	{
//		*dst = *src;
//		dst++;
//		src++;
//	}
//	return dst;
//}

//char *my_strcpy(char *dst, const char *src)
//{
//	char *ret = dst;
//	assert(dst != NULL);
//	assert(src != NULL);
//	
//	while(*dst++ = *src++)
//	{
//		;
//	}
//	return dst;
//}
//
//int main()
//{
//	char *ch = "abcdef";
//	char buf[10] = {0};
//	char *ret = my_strcpy(buf,ch);
//	printf("buf:%s\n",buf);
//	return 0;
//}


////模擬實現strcat

//#include<assert.h>
//
//char *my_strcat(char *dst,const char *src)
//{
//	char *ret = dst; 
//	assert(dst != NULL);
//	assert(src != NULL);
//	while(*dst)
//	{
//		dst++;
//	}
//	while(*dst++ = *src++)
//	{
//		;
//	}
//	return ret;
//}
//
//int main()
//{
//	char arr1[20] = "abcd";          //定義的數組大小要大於鏈接後的大小
//	char arr2[] = "aefgh";
//	//char *ret = my_strcat(arr1,arr2);  
//	my_strcat(arr1,arr2);
//	printf("連接後的結果：%s\n",arr1);
//	return 0;
//}

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>

////作業19

////模擬strcpy函數
//#include<assert.h>
//char *my_strcpy(char *dst, const char *src)
//{
//	char *p = dst;
//	assert(dst);
//	assert(src);
//	while(*dst++ = *src++)
//	{
//		;
//	}
//	return dst;
//}
//
//int main()
//{
//	char *cp = "abcde12345";
//	char arr[20];
//	printf("%s\n",cp);
//	my_strcpy(arr,cp);
//	printf("%s\n",arr);;
//	return 0;
//}


////模擬strcat(字符串拼接)
//#include<assert.h>
//char *my_strcat(char *dst, const char *src)
//{
//	char *p = dst;
//	assert(dst);
//	assert(src);
//	while(*dst)    //while(*dst++)  錯誤的  //while((*dst)++)  錯誤的
//	{
//		dst++;
//	}
//	while(*dst++ = *src++)
//	{
//		;
//	}
//	return p;
//}
//
//int main()
//{	
//	char arr[20] = "abcde";
//	char *cp = "456789";
//	printf("%s\n",arr);
//	my_strcat(arr,cp);
//	printf("%s\n",arr);
//	return 0;
//}


////模擬strstr(判斷字符串1是不是字符串2的子串)
#include<assert.h>
#include<string.h>
////char *my_strstr(const char *dst,const char *src)
////{	
////	const char *end = dst + strlen(dst) - strlen(src) + 1;  //優化的地方
////	const char *d = dst;
////	assert(dst);
////	assert(src);
////	while(d < end)
////	{
////		const char *p = d;    
////		const char *s = src;
////		while(*s)
////		{
////			if(*p == *s)
////			{
////				p++;
////				s++;
////			}
////			else
////			{
////				break;
////			}
////		}
////		if(*s == '\0')
////		{
////			return d;
////		}
////		d++;
////	}
////}

//#include<assert.h>
//char *my_strstr(const char *dst, const char *src)
//{
//	const char *d = dst; 
//	assert(dst);
//	assert(src);
//	while(d)
//	{
//		const char *p = d;
//		const char *s = src;
//		while((*p != '\0') && (*s != '\0') && (*p == *s))
//		{
//			s++;
//			p++;
//		}
//		if(*s == '\0')
//		{
//			return d;
//		}
//		d++;
//	}
//}
//
//int main()
//{
//	char *s = "abcdefg";
//	char *p = "cdef";
//	//char *ch = "higk";
//	char * ret = my_strstr(s,p);
//	//char * ret = my_strstr(s,ch);
//	printf("%s\n",ret);
//	return 0;
//}



//模擬實現strchr 

//#include<assert.h>
//char *my_strchr(const char *dst, char c)
//{
//	assert(dst);
//	while((*dst != c) && (*dst != '\0'))
//	{
//		dst++;
//	}
//	return *dst == c ? dst:NULL;
//}
//
//int main()
//{
//	char *s = "abcdef";
//	char c = 'g';
//	char *ret = my_strchr(s, c);
//	printf("%s\n",ret);
//	return 0;
//}


////模擬實現strcmp

//#include<assert.h>
//int my_strcmp(const char *dst, const char *src)
//{
//	assert(dst);
//	assert(src);
//	while(*dst != '\0' && *src != '\0')
//	{
//		if(*dst == *src)
//		{
//			dst++;
//			src++;
//		}
//		else if(*dst > *src)
//		{
//			return 1;
//		}
//		else
//		{
//			return -1;
//		}
//	}
//	if(*dst != '\0')
//	{
//		return 1;
//	}
//	if(*src != '\0')
//	{
//		return -1;
//	}
//	return 0;
//}

//#include<assert.h>
//int my_strcmp(const char *dst, const char *src)
//{	
//	int ret = 0;
//	assert(dst);
//	assert(src);
//	while(!(ret = *(unsigned char *)dst - *(unsigned char *)src) && *src)
//	{
//		dst++;
//		src++;
//	}
//	if(ret > 0)
//	{
//		ret = 1;
//
//	}
//	else
//	{
//		return -1;
//	}
//	return ret;
//}
//
//int main()
//{
//	char *ch = "abcde";
//	char *cp = "abcdef";
//	int ret = my_strcmp(ch,cp);
//	printf("%d\n",ret);
//	return 0;
//}


////模擬實現memcpy

//#include<string.h>
//#include<assert.h>
//char *my_memcpy(void *dst, const void *src, int count)
//{
//	char *d = dst;
//	const char *s = src;
//	assert(dst);
//	assert(src);
//	while(count--)
//	{
//		*d = *s;
//		++d;
//		++s;
//	}
//	return dst;
//}
//
//int main()
//{
//	char p[] = "abcdef";
//	char arr[10];
//
//	//printf("%d\n",strlen(s));
//	my_memcpy(arr,p,sizeof(p));
//	printf("%s\n",arr);
//	return 0;
//}


////模擬實現memmove

//#include<assert.h>
//#include<string.h>
//void *my_memmove(void *dst, const void *src, int count)
//{
//	char *d = dst;
//	const char *s = src;
//	assert(dst);
//	assert(src);
	//////
	//if(s < d && s+count >d)
	//{
	//	d = d + count -1;
	//	s = s + count -1;
	//	while(count--)
	//	{
	//		*d = *s;
	//		--d;
	//		--s;
	//	}
	//}
	//else
	//{
	//	while(count--)
	//	{
	//		*d = *s;
	//		++d;
	//		++s;
	//	}
	//}

    ////
//	if(d <= s || s+count <= d)       //錯誤的 if(d <= s && s+count <= d)
//	{
//		while(count--)
//		{
//			*d = *s;
//			++d;
//			++s;
//		}
//	}
//	else
//	{
//		d = d + count -1;
//		s = s + count -1;
//		while(count--)
//		{
//			*d = *s;
//			d--;
//			s--;
//			/*--s;
//			--d;*/
//		}
//	}
//
//	return dst;
//}
// 
//int main()
//{	
//	char ch[64]= "abcdefghijk";
//	my_memmove(ch,ch+1,strlen(ch));
//	printf("%s\n",ch); 
//	return 0;
//}


#define _CRT_SECURE_NO_WARNINGS 1

///作業20
//int *p; --> 指針
//int arr[5]; --> 數組
//int *p[5]; --> 指針數組
//int (*p)[5]; --> 數組指針
//int *((*p)[5]); --> 指針數組的指針
//int *((*p)[10])[5]; --> 指針數組指針的數組
//int (*p[10])[5]; --> 數組指針數組
//int *(*p[5])[5]; --> 數組指針數組的指針
//
//
//int test() --> 函數的聲明
//int *ptest() -->指針函數     //是否存在？ 不存在
//viod *ptest() -->函數指針
//int (*ptest)() --> 函數指針 
//
//(void (*)() 函數指針 --> void(*)()0 將0強轉爲函數指針 -->
//(void(*)()0) 對0這個函數指針解引用 --> (*(void(*)()0)() -->
//調用函數，這個函數爲:無返回類型參數爲空的函數
//
//void(*signal(int,void(*)(int)))(int);
//
//typedef void(*pfun_t)(int); -->定義了一個 函數指針類型
//返回值爲void 參數爲int 的函數指針類型
//
//pfun_t signal(int, pfun_t) --> 返回值爲 函數指針 參數爲 int和函數指針 的函數聲明
//
//int (*p[5])() -->函數指針數組
//int *p[5]() --> 不存在這樣的東西
//int (*)()p[5] -->錯誤的,語法錯誤
//
//int ((*p)[5])() -->數組指針函數
//int (*(*p)[5])() -->函數指針數組指針
//int (*(*p[10])[5])() -->函數指針數組指針的數組


#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>

////函數指針數組的用法（轉移表） 計算器

//int add(int x, int y)
//{
//	return x+y;
//}
//
//int sub(int x, int y)
//{
//	return x-y;
//}
//
//int mul(int x, int y)
//{
//	return x*y;
//}
//
//int div(int x, int y)
//{
//	return x/y;
//}
//
//
//int main()
//{
//	int input = 1;  //初值不能爲零
//	int x = 0;
//	int y = 0;
//	int ret = 0;
//	int (*p[5])(int x, int y) = {0,add,sub,mul,div};  //轉移表
//	while(input)
//	{
//		printf("*************************\n");
//		printf("***1.add         2.sub***\n");
//		printf("***3.mul         4.div***\n");
//		printf("*************************\n");
//		printf("請選擇: ");
//		scanf("%d",&input);
//		if((input>0) && (input<5))
//		{
//			printf("請輸入操作數  ");
//			scanf("%d%d",&x,&y);
//			ret = (*p[input])(x, y);
//		}
//		else
//		{
//			printf("選擇錯誤");
//			break;
//		}
//		printf("ret = %d\n",ret);
//		printf("\n");
//		printf("\n");
//		printf("\n");
//		printf("-------------------------\n");
//	}
//	return 0;
//}


////回調函數  
////模擬實現qsort（採用冒泡法）

//int int_cmp(const void *x, const void *y)
//{
//	int *a = (int *)x;
//	int *b = (int *)y;
//	return *a > *b ? 1 : *a < *b ? -1 : 0;
//}
//
//void swap(void *x, void *y,int size)
//{
//	char *a = (char *)x;
//	char *b = (char *)y;
//	while(size--)
//	{
//		*a ^= *b;
//		*b ^= *a;
//		*a ^= *b;
//		a++;    //不能少
//		b++;
//	}
//}
//
//void bubble(void *arr, int count, int size, int(*cmp)(void *x, void *y))
//{
//	int i = 0;
//	int j = 0;
//	int flag = 0;
//	for(i = 0;i<count-1;++i)
//	{
//		flag = 0;
//		for(j=0;j<count-1-i;++j)
//		{
//			if(cmp((char *)arr + j*size, (char *)arr + (j+1)*size) > 0)  //注意最後的>0
//			{
//				flag = 1;	
//				swap((char *)arr + j*size, (char *)arr + (j+1)*size, size);
//			}
//		}
//		if(0 == flag)
//		{
//			break;
//		}
//	}
//}
//
//void print_arr(int arr[10], int sz)
//{
//	int i = 0;
//	for(i=0;i<sz;++i)
//	{
//		printf("%d ",arr[i]);
//	}
//	printf("\n");
//}
//
//int main()
//{
//	int arr[] = {1,3,5,7,9,0,2,4,6,8};
//	int sz = sizeof(arr)/sizeof(arr[0]);
//	bubble(arr,sz,sizeof(arr[0]),int_cmp);
//	print_arr(arr, sz);
//	return 0;
//}


#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>

////模擬實現strncat

//#include<assert.h>
//#include<string.h>
//
//char *my_strncat(char *dst, const char *src, int num)
//{
//	char *ret = dst;
//	assert(dst);
//	assert(src);
//	while(*dst)
//	{
//		++dst;
//	}
//	while(num--)
//	{
//		*dst = * src;
//		dst++;
//		src++;
//	}
//	return ret;
//}
//
//int main()
//{
//	char arr[64] = "abcdefg";
//	char *ch = "hijklmn";
//	int sz = strlen(ch);
//	char *ret = my_strncat(arr,ch,sz);
//	printf("%s\n",ret);
//	return 0;
//}



////模擬實現strncpy

//#include<string.h>
//#include<assert.h>
//char *my_strncpy(char *dst, const char *src, int num)
//{
//	char *ret = dst;
//	assert(dst);
//	assert(src);
//	while(num--)
//	{
//		*dst = *src;
//		dst++;
//		src++;
//	}
//	return ret;
//}
//
//int main()
//{
//	char arr[64];
//	char *ch = "opqrstuvwxyz";
//	int sz = strlen(ch) + 1;        //需要手動加\0
//	char *ret = my_strncpy(arr,ch,sz);
//	printf("%s\n",ret);
//	return 0;
//}

////模擬實現strncmp

//#include<assert.h>
//int my_strncmp(const char *p, const char *q, int num)
//{
//	assert(p);
//	assert(q);
//	while(num--)
//	{
//		if(*p > *q)
//		{
//			return 1;
//		}
//		else if(*p < *q)
//		{
//			return -1;
//		}
//		else
//		{
//			p++;
//			q++;
//		}
//	}
//	return 0;
//}
//
//int main()
//{
//	char *ch = "abcde";
//	char *cp = "abcdef";
//	int ret = my_strncmp(ch,cp,6);
//	printf("%d\n",ret);
//	return 0;
//}

#define _CRT_SECURE_NO_WARNINGS 1

//#include<stdio.h>
////交換倆個整形變量的值
//int main()
//{
	////解法一
	//int a = 10;
	//int b = 20;
	//int c = 0;
	//c = a;
	//a = b;
	//b = c;

	//解法二
	//int a = 34;
	//int b = 26;
    //a = a+b;
	//b = a-b;
	//a = a-b;

	//解法三
	//int a = 97;
	//int b = 25;
	//a = a^b;
	//b = a^b;
	//a = a^b;
	//printf("%d,%d",a,b);
//return 0;
//}



////求10 個整數中最大值（可以改變數組的值）
//int main()
//{
//	int arr[] = {-6,-8,-4,-9,-2,-10,-7,2,-1,-5};
//	int max = arr[0];
//	int i = 0;
//	for(i=1;i<10;i++)
//	{
//		if(arr[i]>max)
//		{
//			max = arr[i];
//		}
//	}
//	printf("%d\n",max);
//return 0;
//}




////將三個數按從大到小輸出  或者 //用函數的方式
//void Swap(int *p1 , int *p2)
//{
//	int tmp =  *p1;
//	    *p1 =  *p2;
//	    *p2 =  tmp;
//}
//int main ()
//{
//	int a = 0;
//	int b = 0;
//	int c = 0;
//	int tmp = 0;
//  scanf("%d %d %d",&a,&b,&c);
//	
//	if(a<b)
//	{
//		Swap (&a,&b);
//		//tmp = a;
//		//a = b;              
//		//b = tmp;
//	}
//	if(a<c)
//	{
//		Swap (&a,&c); 
		//tmp = a;
		//a = c;
		//c = tmp;
//	}
//	if(b<c)
//	{
//		Swap (&b,&c);
//		//tmp = b;
//		//b = c;
//		//c = tmp;
//	}
//	printf("%d,%d,%d\n",a,b,c) ; //(規定了輸出a爲最大值)
//	return 0;
//}




////求2個數的最大公約數
//int main()
//{
//	int a = 0;
//	int b = 0;
//	scanf("%d%d",&a,&b);
//	while(a%b)   //或者while(a%b != 0)
//	{
//		int tmp = a%b;
//		a = b;
//		b = tmp;
//	}
//printf("%d\n",b);
//	return 0;
//}





////計算1/1-1/2+1/3-1/4+1/5 …… + 1/99 - 1/100 的值
//#include<math.h>
//int main()
//{
//	int i = 0;
//	double sum = 0.0;
//	double n = -1;
//	for(i=1;i<=100;i++)
//	{
//		  n = -1;	        //每次進入循環n都要初始化
//		  n = pow (n, (i+1));
//		  sum = sum + n * (1.0/i);
//	}
//	printf("%lf",sum);
//return 0;
//}


//int main()
//{
//	int i = 0;
//	double sum = 0.0;
//	int flag = -1;
//	for(i=1;i<=100;i++)
//	{
//		sum = sum+flag*1.0/i;
//		flag = -flag;
//	}
//	printf("%lf",sum);
//return 0;
//}







////	將數組A中的內容和數組B中的內容進行交換 
//int main ()
//{	
//	int arrA[] = {1,2,3,4,5,6,7,8,9,10};
//	int arrB[] = {-1,-2,-3,-4,-5,-6,-7,-8,-9,-10};
//	int tmp = 0;
//	int i = 0;
//    //int sz = sizeof(arrA)/sizeof(arrA[0]);
//	
//	//交換兩個數組的內容
//	for(i=0;i<10;i++)     //for(i=0;i<sz;i++)
//	{
//		tmp = arrA[i];
//		arrA[i] = arrB[i];
//		arrB[i] = tmp;
//	}
//
//	//打印第一個數組
//    for(i=0;i<10;i++)    //for(i=0;i<sz;i++)
//	{
//		printf("%d\n",arrA[i]);
//	}
//
//	//換行
//	printf("\n");
//
//	//打印第二個數組
//	for(i=0;i<10;i++)      //for(i=0;i<sz;i++)
//	{
//		printf("%d\n",arrB[i]);
//	}	
//	return 0;
//}





////數一下 1到 100 的所有整數中出現多少次數字9

//int main()
//{
//	int i = 0;
//	int count = 0;
//	for(i=1;i<=100;i++)
//	{
//		//個位上9的個數
//		if(i%10==9)
//		{
//			count++;
//		}
//
//		//十位上9的個數
//		if(i/10==9)
//		{
//			count++;
//		}
//	}
//	printf("%d\n",count);
//return 0;
//}





////在屏幕上輸出以下圖案：
////      *
////     ***
////    *****
////   *******
////  *********
//// ***********
////*************
//// ***********
////  *********
////   *******
////    *****
////     ***
////      *

//int main()
//{
//	int i = 0;
//	int line = 0;
//	int j = 0;
//	scanf("%d",&line);
//
//	//先打印上半部分
//	for(i=0;i<line;i++)
//	{
//		//先打印空格
//		for(j=0;j<line-1-i;j++)  //（難點）
//		{
//			printf(" ");// 或者 printf("%c",' ');
//		}
//		//打印*
//		for(j=0;j<2*i+1;j++)  //（難點）
//		{
//			printf("*");
//		}
//		printf("\n");
//	}
//	
//	
//	//打印下半部分
//	for(i=0;i<line-1;i++)
//	{
//		//先打印空格
//		for(j=0;j<=i;j++)   //（難點）
//		{
//			printf(" ");
//		}
//		//打印*
//		for(j=0;j<(line-1-i)*2-1;j++)  //(難點)
//		{
//			printf("*");
//		}
//		printf("\n");
//	}
//return 0;
//}



////打印水仙花數
//#include<math.h>
//int main()
//{
//	int i = 0;
//	int bit = 1;
//	for(i=0;i<1000;i++)
//	{
//		//計算是幾位數
//	    //scanf("%d",&i);
//		int tmp = i;
//		int sum = 0;
//		bit = 1;      ////這一句很重要（每一個數進來要將bit置1） 
//		while(tmp/10)
//		{
//			bit++;
//			tmp = tmp/10;
//	     }
//         //printf("%d",bit);
//		////取下每一位
//		 tmp = i;
//	     while(tmp)   //不能是(tmp%10),會將370 ，407 這樣有零的數字丟失
//		 {
//			sum = sum + pow(tmp%10,bit);
//			tmp = tmp /10;
//		 }
//		 if(sum == i)
//		 {
//			printf(" %d ", i );
//		 }
//
//     }
//	return 0;
//}



////求Sn=a+aa+aaa+aaaa+aaaaa的前5項之和
//int main()
//{
//	
//	int i = 0;
//	int a = 0;
//	int sn = 0;
//	int ret = 0;
//	int tmp = 0;
//
//	scanf("%d%d",&a,&tmp);
//	for(i=0;i<tmp;i++)
//	{	
//		ret = ret*10+a;
//		sn = sn+ret;
//	}
//printf("%d",sn);
//return 0;
//}


////編寫程序從標準輸入讀取C源代碼，並驗證所有的花括號都正確的成對出現

//int main()
//{
//	char ch = 0;
//	int count = 0;
//	
//	while((ch=getchar()) != EOF)
//	{
//		//putchar(ch);
//		if(ch == '{')
//		{
//			count++;
//		}
//		else if((ch == '}') && (0==count))
//		{
//			printf("不匹配\n");
//			return 0;
//		}
//		else if((ch == '}') && (count != 0))
//		{
//			count--;
//		}
//	}
//	if (0 == count)
//	{
//		printf("匹配\n");
//	}
//	else
//	{
//		printf("不匹配\n");
//	}
//
//return 0;
//}


////編寫一個程序，可以一直接收鍵盤字符，
////如果是小寫字符就輸出對應的大寫字符，
////如果接收的是大寫字符，就輸出對應的小寫字符，
////如果是數字不輸出
//#include<ctype.h>
//int main()
//{
//	int ch = 0;
//	while((ch = getchar()) != EOF)
//	{
//		if((ch>='a')&&(ch<='z'))
//		{
//			putchar(toupper(ch));
//			//putchar(ch-32);
//			//putchar(ch-('a'-'A'));
//		}
//		else if((ch>='A')&&(ch<='Z'))
//		{
//			putchar(tolower(ch));
//			//putchar(ch+32);
//			//putchar(ch+'a'-'A');
//		}
//	}
//return 0;
//}


#define _CRT_SECURE_NO_WARNINGS 1
//#include<stdio.h>
//int main()
//{
//	//printf("file:%s line:%d\n",__FILE__,__LINE__);
//	printf("date:%d time:%d",__DATE__,__TIME__);
//	return 0;
//}

//int main()
//{
//	int i = 0;
//	int arr[10] = {0};
//		
//	for(i=0;i<=12;i++)
//	{
//		arr[i] = i;
//		printf("hehe\n");
//	}
//	return 0;
//}

////使用宏實現兩個數中求較大值

//#define MAX(a,b) (a)>(b)?(a):(b)
//
//int main()
//{
//	int max = MAX(3,4);
//	printf("max = %d",max);
//	return 0;
//}



////寫一個宏可以將一個數字的奇數位和偶數位交換

//#define SWAP(a,b,c)  (c = a) ; (a = b); (b = c)
//int main()
//{
//	int i = 0;
//	int a = 0;
//	int j = 0;
//	int m = 0;
//	int n = 0;
//	int tmp = 0;
//	scanf("%d",&a);
//	for(i=31;i>=0;i-=2)
//	{
//		j = i;
//		m = (a>>j)&1;
//		n = (a>>(j-1))&1;
//		//tmp = m;
//		//m = n;
//		//n = tmp;
//		SWAP(m,n,tmp);      //(() = ();() = ();()=());
//		printf("%d%d",m,n);
//	}
//	return 0;
//}




////計算奇數的個數
//int Detr(int arr[],int sz)
//{
//        int i = 0;
//        int count = 0;
//        for(i=0;i<sz;i++)
//        {
//                if(arr[i]%2 != 0)
//                count++;
//        }
//        return count;
//}
//
//
////將一個數組的內容轉移到另一個數組
//void MoveOne(int arr[], int i)
//{
//        int left = 0;
//        arr[left] = i;
//        left++;
//}
//
//
//void MoveTwo(int arr[],int arrx[],int left )
//{
//        arr [left] = arrx[left];
//        left++;
//
//}
//
//
//
//
//void  Trp(int arr[],int sz, int count)
//{
//        int i = 0;
//        int left = 0;
//        int arr1[10] = {0};
//        int arr2[10] = {0};
//        for(i=0;i<sz;i++)
//        {
//                if(arr[i]%2 != 0)
//                {
//                        MoveOne(arr1,arr[i]);
//                }
//                else
//                {
//                        MoveOne(arr2,arr[i]);
//                }
//        }
//        for(i=0;i<count;i++)
//        {
//                MoveTwo(arr,arr1,left);
//        }
//        left = count;
//        for(i=count;i<sz;i++)
//        {
//                MoveTwo(arr,arr2,left);
//        }
//        for(i=0;i<sz;i++)
//        {
//                printf("% d",arr[i]);
//        }
//        printf("\n");
//}
//
//
//
//
//int main()
//
//{
//        int arr[] = {1,2,3,4,5,6,7,8,9,10};
//        int sz = sizeof(arr)/sizeof(arr[0])-1;
//		int i = Detr(arr,sz);
//        Trp(arr,sz,i);
//        return 0;
//}






//void Rearch(int arr[3][3],int i,int j,int key)
//{
//	int m = 0;
//	int n = 0;
//
//	for(m=0;m<i;m++)
//	{
//		for(n=0;n<j;n++)
//		{
//			 if(arr[i][j] == key)
//			 {
//				printf("找到了\n");
//				break;
//			 }
//
//		}
//	}
//	if((m>2)&&(n>2))
//	{
//		printf("找不到\n");
//	}
//}
//
//int main()
//{
//	int arr[3][3] = {{1,2,3},{2,3,4},{3,4,5}};
//	//int i = 0;
//	//int j = 0;
//	//for(i=0;i<3;i++)
//	//{
//	//	for(j=0;j<3;j++)
//	//	{
//	//		printf("%d",arr[i][j]);
//	//	}
//	//	printf("\n");
//	//}
//	int key = 6;
//    Rearch(arr,3,3,key);
//	return 0;
//}
//     
//#include<string.h>
//int main()
//{
//        char arr[] = "abcdef";
//        //int sz = sizeof(arr)/sizeof(arr[0])-1;
//        //Levo();
//		//int sz = strlen(arr);
//		
//        printf("%d\n",arr);
//
//
//        return 0;
//}
  

//int main()
//{
//	int i = 0;
//	int arr[10] = {0};
//	for(i=0;i<=12;i++)
//	{
//		arr[i] = 0;
//		printf("hehe\n");
//	}
//	return 0;
//}



//int main()
//{	
//	main();
//	return 0;
//}


////接受一個整型值（無符號），把它轉換爲字符並打印它
////例如  輸入1234  輸出1 2 3 4
 
//void Print(int num)
//{
//	if(num>9)
//	{
//		Print(num/10);
//	}
//	printf("%d ",num%10);
//	//return  num%10 ;  不能用return  無輸出
//}
//
//int main() 
//{
//	int num = 1234;
//	Print(num);
//	return 0;
//}


////編寫函數不允許創建臨時變量，求字符串長度
//#include<assert.h>
//int my_strlen(const char *str)
//{
//	//int count = 0;
//
//	assert(str != NULL);
//
//	//while(*str != '\0')
//	//{
//	//	count++;
//	//	*str++;
//	//}
//
// 
//	if(*str != '\0')						
//	{	
//										 //str++;
//		return 1+my_strlen(str+1);       //return 1+my_strlen(str);
//	}	
//	else
//		return 0;
//	
//	//return count;
//}
//
//
//int main()
//{
//	char *ch = "abcdefghijklmn";     //不能寫成char ch = "abcdef";
//	int ret = my_strlen(ch);
//	printf("%d\n",ret);
//	return 0;
//}


//////求n的階乘
//
//int Fun(int n)
//{
//	if(n<=1)        //0的階乘是1
//	{
//		return 1;
//	}
//	else 
//	{
//		return n*Fun(n-1);
//	}
//}
//
//int main()
//{	
//	int n = 0;
//	int ret = 0;
//	scanf("%d",&n);
//	ret= Fun(n);
//	printf("%d",ret);
//	return 0;
//}




////求第n個斐波那契數（不考慮溢出）
////1 1 2 3 5 8 13 21 34 55 89 ......
////循環方式
//int Fbc(int n)
//{
//	
//	int a = 1;
//	int b = 1;
//	int c = 1;
//	while(n>2)
//	{	
//		n = n-1;
//		c = a+b;
//		a = b;
//		b = c;
//	
//	}
//	return c;
//}


////遞歸的方式
//Fbc(int n)
//{
//	
//	if(n<=2)
//		return 1;
//	else
//		return Fbc(n-1)+Fbc(n-2);
//	
//}



//int main()
//{
//	int ret = 0;
//	int n = 0;
//	scanf("%d",&n);
//	ret = Fbc(n);
//	printf("%d",ret);
//	return 0;
//}



//int main(int argc, char*argv[], char*envp[])
//{
//	int i = 0;
//	for(i=0;i<argc;i++)
//	{
//		printf("%s\n",argv[i]);
//		i++;
//	}
//	return 0;
//}

////計算器
//#include<stdlib.h>
//int Add(int x, int y)
//{
//	return x+y;
//}
//
//int Sub(int x, int y)
//{
//	return x-y;
//}
//
//int Mul(int x, int y)
//{
//	return x*y;
//}
//
//int Div(int x, int y)
//{
//	return x/y;
//}
//
//int main(int argc, char*argv[], char*envp[])
//{
//	int x = 0;
//	int y = 0;
//	int ret = 0;
//	if(argc != 4)
//	{
//		printf("參數有誤\n");
//		return 1;
//	}
//	x = atoi(argv[2]);
//	y = atoi(argv[3]);
//	switch(*(argv[1]+1))
//	{
//		case'a':
//			ret = Add(x, y);
//			break;
//		case's':
//			ret = Sub(x, y);
//			break;
//		case'm':
//			ret = Mul(x, y);
//			break;
//		case'd':
//			ret = Div(x, y);
//			break;
//	}
//	printf("ret = %d",ret);
//	return 0;
//}


////作業15

////使用可變參數，實現函數，求函數參數的平均值
//#include<stdarg.h>
//int avervge(int n,...)
//{	
//	int i = 0;
//	int sum = 0;
//	va_list arg;  ///是宏 不是函數 

//	// typedef char * va_list;

//	va_start(arg,n);

//	//#define va_start  _crt_va_start
//	//#define _crt_va_start(ap,v)  ( ap = (va_list)_ADDRESSOF(v) + _INTSIZEOF(v) )
//	//  (arg = (char *) &(n))+(向上取整（1-4，取4；5-8，取8）)
//
//	for(i=0;i<n;i++)
//	{
//		sum += va_arg(arg,int);

//		//#define va_arg  _crt_va_arg
//		//#define _crt_va_arg(ap,t)    ( *(*)((ap += _INTSIZEOF(t)) - _INTSIZEOF(t)) )
//		// sum +=  (*(*)((arg += 4) - 4))

//	}
//	va_end(arg);

//	//#define _crt_va_end(ap)      ( ap = (va_list)0 

//	return sum/n;
//}
//
//int main()
//{
//	int n = 7;
//	int ret = avervge(7,1,2,3,4,5,6,28);
//	printf("ret = %d\n",ret);
//	return 0;
//}



////使用可變參數，實現函數，求函數參數的最大值

//int Max(int n,...)
//{
//	int i = 0;
//	int max = 0;
//	max = *(&(n)+1);
//	
//	for(i=0;i<(n-1);i++)
//	{
//		if( max > (*(&(n)+2+i)) )  ////這裏很容易出錯，注意書寫
//		{
//			max = max;
//		}
//		else
//		{
//			max = *(&(n)+2+i);     ////這裏很容易出錯，注意書寫
//		}
//	}
//	
//	return max;
//}
//
//
//int main()
//{
//	int max = 0;
//	max = Max(5,7,25,5,3,36);
//	printf("max = %d\n",max);
//	return 0;
//}



////求任意個數的平均值

//int average(int n,...)
//{
//	int i = 0;
//	int sum = 0;
//	for(i=0;i<n;i++)
//	{
//		sum += *(&(n)+1+i);	
//	}
//	return sum/n;
//}
//
//
//int main()
//{
//	int ret = 0;
//	ret = average(6,9,6,6,12,7,2);
//	printf("ret = %d\n",ret);
//	return 0;
//}


////模擬實現printf函數，可完成下面的功能 
 
////能完成下面函數的調用。 
////printf("s% c%c%c% d%\n","hello",'b','i','t'，100); 
////函數原型： 
////printf(char *format, ...) 

//Print(const char *format,...)
//{
//	putchar(format++);
//
//	
//
//}
//
//int main()
//{
//	char ch = "hello";
//	char arr[] = {'b','i','t'};
//	int a = 100;
//	Print(((char*)&(ch)),((char*)&(arr)),((char*)&(a)));
//	return 0;
//}


//#define M 100
//int main()
//{
////#if !defined(M)
////	printf("M\n");
////#endif
//
////#ifndef M 
////	printf("M\n");
////#endif
//
////#if defined(M)
////	printf("M\n");
////#endif
//
////#ifdef M
////	printf("M\n");
////#endif
//
//	return 0;
//}

//int main()
//{
//	int a = 0x11223344;
//	return 0;
//}


////寫一個函數判斷計算機是小端還是大端存儲

//int check_sys()
//{
//	int i = 1;
//  return (*(char*)&(i)); //返回1爲小端返回0爲大端
//}


////用共用體的做法
//int check_sys()
//{
//	union Un
//	{
//		char a;
//		int i;
//	}u;
//	u.i = 1;
//	return u.a;
//}
//
//
//int main()
//{
//	int ret = check_sys();
//	if(1 == ret)
//		printf("小端\n");
//	else
//		printf("大端\n");
//	return 0;
//}



////編寫一個函數實現n^k，使用遞歸實現 
////n^k = n*n^k-1
//int second_party(int n ,int k)
//{	
//	 if(k>0)
//	 {
//        return second_party(n,k-1)*n;
//	 }
//	 else
//	 {
//		return 1;
//	 }
//}
//
//int main()
//{
//        int n = 0;
//        int k = 0;
//        int ret = 0;
//        scanf("%d %d",&n,&k);
//        ret = second_party(n,k);
//        printf("n的k次方是:%d\n",ret);
//        return 0;
//}



////寫一個遞歸函數DigitSum(n)，輸入一個非負整數，返回組成它的數字之和，例如，調用DigitSum(1729)，則應該返回1+7+2+9，它的和是19 

//int dig_itsum(int n)
//{
//        while(n/10)  //if((n/10)>0)
//        {
//                return n%10 + dig_itsum(n/10);
//        }	
//}
//
//int main()
//{
//        int n = 0;
//        int ret = 0;
//        scanf("%d",&n);
//        ret = dig_itsum(n);
//        printf("ret = %d\n",ret);
//        return 0;
//}

//#include<assert.h>
//int my_strlen(const char *p)
//{
//        int count = 0;
//		assert(p != NULL);
//        while(*p != '\0')
//        {
//                count++;
//                *p++;
//        }
//        return count;
//}
//
//int main()
//{
//        char *ch = "abcdefg";
//        int i = 0;
//        i = my_strlen(ch);
//        printf("%d\n",i);
//        return 0;
//}


//#include<assert.h>
//int my_strlen(char *p)
//{
//        assert(p != NULL);
//        if(*p != '\0')
//        {
//                return 1 + my_strlen(p+1);// 錯誤的寫法 (*p+1)
//        }
//        else
//        {
//                return 0;
//        }
//}
//
//int main()
//{
//        char *ch = "abcdefgh";
//        int i = 0;
//        i = my_strlen(ch);
//        printf("%d\n",i);
//}



//void Fun(int num)
//{
//        if(num >9)
//        {
//				Fun(num/10);
//		}
//		printf("%d ",num%10);
//}       
//
//int main()
//{
//        int num = 0;
//        scanf("%d",&num);
//        Fun(num);
//        return 0;
//}




////作業 15 遞歸
//#include<stdio.h>

////遞歸和非遞歸分別實現求第n個斐波那契數

////遞歸的方法
/*int Fib(int n)
{
        if(n<=2)
        {
                return 1;
        }
        else
        {
                return Fib(n-1)+Fib(n-2);
        }       
}

int main()
{
        int n = 0;
        int ret = 0;
        scanf("%d",&n);
        ret = Fib(n);
        printf("ret = %d\n",ret);
        return 0;
}*/


//// 循環的方法

/*int Fib(int n)
{
        int a = 1;
        int b = 1;
        int c = 1;
        while(n>2)
        {
                c = a+b;
                a = b;
                b = c;
                n--;
        }
        return c;
}


int main()
{
        int n = 0;
        int ret = 0;
        scanf("%d",&n);
        ret = Fib(n);
        printf("ret = %d\n",ret);
        return 0;
}*/

////編寫一個函數實現n^k，使用遞歸實現 

////n^k = n*n^k-1
/*int second_party(int n ,int k)
{
        if(k>0)
        {
                return second_party(n,k-1)*n;
        }
        else
        {
                return 1;
        }

}

int main()
{
        int n = 0;
        int k = 0;
        int ret = 0;
        scanf("%d %d",&n,&k);
        ret = second_party(n,k);
        printf("n的k次方是:%d\n",ret);
        return 0;
}*/



////寫一個遞歸函數DigitSum(n)，輸入一個非負整數，返回組成它的數字之和，例如，調用DigitSum(1729)，則應該返回1+7+2+9，它的和是19 

/*int dig_itsum(int n)
{
        if((n/10)>0)
        {
                return n%10 + dig_itsum(n/10);  
        }
        
}

int main()
{       
        int n = 0;
        int ret = 0;
        scanf("%d",&n);
        ret = dig_itsum(n);
        printf("ret = %d\n",ret);
        return 0;
}*/



////遞歸和非遞歸分別實現strlen 

////非遞歸
/*#include<assert.h>
int my_strlen(char *p)
{
        int count = 0;
        assert(p != NULL);
        while(*p != '\0')
        {
                count++;
                *p++;   
        }
        return count;
}

int main()
{
        char *ch = "abcdefg";  // 錯誤的寫法char = "abcdef";
        int i = 0;
        i = my_strlen(ch);
        printf("%d\n",i);
        return 0;
}*/

////遞歸

/*#include<assert.h>
int my_strlen(char *p)
{
        assert(p != NULL);
        if(*p != '\0')
        {
                return 1 + my_strlen(p+1);//錯誤的寫法(*p+1)
        }
        else
        {
                return 0;
        }
}

int main()
{
        char *ch = "abcdefgh";
        int i = 0;
        i = my_strlen(ch);
        printf("%d\n",i);
}*/


////遞歸和非遞歸分別實現求n的階乘 

////非遞歸 

/*int Fun(int n)
{
        int i = 0;
        int ret = 1;
        for(i = 1;i<=n;i++)
        {
                ret = ret * i;
        }
        return ret;
}       
int main()
{       
        int n = 0;
        int ret = 0;
        scanf("%d",&n);
        ret = Fun(n);
        printf("%d\n",ret);
        return 0;
}*/

////遞歸

/*int Fun(int n)
{
        if(n<2)
        {       
                return 1;
        }
        else
        {
                return n * Fun(n-1);
        }
}

int main()
{       
        int n = 0;
        int ret = 0;
        scanf("%d",&n);
        ret = Fun(n);
        printf("%d\n",ret);
        return 0;
}*/


////遞歸方式實現打印一個整數的每一位 

/*void Fun(int num)
{
        if(num >9)
        {
                Fun(num/10);   // printf()不能寫到 if語句的裏面
        }       
        printf("%d ",num%10);
        
}

int main()
{       
        int num = 0;
        scanf("%d",&num);
        Fun(num);
        return 0;
}*/



////編寫一個函數reverse_string(char * string)（遞歸實現） 
////實現：將參數字符串中的字符反向排列。 
////要求：不能使用C函數庫中的字符串操作函數。 
//#include<assert.h>
//void reverse_string(const char *p)
//{
//        assert(p != NULL);
//        if(*p != '\0')
//        {
//                reverse_string(p+1);
//        }
//        printf("%c ",*p);
//}
//
//int main()
//{
//        char *ch = "abcdef";
//        reverse_string(ch);
//        return 0;
//}





////作業17

////一個數組中只有兩個數字是出現一次，其他所有數字都出現了兩次。 
////找出這兩個數字，編程實現。 

//int Find(int sz, int arr[])
//{	
//	int i = 0;
//	int ret = 0;
//	for(i=0;i++;i<sz)
//	{
//		ret = arr[i] ^ ret;
//	}
//
//	return ret;
//}
//
//int main()
//{
//	int arr[] = {1,1,2,2,3,3,4,4,5};
//	int sz = sizeof(arr)/sizeof(arr[0]);
//	int ret = Find(sz,arr);
//	printf("%d\n",ret);
//	//printf("%d\n",sz);
//	return 0;
//}


////喝汽水，1瓶汽水1元，2個空瓶可以換一瓶汽水，給20元，可以多少汽水。編程實現

//int Exchange(int money)
//{
//	int bottle = 0;
//	int water = 0;
//	bottle = money;
//	water = money;
//	while(bottle>1)
//	{
//		water = water + bottle/2;
//		bottle = bottle/2+bottle%2;		
//	}
//	return water;
//	//return money*2-1;
//}
//int main()
//{
//	int i = 0;
//	int ret = 0;
//	scanf("%d",&i);
//	ret = Exchange(i);
//	printf("%d\n",ret);
//	return 0;
//}


////模擬實現strcpy 

//#include<assert.h>

//char *my_strcpy(char *dst, const char *src)
//{	
//	char *ret = dst;
//	assert(dst != NULL);
//	assert(src != NULL);
// 
//	while(*src != '\0')
//	{
//		*dst = *src;
//		dst++;
//		src++;
//	}
//	return ret;
//}

//char *my_strcpy(char *dst, const char *src)
//{
//	char *ret = dst;
//	assert(dst != NULL);
//	assert(src != NULL);
//	
//	while(*dst++ = *src++)
//	{
//		;
//	}
//	return ret;
//}
//
//int main()
//{
//	char *ch = "abcdef";
//	char buf[10] = {0};
//	char *ret = my_strcpy(buf,ch);
//	printf("buf:%s\n",buf);
//	return 0;
//}


////模擬實現strcat

//#include<assert.h>
//
//char *my_strcat(char *dst,const char *src)
//{
//	char *ret = dst; 
//	assert(dst != NULL);
//	assert(src != NULL);
//	while(*dst)
//	{
//		dst++;
//	}
//	while(*dst++ = *src++)
//	{
//		;
//	}
//	return ret;
//}
//
//int main()
//{
//	char arr1[20] = "abcd";          //定義的數組大小要大於鏈接後的大小
//	char arr2[] = "aefgh";
//	//char *ret = my_strcat(arr1,arr2);  
//	my_strcat(arr1,arr2);
//	printf("連接後的結果：%s\n",arr1);
//	return 0;
//}

#define _CRT_SECURE_NO_WARNINGS 1
//#include<stdio.h>

////計算器
//#include<stdlib.h>
//int Add(int x, int y)
//{
//	return x+y;
//}
//
//int Sub(int x, int y)
//{
//	return x-y;
//}
//
//int Mul(int x, int y)
//{
//	return x*y;
//}
//
//int Div(int x, int y)
//{
//	return x/y;
//}
//
//int main(int argc, char*argv[], char*envp[])
//{
//	int x = 0;
//	int y = 0;
//	int ret = 0;
//	if(argc != 4)
//	{
//		printf("參數有誤\n");
//		return 1;
//	}
//	x = atoi(argv[2]);
//	y = atoi(argv[3]);
//	switch(*(argv[1]+1))
//	{
//		case'a':
//			ret = Add(x, y);
//			break;
//		case's':
//			ret = Sub(x, y);
//			break;
//		case'm':
//			ret = Mul(x, y);
//			break;
//		case'd':
//			ret = Div(x, y);
//			break;
//	}
//	printf("ret = %d\n",ret);
//	return 0;
//}


////冒泡排序可以排序字符串

//#include<assert.h>
//void Swap(char *x,char *y)
//{
//	assert(x);
//	assert(y);
//	*x ^= *y;
//	*y ^= *x;
//	*x ^= *y;
//} 
//
////數組下標索引的方式
//void bubble_sort(char arr[],int len)
//{
//	int i = 0;
//	int j = 0;
//	for(i=0;i<len-1;i++)
//	{
//		int flag = 0;             //
//		for(j=0;j<len-1-i;j++)
//		{
//			
//			if(arr[j]>arr[j+1])
//			{
//				flag = 1;
//				Swap(&arr[j],&arr[j+1]);
//				
//			}
//		}
//		if(0 == flag)       //
//		{
//			break;
//		}
//	}
//}
////
////////指針的方式1
//////void bubble_sort(char *arr, int len)
//////{
//////	char *start = arr;
//////	char *end = (arr+len-1);
//////	assert(arr);
//////	while(end > arr)     
//////	{
//////		int flag = 0;
//////		for(start = arr; start < end; start++)
//////		{
//////			
//////			if(*start > *(start+1))
//////			{
//////				Swap(start,(start+1));   //傳的本身就是地址
//////				flag = 1;
//////			}
//////			
//////		}
////			if(!flag)
//////		{
//////			break;
//////		}
//////		end--;  // 不能忘記
//////	}
//////}
////
////////指針的方式2
////void bubble_sort(char *arr,int len)
////{
////	char *start = arr;
////	char *end = arr+len-1;
////	for(end =(arr+len-1);end > arr;end--)
////	{
////		int flag = 0;
////		for(start = arr;start < end;start++)
////		{
////			
////			if(*start >*(start+1))
////			{
////				Swap(start,start+1);//傳的本身就是地址
////				flag = !flag;
////			}
////			
////		}
////		if(0 == flag)
////		{
////			break;
////		}
////	}
////
////}
////
//void Show(char arr[],int len)
//{
//	int i = 0;
//	for(i=0;i<len;i++)
//	{
//		printf("%c ",arr[i]);
//	}
//	printf("\n");
//}
//
//#include<string.h>
//int main()
//{
//	char arr[] = "kjhadsbc";
//	//printf("%d\n",strlen(ch));
//	int len = 0;
//	len = sizeof(arr)/sizeof(arr[0])-1;
//	//len = strlen(arr);
//	Show(arr,len);
//	bubble_sort(arr,len);
//	Show(arr,len);
//	return 0;
//}



//int main()
//{
//	int count = 0;
//	char ch = 0;
//	while((ch = getchar()) != EOF)
//	{
//		if(ch == '{')
//			count++;
//		else if((ch == '}') && (count == 0))
//		{
//			printf("不匹配\n");
//			return 0;
//		}
//		else if(ch == '}')
//			count--;
//	}
//	if(count == 0)
//		printf("匹配\n");
//	else
//		printf("不匹配\n");
//	return 0;
//}







//楊氏矩陣 
//有一個二維數組. 
//數組的每行從左到右是遞增的，每列從上到下是遞增的. 
//在這樣的數組中查找一個數字是否存在。 
//時間複雜度小於O(N); 
//
//數組： 
//1 2 3 
//2 3 4 
//3 4 5 
//
//
//1 3 4 
//2 4 5 
//4 5 6
 


////數組的方式

//int Seek(int arr[][4],int row, int key)
//{
//	int i = 0;
//	int j = row-1;
//	while(i<row && j>=0)
//	{
//		if(arr[i][j] == key)
//		{	
//			printf("存在\n");
//			return 0;
//		}
//		else if(arr[i][j] > key)
//		{
//			j--;
//		}
//		else
//		{
//			i++;
//		}
//	}
//	printf("不存在\n");
//	return 0;
//}


////指針的方式
//#include<assert.h>
//int Seek(int *arr, int row , int col, int key)
//{
//        int i = 0;
//        int j = col -1;
//        assert(arr);
//		//printf("arr=%d\narr+1 = %d\n",arr,arr+1);
//        while(i<row && j>=0)
//        {
//                if(arr[i*col+j]  == key)  ////
//                {
//                        printf("存在\n");
//                        return 0;
//                }
//                else if(arr[i*col+j] > key)////
//                {
//                        j--;
//                }
//                else
//                {
//                        i++;
//                }
//        }
//        printf("不存在\n");
//		return 0;
//}            
//      
//
//int main()
//{   
//        int arr[][4] = { {1,4,7,10},
//                        {9,12,15,18},
//                        {17,20,23,26},
//                        {25,28,31,34},
//                        };
//
//        int key = 0;
//        printf("請輸入要查找的數:> ");
//        scanf("%d",&key);
//        //Seek(arr,4,key);
//		//printf("%d\n",*(int*)arr+1);
//		//printf("arr=%d\n(int*)arr=%d\n&arr=%d",arr,(int*)arr,&arr);
//        Seek((int*)arr,4,4,key);
//        return 0;
//}


#define _CRT_SECURE_NO_WARNINGS 1
//#include<stdio.h>

////作業19

////模擬strcpy函數
//#include<assert.h>
//char *my_strcpy(char *dst, const char *src)
//{
//	char *p = dst;
//	assert(dst);
//	assert(src);
//	while(*dst++ = *src++)
//	{
//		;
//	}
//	return dst;
//}
//
//int main()
//{
//	char *cp = "abcde12345";
//	char arr[20];
//	printf("%s\n",cp);
//	my_strcpy(arr,cp);
//	printf("%s\n",arr);;
//	return 0;
//}


////模擬strcat(字符串拼接)
//#include<assert.h>
//char *my_strcat(char *dst, const char *src)
//{
//	char *p = dst;
//	assert(dst);
//	assert(src);
//	while(*dst)    //while(*dst++)  錯誤的  //while((*dst)++)  錯誤的
//	{
//		dst++;
//	}
//	while(*dst++ = *src++)
//	{
//		;
//	}
//	return p;
//}
//
//int main()
//{	
//	char arr[20] = "abcde";
//	char *cp = "456789";
//	printf("%s\n",arr);
//	my_strcat(arr,cp);
//	printf("%s\n",arr);
//	return 0;
//}


////模擬strstr(判斷字符串1是不是字符串2的子串)
//#include<assert.h>
//#include<string.h>
//char *my_strstr(const char *dst,const char *src)
//{	
//	const char *end = dst + strlen(dst) - strlen(src) + 1;  //優化的地方
//	const char *d = dst;
//	assert(dst);
//	assert(src);
//	while(d < end)
//	{
//		const char *p = d;    
//		const char *s = src;
//		while(*s)
//		{
//			if(*p == *s)
//			{
//				p++;
//				s++;
//			}
//			else
//			{
//				break;
//			}
//		}
//		if(*s == '\0')
//		{
//			return d;
//		}
//		d++;
//	}
//	
//}



//#include<assert.h>
//char *my_strstr(const char *dst, const char *src)
//{
//	char *d = dst; 
//	assert(dst);
//	assert(src);
//	while(d)
//	{
//		const char *p = d;
//		const char *s = src;
//		while((*p != '\0') && (*s != '\0') && (*p == *s))
//		{
//			s++;
//			p++;
//		}
//		if(*s == '\0')
//		{
//			return d;
//		}
//		d++;
//	}
//}
//
//int main()
//{
//	char *s = "abcdefg";
//	char *p = "cdef";
//	//char *ch = "higk";
//	char * ret = my_strstr(s,p);
//	//char * ret = my_strstr(s,ch);
//	printf("%s\n",ret);
//	return 0;
//}



////模擬實現strchr 
//
//#include<assert.h>
//char *my_strchr(const char *dst, char c)
//{
//	assert(dst);
//	while((*dst != c) && (*dst != '\0'))
//	{
//		dst++;
//	}
//	return *dst == c ? dst:NULL;
//}
//
//int main()
//{
//	char *s = "abcdef";
//	char c = 'g';
//	char *ret = my_strchr(s, c);
//	printf("%s\n",ret);
//	return 0;
//}


////模擬實現strcmp

//#include<assert.h>
//int my_strcmp(const char *dst, const char *src)
//{
//	assert(dst);
//	assert(src);
//	while(*dst != '\0' && *src != '\0')
//	{
//		if(*dst == *src)
//		{
//			dst++;
//			src++;
//		}
//		else if(*dst > *src)
//		{
//			return 1;
//		}
//		else
//		{
//			return -1;
//		}
//	}
//	if(*dst != '\0')
//	{
//		return 1;
//	}
//	if(*src != '\0')
//	{
//		return -1;
//	}
//	return 0;
//}

//#include<assert.h>
//int my_strcmp(const char *dst, const char *src)
//{	
//	int ret = 0;
//	assert(dst);
//	assert(src);
//	while(!(ret = *(unsigned char *)dst - *(unsigned char *)src) && *src)
//	{
//		dst++;
//		src++;
//	}
//	if(ret > 0)
//	{
//		ret = 1;
//
//	}
//	else
//	{
//		return -1;
//	}
//	return ret;
//}
//
//int main()
//{
//	char *ch = "abcde";
//	char *cp = "abcdef";
//	int ret = my_strcmp(ch,cp);
//	printf("%d\n",ret);
//	return 0;
//}


////模擬實現memcpy

//#include<string.h>
//#include<assert.h>
//char *my_memcpy(void *dst, const void *src, int count)
//{
//	char *d = dst;
//	const char *s = src;
//	assert(dst);
//	assert(src);
//	while(count--)
//	{
//		*d = *s;
//		++d;
//		++s;
//	}
//	return dst;
//}
//
//int main()
//{
//	char p[] = "abcdef";
//	char arr[10];
//
//	//printf("%d\n",strlen(s));
//	my_memcpy(arr,p,sizeof(p));
//	printf("%s\n",arr);
//	return 0;
//}


////模擬實現memmove

//#include<assert.h>
//#include<string.h>
//void *my_memmove(void *dst, const void *src, int count)
//{
//	char *d = dst;
//	const char *s = src;
//	assert(dst);
//	assert(src);
	//////
	//if(s < d && s+count >d)
	//{
	//	d = d + count -1;
	//	s = s + count -1;
	//	while(count--)
	//	{
	//		*d = *s;
	//		--d;
	//		--s;
	//	}
	//}
	//else
	//{
	//	while(count--)
	//	{
	//		*d = *s;
	//		++d;
	//		++s;
	//	}
	//}

    ////
//	if(d <= s || s+count <= d)       //錯誤的 if(d <= s && s+count <= d)
//	{
//		while(count--)
//		{
//			*d = *s;
//			++d;
//			++s;
//		}
//	}
//	else
//	{
//		d = d + count -1;
//		s = s + count -1;
//		while(count--)
//		{
//			*d = *s;
//			d--;
//			s--;
//			/*--s;
//			--d;*/
//		}
//	}
//
//	return dst;
//}
// 
//int main()
//{	
//	char ch[64]= "abcdefghijk";
//	my_memmove(ch,ch+1,strlen(ch));
//	printf("%s\n",ch); 
//	return 0;
//}




////作業20
//int *p; --> 指針
//int arr[5]; --> 數組
//int *p[5]; --> 指針數組
//int (*p)[5]; --> 數組指針
//int *((*p)[5]); --> 指針數組的指針
//int *((*p)[10])[5]; --> 指針數組指針的數組
//int (*p[10])[5]; --> 數組指針數組
//int *(*p[5])[5]; --> 數組指針數組的指針
//
//
//int test() --> 函數的聲明
//int *ptest() -->指針函數     //是否存在？ 是
//int (*ptest)() --> 函數指針 
//
//(void (*)() 函數指針 --> void(*)()0 將0強轉爲函數指針 -->
//(void(*)()0) 對0這個函數指針解引用 --> (*(void(*)()0)() -->
//調用函數，這個函數爲:無返回類型參數爲空的函數
//
//void(*signal(int,void(*)(int)))(int);
//
//typedef void(*pfun_t)(int); -->定義了一個 函數指針類型
//返回值爲void 參數爲int 的函數指針類型
//
//pfun_t signal(int, pfun_t) --> 返回值爲 函數指針 參數爲 int和函數指針 的函數聲明
//
//int (*p[5])() -->函數指針數組
//int *p[5]() --> 不存在這樣的東西
//int (*)()p[5] -->錯誤的,語法錯誤
//
//int ((*p)[5])() -->數組指針函數
//int (*(*p)[5])() -->函數指針數組指針
//int (*(*p[10])[5])() -->函數指針數組指針的數組


////求一個整數存儲在內存中的二進制中1的個數
//int Count(int num)
//{
//	int count = 0;
//	while(num)
//	{
//		count++;
//		num &= (num-1);
//	}
//	return count;
//}
//
//int main()
//{
//	int a = 0;
//	int ret = 0;
//	scanf("%d",&a);  
//	ret = Count(a); 
//	printf("%d\n",ret);
//	return 0;
//}


////函數指針數組的用法（轉移表） 計算器

//int add(int x, int y)
//{
//	return x+y;
//}
//
//int sub(int x, int y)
//{
//	return x-y;
//}
//
//int mul(int x, int y)
//{
//	return x*y;
//}
//
//int div(int x, int y)
//{
//	return x/y;
//}
//
//
//int main()
//{
//	int input = 1;  //初值不能爲零
//	int x = 0;
//	int y = 0;
//	int ret = 0;
//	int (*p[5])(int x, int y) = {0,add,sub,mul,div};  //轉移表
//	while(input)
//	{
//		printf("*************************\n");
//		printf("***1.add         2.sub***\n");
//		printf("***3.mul         4.div***\n");
//		printf("*************************\n");
//		printf("請選擇: ");
//		scanf("%d",&input);
//		if((input>0) && (input<5))
//		{
//			printf("請輸入操作數  ");
//			scanf("%d%d",&x,&y);
//			ret = (*p[input])(x, y);
//		}
//		else
//		{
//			printf("選擇錯誤");
//			break;
//		}
//		printf("ret = %d\n",ret);
//		printf("\n");
//		printf("\n");
//		printf("\n");
//		printf("-------------------------\n");
//	}
//	return 0;
//}


////回調函數  
////模擬實現qsort（採用冒泡法）

//int int_cmp(const void *x, const void *y)
//{
//	int *a = (int *)x;
//	int *b = (int *)y;
//	return *a > *b ? 1 : *a < *b ? -1 : 0;
//}
//
//void swap(void *x, void *y,int size)
//{
//	char *a = (char *)x;
//	char *b = (char *)y;
//	while(size--)
//	{
//		*a ^= *b;
//		*b ^= *a;
//		*a ^= *b;
//		a++;    //不能少
//		b++;
//	}
//}
//
//void bubble(void *arr, int count, int size, int(*cmp)(void *x, void *y))
//{
//	int i = 0;
//	int j = 0;
//	int flag = 0;
//	for(i = 0;i<count-1;++i)
//	{
//		flag = 0;
//		for(j=0;j<count-1-i;++j)
//		{
//			if(cmp((char *)arr + j*size, (char *)arr + (j+1)*size) > 0)  //注意最後的>0
//			{
//				flag = 1;	
//				swap((char *)arr + j*size, (char *)arr + (j+1)*size, size);
//			}
//		}
//		if(0 == flag)
//		{
//			break;
//		}
//	}
//}
//
//void print_arr(int arr[10], int sz)
//{
//	int i = 0;
//	for(i=0;i<sz;++i)
//	{
//		printf("%d ",arr[i]);
//	}
//	printf("\n");
//}
//
//int main()
//{
//	int arr[] = {1,3,5,7,9,0,2,4,6,8};
//	int sz = sizeof(arr)/sizeof(arr[0]);
//	bubble(arr,sz,sizeof(arr[0]),int_cmp);
//	print_arr(arr, sz);
//	return 0;
//}




////模擬實現strncat

//#include<assert.h>
//#include<string.h>
//
//char *my_strncat(char *dst, const char *src, int num)
//{
//	char *ret = dst;
//	assert(dst);
//	assert(src);
//	while(*dst)
//	{
//		++dst;
//	}
//	while(num--)
//	{
//		*dst = * src;
//		dst++;
//		src++;
//	}
//	return ret;
//}
//
//int main()
//{
//	char arr[64] = "abcdefg";
//	char *ch = "hijklmn";
//	int sz = strlen(ch);
//	char *ret = my_strncat(arr,ch,sz);
//	printf("%s\n",ret);
//	return 0;
//}



////模擬實現strncpy

//#include<string.h>
//#include<assert.h>
//char *my_strncpy(char *dst, const char *src, int num)
//{
//	char *ret = dst;
//	assert(dst);
//	assert(src);
//	while(num--)
//	{
//		*dst = *src;
//		dst++;
//		src++;
//	}
//	return ret;
//}
//
//int main()
//{
//	char arr[64];
//	char *ch = "opqrstuvwxyz";
//	int sz = strlen(ch) + 1;        //需要手動加\0
//	char *ret = my_strncpy(arr,ch,sz);
//	printf("%s\n",ret);
//	return 0;
//}

////模擬實現strncmp

//#include<assert.h>
//int my_strncmp(const char *p, const char *q, int num)
//{
//	assert(p);
//	assert(q);
//	while(num--)
//	{
//		if(*p > *q)
//		{
//			return 1;
//		}
//		else if(*p < *q)
//		{
//			return -1;
//		}
//		else
//		{
//			p++;
//			q++;
//		}
//	}
//	return 0;
//}
//
//int main()
//{
//	char *ch = "abcde";
//	char *cp = "abcdef";
//	int ret = my_strncmp(ch,cp,6);
//	printf("%d\n",ret);
//	return 0;
//}


//int main()
//{
//	int i = 0;
//	printf("請輸入要轉換的十進制數： \n");
//	scanf("%d",&i);
//	printf("該數轉換爲十六進制數爲：%x\n",i );
//	return 0;
//}


//int *f1(void)
//{	
//	int x = 10;
//	return &x;
//}
//
//int main()
//{
//	int *ret = f1();
//	printf("%d\n",*ret);
//	return 0;
//}


//struct B
//{
//	int a;
//};
//
//typedef struct A
//{
//	int a;
//	char b;
//	double c;
//	float d;
//	struct A *obj;
//}x;

//struct B
//{
//	 int a;
//	 char b;
//}*p,arr[20];

//struct B;
//struct A
//{
//	int x;
//	struct B *b;
//};
//
//struct B
//{
//	int y;
//	struct A *a;
//};

//struct A
//{
//	char a;
//	int c;
//	char b;
//};
//
//
//int main()
//{
//	printf("%d\n",sizeof(struct A));
//	//struct point p2 = {1,2};
//	//p1.x = 1;
//	//p1.y = 2;
//	//p1 = {1,2};  //錯誤
//	//x obx; 
//	//printf("%#p\n",&x);
//	//printf("%#p\n",&(x.a));
//	//printf("%#p\n",&(x.b));
//	//printf("%#p\n",&(x.c));
//	//printf("%#p\n",&(x.d));
//	//struct A *p = &x;
//	//x.a = 10;
//	//x.b = 'A';
//	//
//	//p->a = 300;
//	//p->b = 'C';
//	//(*p).a = 20;
//	//(*p).b = 'B';
//	//p = &x; //錯誤的
//	return 0;
//}



////將8個比特爲的某一位改爲flag

//void fun(int i, int step, int flag)
//{
//		int j = 0;
//		for(j = 7;j>=0;j--)
//		{
//			if(j == (8-step+1))
//			{
//				if(((i >> j) & 1) == flag)
//				{
//					printf("%d",(i >> j) & 1);
//				}
//				else
//				{
//					printf("%d",!((i >> j) & 1));
//				}
//			}
//		
//			else
//			{
//				printf("%d",(i >> j) & 1);
//			}
//		}
//}
//
//
//int main()
//{
//	char a = 5;
//	fun(a,5,1);
//	return 0;
//}




////編寫函數： 
////unsigned int reverse_bit(unsigned int value); 
////這個函數的返回 值value的二進制位模式從左到右翻轉後的值。 
////
////如： 
////在32位機器上25這個值包含下列各位： 
////00000000000000000000000000011001 
////翻轉後：（2550136832） 
////10011000000000000000000000000000 
////程序結果返回： 
////2550136832 

//typedef unsigned int unit;
//#include<math.h>
//unsigned int reverse_bit(unsigned int value)
//{
//	int i = 0;
//	unsigned int num = 0;
//	for(i=0;i<32;i++)
//	{
//		//num = (unit)(num + ((value >> i) & 1) * pow(2,32-i-1));
//		num |= ((value >> i) & 1) << (31 - i);       //效率更高 (拿到那一位將它左移到對應位，進行或等就會得到翻轉的值)
//
//	}
//	return num;
//}
//
//int main()
//{
//	unsigned int i = 0;
//	unsigned int ret = 0;
//	scanf("%d",&i);         //不能寫成 scanf("%u",%i); 程序會崩潰
//	ret = reverse_bit(i);
//	printf("%u\n",ret);
//	//printf("%d\n",sizeof(unit));
//	return 0;
//}



////不使用（a+b）/2這種方式，求兩個數的平均值

////方法一

//int Average(int x, int y)
//{
//	return y+(x-y)/2;
//}

////方法二
//00001010     10
//00010100     20
//
//00000000     & 
//00011110     ^
//00001111     ^ >>1

////首先，&得到的數字位，只有兩個1纔得到1，就是進位的1，
////而本該向前進一位的1待在了本位。實際上
////應該讓得到的結果左移1（讓進位的1進到合適的位置），
////然後再右移1（除以2），得到進位的平均數。
////然後，^得到的數字位，實際得到的是本位得到的結果（不包括進位），
////讓他右移1，得到本位的平均數。
////兩個平均數相加，得到整個數完整的平均數。

//#include<math.h>
//int Average(int x, int y)
//{
//	return (x & y) + ((x ^ y) >> 1);    //(x&y) x和y相同位的平均值  (x^y)>>1 x和y不同位的平均值
//}
//
//int main()
//{
//	int a = 25;
//	int b = 15;
//	int ret = 0;
//	ret = Average(a,b);
//	printf("%d\n",ret);
//	return 0;
//}


////編程實現： 
////一組數據中只有一個數字出現了一次。其他所有數字都是成對出現的。 
////請找出這個數字。（使用位運算） 

//int look_out(int *a, int len)
//{
//	int i = 0;
//	int ret = 0;
//	for(i=0;i<len;++i)
//	{
//		ret ^= a[i];     //用異或操作
//	}
//	return ret;
//}
//
//int main()
//{
//	int arr[] = {1,2,3,4,5,6,7,8,9,2,3,4,5,6,7,8,9};
//	int len = sizeof(arr)/sizeof(arr[0]);
//	int ret = 0;
//	ret = look_out(arr,len);
//	printf("%d\n",ret);
//	return 0;
//}


////有一個字符數組的內容爲:"student a am i",請你將數組的內容改爲"i am a student". 
////要求： 
////不能使用庫函數。只能開闢有限個空間（空間個數和字符串的長度無關）

////求字符串長度
//int my_strlen(const char *dst)
//{
//	int count = 0;
//	while(*dst != '\0')
//	{
//		dst++;
//		count++;
//	}
//	return count;
//}
//
//
//////逆序函數
//void Reverse(char arr[], int left, int right)
//{	
//	while(left<right)
//	{
//		char tmp = arr[left];
//		arr[left] = arr[right];
//		arr[right] = tmp;
//		left++;
//		right--;
//	}
//}
//
//
//////逆序字符串
//char* reverse_str(char arr[])
//{
//	int left = 0;
//	int right = my_strlen(arr) - 1;
//	int i = 0;
//	//先逆序整個字符串
//	Reverse(arr,left,right);
//	//逐個逆序單詞
//	while(arr[i] != '\0')
//	{
//		left = i;
//		//逆序一個單詞
//		while((arr[i] != ' ') && arr[i] != '\0')    //條件重點理解
//		{
//			i++;
//		}
//		right = i - 1;             //i是空格的下標
//		Reverse(arr,left,right);
//		if(arr[i] == ' ')         //判斷不能少，不然會跳過\0，程序崩潰,   也不能寫成 !=
//		{
//			i++;
//		}
//	}
//	return arr;
//}
//
//
//int main()
//{
//	char arr[] = "chao li";
//	reverse_str(arr);
//	printf("%s\n",arr);
//	
//	return 0;
//}


////二分查找循環的方式  （空間複雜度 O(log2 n)      時間複雜度O(1)   ）
//#include<string.h>

////區間位左閉右閉
//int banary_search(int arr[], int len, int num)
//{
//	int left = 0;
//	int right = len - 1;  //[ ]左閉右閉的情況
//	
//	while(left <= right)   ////要小於等於
//	{
//		int mid = left + ((right - left) >> 1);//
//		if(arr[mid] == num)
//		{
//			return mid;
//		}
//		else if(arr[mid] < num)
//		{
//			left = mid + 1;             //保證左閉
//			//mid = left + ((right - left)/2);
//			//mid = left + ((right - left) >> 1);
//			//mid = (left & right) + ((left ^ right) >> 1);
//		}
//		else 
//		{
//			right = mid - 1;          //保證右閉
//			//mid = left + ((right - left)/2);
//			//mid = left + ((right - left) >> 1);
//			//mid = (left & right) + ((left ^ right) >> 1);
//		}
//	}
//	return -1;
//}

////區間爲左閉右開
//int banary_search(int *arr, int len, int num)
//{
//	int left = 0;
//	int right = len;    // [  ) 左閉右開
//	
//	while(left < right)  //
//	{
//		int mid = (left & right) + ((left ^ right) >> 1);//
//
//		if(arr[mid] == num)
//		{
//			return mid;
//		}
//		else if(arr[mid] < num)
//		{
//			left = mid + 1;   //
//			//mid = (left & right) + ((left ^ right) >> 1);
//		}
//		else
//		{
//			right = mid;
//			//right = mid - 1;   //如果恰巧middle-1就是查找的元素,那麼就會找不到這個元素
//			//mid = (left & right) + ((left ^ right) >> 1);
//		}
//	}
//	return -1;
//}


////遞歸的方式 (時間複雜度O(log2 n)   空間複雜度O(n))
//int banary_search(int arr[], int left, int right, int num)
//{
//	int mid = (left & right) + ((left ^ right) >> 1);
//	if(left > right)
//	{
//		return -1;
//	}
//	else
//	{
//		if(arr[mid] == num)
//			return mid;
//		else if(arr[mid] < num)
//			banary_search(arr,mid+1,right,num);  //
//		else 
//			banary_search(arr,left,mid-1,num);  //
//	}
//}
//
//
//int main()
//{
//	int arr[] = {1,2,3,4,5,6,7,8,9,10};
//	//int len = sizeof(arr)/sizeof(arr[0]);
//	int left = 0;
//	int right = sizeof(arr)/sizeof(arr[0])-1;
//	int ret = banary_search(arr,left,right,5);
//	//int ret = banary_search(arr,len,5);
//	printf("%d\n",ret);
//	return 0;
//}



////斐波那契數列(循環方式)(時間複雜度 O(n) 空間複雜度 O(1))
//int fibonacci_sequence(int n)
//{
//	int a = 1;
//	int b = 1;
//	int c = 1;
//	while(n>2)
//	{
//		c = a + b;
//		a = b;
//		b = c;
//		--n;
//	}
//	return c;
//	
//}

//0 1 1 2 3 5 8 13 21 34 55

////遞歸方式(時間複雜度O(2^n)   空間複雜度O(n))
//int fibonacci_sequence(int n)
//{
//	if(n<3)
//		return 1;
//	return fibonacci_sequence(n-1)+fibonacci_sequence(n-2);
//}
//
//int main()
//{	
// 	printf("%d\n",fibonacci_sequence(7));
//	return 0;
//}

#define _CRT_SECURE_NO_WARNINGS 1
//#include<stdio.h>


////猜數字遊戲
////#include<string.h>
////#include<windows.h>
//#include<stdlib.h>
//#include<time.h>
//enum Option
//{
//	EXIT,
//	PLAY,
//};
//
//void menu()
//{
//	printf("*************************\n");
//	printf("*** 1.play     0.exit ***\n");
//	printf("*************************\n");
//	
//}
//
//void game()
//{
//	int ret=0;
//	int num=0;
//	ret = rand()%100+1;
//	while(1)
//	{
//		printf("請猜數字; ");
//		scanf("%d",&num);
//		if(num == ret)
//		{
//			printf("恭喜你，猜對了\n");
//			break;
//		}
//		else if(num>ret)
//		{
//			printf("猜大了\n");
//		}
//		else
//		{
//			printf("猜小了\n");
//		}
//	}
//}
//
//int main()
//{
//	int input=0;
//	srand((unsigned int)time(NULL));
//	do
//	{
//		menu();
//		printf("請選擇： ");
//		scanf("%d",&input);
//		switch(input)
//		{
//		case 1:
//			game();
//			break;
//		case 0:
//			break;
//		default:
//			printf("選擇錯誤\n");
//			break;
//		}
//	}
//	while (input);
//	
//return 0;
//}







////用2分法查找數組裏面的元素，找到時返回該元素下標
//int main()
//{
//	int key = 10;
//	int arr[] = {0,1,2,3,4,5,6,7,8,9};
//	int left = 0;
//	int right = sizeof(arr)/sizeof(arr[0])-1;
//	int mid = left+(right-left)/2;
//
//	while(left<=right)
//	{
//		mid=left+(right-left)/2;
//		if(arr[mid]==key)     //    切記:  比較的時候不能寫爲  if(arr==key)  
//		{
//			printf("找到了\n");
//			printf("%d\n",mid);
//			break;
//		}
//	else if(arr[mid]<key)
//		{
//			left = mid+1;
//			//mid = left+(right-left)/2;   //這一句可以放在while循環的開始   這樣後面就不再需要寫了
//		}
//	 else          //這裏不可以寫成 else(),  else後面不可以有條件。但是，else if()這樣可以。
//		{
//			right = mid-1;
//			//mid = left+(right-left)/2;
//		}
//	}
//	if(left>right)
//	{
//		printf ("沒找到\n");
//	}
//
//return 0;
//}







////模擬用戶登錄密碼只有3次輸入機會
//#include<string.h>
//int main()
//{	
//	int i = 0;
//	char passwed [10] = {0};
//	
//	while(i<3)     //或者用for(i=0;i<3;i++)則去掉後面的i++。continue有沒有不影響
//	{	
//		printf("請輸入密碼\n：");
//		scanf("%s",&passwed);         // 切記 ：前倆句不能放在循環外部。一定要放在循環內部，因爲每次都要輸入密碼再判斷。
//		if(0 == strcmp(passwed,"123456"))
//		{
//			printf("登陸成功!\n");
//			break;    
//		}
//		else
//		{	
//			printf("密碼錯誤!\n");
//			i++;
//			continue;  //結束本次循環，進入下次循環的判斷部分
//		}
//	}
//	if(i == 3)
//	{
//		printf("退出系統！");
//	}
//
//return 0;
//}



////計算有幾位

// int main()
// {
//	int i = 0;
//	int m = 0;
//	int bit = 1;
//	scanf("%d",&i);
//	m=i;
//	while(m/10)
//	{
//		bit++;
//		m=m/10;
//	}
// return 0;
// }


////寫一個函數返回參數二進制中 1 的個數
////i大於15和負數  沒有輸出
//int main()
//{
//	int i = 0;
//	int count = 0;
//	scanf("%d",&i);
//	while(i)
//	{
//		if(i%2 == 1)
//		{
//			count++;
//			i=i/2;
//		}
//	}
//	printf("%d",count);
//return 0;
//}


//int main()
//{
//	int num = 0;
//	int i = 0;
//	int count = 0;
//	scanf("%d",&num);
//	for(i=0;i<32;i++)
//	{
//		if(((num>>i) & 1) == 1)
//		{
//			count++;
//		}
//	}
//	printf("%d",count);
//	return 0;
//}


//int main()
//{
//	int num = 0;
//	int count = 0;
//	scanf("%d",&num);
//	while(num)
//	{
//		count++;
//		num = num & (num-1);
//	}
//	printf("%d",count);
//	return 0;
//}

////獲取一個數二進制序列中所有的偶數位和奇數位，分別輸出二進制序列
//int main()
//{
//	int i = 0;
//	int j = 0;
//	int a = 0;
//	scanf("%d",&i);
//	printf("奇數位\n");
//	for(j=0;j<31;j+=2)
//	{	
//		//先打印奇數位	
//		i=i >> j;
//		a=i & 1;
//		printf("%d",a);
//	}
//	  //打印偶數位
//	printf("\n");
//	printf("偶數位\n");
//	for(j=1;j<32;j+=2)
//	{
//		i = i >> j;
//		a = i & 1;
//		printf("%d",a);
//	}
//return 0;
//}


//輸出一個整數的每一位
//int main ()
//{
//	int i = 0;
//	int tmp = 0;
//	int bit = 1;
//	scanf("%d",&i);
//
//	// 計算這個數有幾位
//	tmp = i;
//	while(tmp/10)
//	{
//		bit++;
//		tmp=tmp/10;	
//	}
//	// 取下每一位的數字
//	while(i%10)
//	{
//		printf("%d\n",i%10);
//		i=i/10;
//	}
//
//return 0;
//}


////編程實現：
////兩個int（32位）整數m和n的二進制表達中，有多少個位(bit)不同？

//int main()
//{
//	int m = 0;
//	int n = 0;
//	int i = 0;
//	int count = 0;
//	scanf("%d%d",&m,&n);
//	m=m^n;
//	for(i=0;i<32;i++)
//	{
//		if(((m>>i) &1 ) == 1)	
//		{
//			count++;
//		}
//	}
//	printf("%d",count);
//return 0;
//}



////用函數打印自己可以控制行列的乘法口訣表
//void Mul(int x, int y,int n)
//{
//	for(x=1;x<=n;x++)
//	{
//		for(y=1;y<=x;y++)
//		{
//			printf("%2d*%2d=%2d ",x,y,x*y);  //不要寫成 printf("%2d*%2d=%2d",x*y);這樣打印的是i*隨機值
//		}
//		printf("\n");
//	}
//}
//
//
//int main()
//{
//	int i = 0;
//	int j = 0;
//	int n = 0;
//	scanf("%d",&n);
//	Mul (i,j,n);
//return 0 ;
//}



////用函數的方式交換兩個數
//void Swap (int *p1, int *p2)
//{
//	int tmp = 0;
//	tmp = *p1;
//	*p1 = *p2;
//	*p2 = tmp;
//	printf("交換a和b:");
//	printf("\n");
//	printf("a=%d\nb=%d",*p1,*p2);
//}
//
//
//int main ()
//{
//	int a = 0;
//	int b = 0;
//	printf("請輸入a和b:");
//	printf("\n");
//	scanf("%d%d",&a,&b);
//	Swap(&a,&b);
//
//return 0;
//}


////用函數的方式判斷是不是閏年
//void Year (int x)
//{
//	if((x%4==0)&&(x%100 != 0)||(x%400==0))
//	{
//		printf("是閏年\n");
//	}
//	else
//	{
//		printf("不是閏年\n");
//	}
//}
//
//
//int main()
//{
//	int i = 0;
//	printf("請輸入年份:");
//	scanf("%d",&i);
//	Year (i);
//return 0;
//}


////求兩個數的最小公倍數

//int main ()
//{
//	int a = 0;
//	int b = 0;
//	int c = 0;
//	int d = 0;
//	int tmp = 0;
//	scanf("%d%d",&a,&b);
//	c = a;
//	d = b;
//	//先求最大公約數
//	while(c%d)
//	{
//		//if(c%d != 0)
//		//{
//			tmp = c%d;
//			c = d;
//			d = tmp;
//		// }	
//	}
//	//求最小公倍數
//	a = a*b/d;
//	printf("%d",a);
//return 0;
//}





////日本某地發生了一件謀殺案，警察通過排查確定殺人兇手必爲4個嫌疑犯的一個。以下爲4個嫌疑犯的供詞。
////A說：不是我。
////B說：是C。
////C說：是D。
////D說：C在胡說
////已知3個人說了真話，1個人說的是假話。
////現在請根據這些信息，寫一個程序來確定到底誰是兇手。

//int main()
//{
//	int killer = 0;
//	for(killer = 'a'; killer<='d'; killer++)
//	{
//		if(3==(killer != 'a')
//			+(killer == 'c')
//			+(killer == 'd')
//			+(killer != 'd'))
//		{
//			printf("%c\n",killer);
//		}
//	}
//return 0;
//}




//打印楊輝三角

//int main()
//{
//	int arr[10][10]={0};
//	int i = 0;
//	int j = 0;
//	int sz = 10; 
//
//	for(i=0;i<sz;i++)
//	{
//		
//
//		for(j=0;j<sz;j++)
//		{
//			//打印斜列
//			if(0==j)
//			{
//				arr[i][j] = 1;
//			}
//			if(i==j)              //若改爲  if(sz==j)
//			{
//				arr[i][j] = 1;
//			}
//			//打印中間
//			if((i>1)&&(j>0))
//			{
//				arr[i][j] = arr[i-1][j-1] + arr[i-1][j];
//			}
//		}
//
//	}
//    
//	for(i=0;i<sz;i++)
//	{	//打印空格
//		for(j=0;j<(sz-i-1);j++)
//		{
//			printf(" ");
//		}
//                            //和前面一處一起改的
//		for(j=0;j<=i;j++)  //此處若改爲    for(j=0;j<i;j++)   也可以打印出，不過少了一行
//		{
//			printf("%3d ",arr[i][j]);
//		}
//		printf("\n");
//		printf("\n");
//
//	}
//		
//return 0;
//}



//int main()
//{
//	int i = 0;
//	int j = 0;
//	int arr[10][10] = {0};
//	int sz = 10;
//
//	for(i=0;i<sz;i++)
//	{
//           //打印空格
//		for(j=0;j<sz-i;j++)
//		{
//			printf(" ");
//		}
//
//		for(j=0;j<sz;j++)
//		{
//			//先打印斜邊
//			if((0==j)||(sz==j))
//			{
//				arr[i][j] = 1;
//			}
//			
//			//打印中間
//			if(i>1&&j>0)
//			{
//				arr[i][j] = arr[i-1][j-1]+arr[i-1][j];	
//			}
//		}
//       
//		for(j=0;j<i;j++)
//		{
//			printf("%3d ",arr[i][j]);
//		}
//		printf("\n");
//		printf("\n");
//	}
	
//return 0;
//}



////計算器

//int main(int argc,char *argv[],char *envp)
//{
//	int x = 0;
//	int y = 0;
//	if(argc != 4)
//	{
//		printf("參數有誤\n");
//	}
//	printf("\n");
//	x = atoi(arr[2]);
//	y = atoi(arr[3]);
//	switch(*(argv[1]))    //*argv[0]
//	{
//		
//	}
//	return0;
//}
	

在這裏插入代碼片
發表評論
所有評論
還沒有人評論，想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章

位圖的像素操作練習（2012-05-25）

很久沒有較長篇的代碼練習了，今天偷閒回顧練習了一下位圖文件的像素操作，備忘，參考了：水平翻轉，垂直翻轉，轉灰度: void BMPOpt(){BIT

蓄丰 2020-07-07 07:54:39

Java實現輸入字符串，其首項和末項字符位置不變，中間部分字符反轉

摘要：   例如輸入：abcdefg；則輸出：afedcbg。 參考代碼： package com.gx.demo; import java.util.Scanner; public class Test { public

程序yang 2020-06-30 21:22:18

一棟電梯樓共10層，電梯每到一層需要語音提示“第幾層到了”。但是第四層不會提示，因爲不吉利。

摘要：   例如:如果賦給變量的值爲1，則輸出“第1層到了”，如果賦給變量的值爲2，則輸出“第2層到了”。 參考代碼： package com.gx.demo; import java.util.Scanner; public

程序yang 2020-06-30 21:22:18

設計一個數組，當輸入的正整數爲n時，其中只能被3整除的賦值爲Three，只能被5整除的賦值爲Five，既能被3整除又能被5整除的賦值爲Fifteen，其他則爲數字。

試例如下，當n=16將返回： {1,2,Three,4,Five,Three,7,8,Three,Five,11,Three,13,14,Fifteen,16} 參考代碼1： package com.gx.demo; impor

程序yang 2020-06-30 21:22:18

Java實現輸入年份，輸出對應的生肖年

摘要：   十二生肖的排序：鼠、牛、虎、兔、龍、蛇、馬、羊、猴、雞、狗、豬 提示：   可以利用switch語句實現 語法： switch(表達式){ case 值1: 表達式的值和 值1匹配上了，需要執

程序yang 2020-06-30 21:22:17

求下面的單鏈表中最大值結點的位置及反轉

摘要： 需求1：求下面的單鏈表中最大值結點的位置： [29, 33, 98, 12, 97, 2, 3, 67, 52, 27] 需求2：將下面的單鏈表反轉: [29, 33, 98, 12, 97, 2, 3, 67, 52,

程序yang 2020-06-30 21:22:17

輸入一個字符串，統計其中有多少個"ab"子字符串；並將其中有所有的"ab"替換成"xy"。

摘要： 編程題 1、輸入一個字符串，統計其中有多少個"ab"子字符串。 2、輸入一個字符串，將其中有所有的"ab"替換成"xy"。 參考代碼： package com.gx.demo; import java.util.Scan

程序yang 2020-06-30 21:22:07

利用Java實現交換兩個變量的三種方式（Java常見面試題）

摘要：   利用Java實現交換兩個變量的三種方式:   （1）藉助臨時變量   （2）不借助第三變量，通過加減方式   （3）通過異或運算 package com.gx.demo; public class ExchangeT

程序yang 2020-06-30 21:22:07

Java優雅地實現數組的三種輸出形式

一維數組： 定義一個數組：int[] array = { 1, 2, 3, 4, 5 }; （1）傳統的for循環方式，示例代碼1： for (int i = 0; i < array.length; i++) { System

程序yang 2020-06-30 21:22:06

Java語言求出100以內的素數（質數），並以5個爲一行的打印輸出

摘要：   質數又稱素數。一個大於1的自然數，除了1和它自身外，不能被其他自然數整除的數叫做質數；否則稱爲合數。 參考代碼： package com.gx.demo; public class Demo1 { public s

程序yang 2020-06-30 21:22:06

第四天 像素翻轉

題目描述 有一副由NxN矩陣表示的圖像，這裏每個像素用一個int表示，請編寫一個算法，在不佔用額外內存空間的情況下(即不使用緩存矩陣)，將圖像順時針旋轉90度。 給定一個NxN的矩陣，和矩陣的階數N,請返回旋轉後的NxN矩陣,保證

什么时候能睡醒啊 2020-06-21 10:20:20

第三天 原串翻轉

咳咳，陪女朋友出去玩了一天，斷了更... 本題出自金典第二題，講道理比較簡單，但是在閱讀了別人分享的代碼之後，看到一些新的知識所以記錄一下。 先上自己無聊的代碼 class Reverse { public: string re

什么时候能睡醒啊 2020-06-21 10:20:20

第三天 確定兩串亂序同構

題目描述 給定兩個字符串，請編寫程序，確定其中一個字符串的字符重新排列後，能否變成另一個字符串。這裏規定大小寫爲不同字符，且考慮字符串重點空格。 給定一個string stringA和一個string stringB，請返回一個bool

什么时候能睡醒啊 2020-06-21 10:20:20

第二天 確定字符互異

題目出自程序員面試金典。 看到這道題直接跳出來了兩個想法：1. 暴力不是很複雜； 2. Hash/Map之流的（違反題目要求）。 習慣性先寫了暴力方法（內心OS：竟然沒有超過時間） class Different { public:

什么时候能睡醒啊 2020-06-21 10:20:20

【編程練習】鏈表必考重點算法

一、單鏈表反轉 LinkList Reserve_L(LinkList L) { if(L==NULL||L->next==NULL) return 0; LNode *p,*r; p=L->next;//指向第一個結點

免于枯燥 2020-06-17 19:55:57