Day6记录

1.指针与数组

1.1迭代器

int *begin = a;
int *end = a + (sizeof(a) / sizeof(*a)) - 1;

通过定义指针变量begin，end作为一个迭代器，通过指针运算，将原本所需循环中变量i优化,可以简化数组下标

void printArray(int *begin,int *end)//遍历数组
{
    while(begin <= end)//指针的比较运算判断
    {
        printf("%d\n",*begin);
        begin++;
    }
}

void swap(int *a, int *b)//数值交换函数
{
	int t = *a;
	*a = *b;
	*b = t;
}

 1.2指针与递归函数

如果要求数组函数不能使用变量和循环，可以用递归函数代替循环，迭代器实现优化变量，如：

void printArray(int *begin, int *end)//遍历数组
{
	if(begin > end)
	{
		return ;
	}
	else
	{
		printf("%d\n", *begin);
		printArray(begin + 1, end);
	}
}

void reverse(int *begin, int *end)//逆序数组
{
	if(begin >= end)
	{
		return ;
	}
	else
	{
		swap(begin, end);
		reverse(begin + 1, end - 1);
	}

}

1.3迭代器在数组中运用

遍历：

void printArray(int *begin,int *end)//遍历数组
{
    while(begin <= end)//指针的比较运算判断
    {
        printf("%d\n",*begin);
        begin++;
    }
}

逆序:

void swap(int *begin,int *end)
{
   int t;
   t = *begin;
   *begin = *end;
   *end = t;
}

void reverse(int *begin ,int *end)
{
   while(begin <= end)
   {
      swap(begin,end)
      begin++;
      end--;
    }
 }
int main(void)
{	
	int a[] = {1,-2,3,-4,5,-6,7,-8,9,0};
	int len = sizeof(a) / sizeof(*a);


	return 0;
}

选择排序：

void swap(int *begin,int *end)
{
   int t;
   t = *begin;
   *begin = *end;
   *end = t;
}
void choiceSort(int *begin, int *end)
{
	int *p;
	for(;begin < end;++begin)
	{
		for(p = begin + 1;p <= end;++p)
		{
			if(*begin > *p)
			{
				swap(begin, p);
			}
		}
	}
}

int main(void)
{	
	int a[] = {1,-2,3,-4,5,-6,7,-8,9,0};
	int len = sizeof(a) / sizeof(*a);


	return 0;
}

冒泡排序：

void swap(int *begin,int *end)
{
   int t;
   t = *begin;
   *begin = *end;
   *end = t;
}

void maopaosort(int *begin,int *end)
{
	for(end;end > begin;end--)
	{
		for(begin;begin < end;begin++)
		{
			if(*begin > *end)
			{	
		                swap(begin,end);
			}
		}
	}
}

二分法查找：

void swap(int *begin,int *end)
{
   int t;
   t = *begin;
   *begin = *end;
   *end = t;
}
int midFind(int *begin,int *end,int n)
{
	int *mid = (end - begin) + begin;
	int *p = begin;
	if(begin > end)
	{
		return -1;
	}
	if(*mid > n)
	{
		end = mid -1;
	}
	else if(*mid < n)
	{
		begin = mid + 1;
	}
	else
	{
		return *mid ;
	}
	midFind(begin,end,n);
}

快速查找：

void swap(int *begin,int *end)
{
   int t;
   t = *begin;
   *begin = *end;
   *end = t;
}
void qSort(int *begin, int *end)
{
	if(begin > end)
	{
		return ;
	}
	int t = *begin;
	int *p = begin;
	int *q = end;

	while(p < q)
	{
		while(p < q && *q >= t)
		{
			--q;
		}
		while(p < q && *p <= t)
		{
			++p;
		}
		swap(p, q);
	}
	swap(begin, p);
	qSort(begin, p - 1);
	qSort(p + 1, end);

}

二，指针与字符串数组

字符串输出：

void Puts(char *s)
{
	while(*s)
	{
		putchar(*s++);
	}
	putchar('\n');
}

字符串长度：

int Strlen(char *s)
{
	if(*s == '\0')//递归函数表示
	{
		return 0;
	}
	else
	        return Strlen (s + 1) + 1;

        
/*	while(*s)
	{
		i++;
		s++;
	}

	return i;
*/
}

strcpy:

char *Strcpy(char *dest,const char *src)
{
	char *ret = dest;
	while(*src)
	{
		*dest++ = *src++;
	}
	*dest = 0;
	return ret;
}

strncpy:

char *Strncpy(char *dest,const char *src,unsigned long n)
{
	char *ret = dest;
	while(*src && n)
	{
		n--;
		*dest++ = *src++;
	}
	*dest = 0;
	return ret;
}

strcat:

char *Strcat(char *dest,const char *src)
{
	char *ret = dest;
	while(*dest)
	{
		dest++;
	}
	while(*src)
	{
		*dest++ = *src++;
	}
	*dest = 0;

	return ret;


}

strncat:

char *Strncat(char *dest, const char *src, unsigned long n)
{
	char *ret = dest;
	while(*dest++)
	{
		
	}
	while(*src && n)
	{
		*dest++ = *src++;
		--n;
	}
	*dest = 0;
	return ret;

}

strcmp:

int Strcmp(const char *dest,const char *src)
{
	while(*dest == *src && *dest && *src)
	{
		dest++;
		src++;
	}
	return *dest - *src;
}

strncmp:

int Strncmp(const char *dest,const char *src,signed long n)
{
	while(*dest == *src && *dest && *src && --n)
	{
		dest++;
		src++;
	}
	return *dest - *src;
}

注意：

1、

int *p;   
p = "hello"; 

sizeof(p)表示的是指针变量所占的字节个数，等价于sizeof(char *a)

strlen(p)表示 p指向"hello"字符串中的首个字符地址，然后经过strlen函数运算得到”hello"一共的字符个数

2、const关键字

（1）const int i;//表示只读，但可以通过指针修改

（2）const int *p;//const修饰的是int *,表示不能通过该指针去修改它所指向的变量，但是指针p本身可以修改

（3）int * const p;//const修饰的是指针p，表示指针p本身不能修改，但是p指针所指向的值可以修改

3、static关键字

（1）static修饰的局部变量，成为静态局部变量。普通局部变量存储于进程栈空间，使用完毕会立即释放，局部变量使用static修饰符定义，即使在声明时未赋初值，编译器也会把它初始化为0。且静态局部变量存储于进程的全局数据区，即使函数返回，它的值也会保持不变。

（2）static修饰全局变量，称为静态全局变量。仅对当前文件可见，其他文件不可访问，其他文件可以定义与其同名的变量，两者互不影响。

（3）static修饰的函数，为静态函数。静态函数只能在声明它的文件中可见，其他文件不能引用该函数。不同的文件可以使用相同名字的静态函数，互不影响

4、万能指针 void *p

可以接受任何类型的指针

void *Memcpy(void *dest, const void *src, unsigned long n)
{
	char *p = (char *)dest;
	char *q = (char *)src;
	while(n)
	{
		*p++ = *q++;
		--n;
	}
	return dest;
}