指针+一维整型数组的基本运用 和 指针＋一维整型数组的初步学习_用指针数组来处理一个一维数组

一，调式程序的技巧：

1.明确问题
2.定位问题
3.加打印（打印核心数据0）

---

二，指针的回顾

1.指针的概念：指针就是地址（内存单元的编号），是一个数据类型（指针类型）
                         指针在不同于句中： 定义指指针指的是定义一个指针变量（int *p）
                                                           打印指针某个变量的指针，就是打印出一个地址的内容

2.指针变量的定义： 基类型*变量名
基类型：数据类型 / 基本数据类型 / 数组类型 / 指针类型
* ： *定义的是一个指针类型的变量，修饰指针变量名的
*p的运算：s1；拿p中的地址到内存定位  ；  s2：定位处偏移基类型大小的空间 ； s3：被当作了基类型变量来看

3.注意事项：指针变量的大小 64位（8字节）， 32（四字节） ； 指针类型存储的是地址，特殊的数据   ；    指针变量的给值：int  *p     ---   野指针，没有初始化，被当作了地址，所以要避免野指针，一般初始化为 NULL

4.指针的核心用途：被调函数修改主调
用法：修改谁就传谁的地址       ；    *p的运算---间接访问 

5.指针+ 一维整型数组（指针操作一维）
int a[10];; int *p=a;
*(p+i)  ==  int 型变量               a[i] == p[i] == *(a+i)

6.关系运算：
b>q  ；  b<q  ； &  ；  *    ；  
p-q (前提是同一类型的指针，表示之间差了几个基类型)
指针不能做加法运算

迭代运算：本质就是可以利用指针访问到每一个元素的地址

迭代实现选择排序冒泡排序：

选择排序：

冒泡排序：

---

三，快速排序（时间复杂度为 n *log n）

快速排序本质就是定义一个基准值，通过从右向左找最大值，再从左向右找最小值，交换，然后循环直至begin和end相等时，此时划分两个部分，然后分别定义基准值重复找数换位的步骤，直至begin>end的时候结束。

快速排序示意图：

快速排序的程序：

void quickSort(int *begin,int *end)       //快速排序
{
	int *p = begin;                       //记录开始的位置和最右边的位置
	int *q= end;
 
	int *k = begin;                       //第一步，确定基准值，a[0]
 
	if(begin>end)                         //结束递归的条件
	{
		return ;
	}
	while(begin<end)                      //begin　和 end　不能反过来，而且直到它们相遇停止循环
	{
		while(begin < end && *end >= *k)  //第二步，从右边（最后一项）开始找，找到第一个比基准值小的值
		{
			--end;                        //没找的话向前移位
		}
		while(begin < end && *begin <= *k) //第三步，从左边（ａ【０】）开始找，找到第一个比基准值大的值
		{
			begin++;                      //没找到向后移位
		}
		swap(begin,end);                  //最大值最小值都找到了，进行它俩的换位
	}                                     //回到循环起始点，接着找最大值最小值
 
	swap(begin,k);                        //此时相遇位置上的值与基准值交换
	quickSort(p,end-1);                   //针对数小的一部分，此时ｂｅｇｉｎ为开始的ａ【０】，ｅｎｄ为ｅｎｄ地址中的新ｅｎｄ－１
	quickSort(begin+1,q);                 //针对数字大的部分，此时ｂｅｇｉｎ为地址ｂｅｇｉｎ＋１，ｅｎｄ为开始的ｅｎｄ
}

---

四，指针+ 一维字符型数组

char *p = s ;   s就是数组首元素的地址

int puts(const char *s);
const char *S;
const int a;//只读变量
int a=10;
const int*p=&a； //表示基类型 为只读
p---指针变量--本身的类型int*
a---int型变量--本身类型int

const char * 的好处：
1.可以接收字符数组名，也可以接受字符串常量，提高了参数的适用性
2.避免了可能出现的修改的操作，也可以将运行时的错误，提前到编译时发现

---

四，相关程序

1.数组的逆序，指针。
 

void nixuArray(int *begin, int *end)                           //逆序，纯指针形式
{
	while(begin<end)
	{
		int t = *begin;
		*begin = *end;
		*end = t;
		++begin;
		--end;
	}
 
}

2.插入排序

void paixuArray(int *begin,int *end)                   //插入排序，纯指针
{
	int *p =begin;
	int *q =NULL;
	for(p=begin;p<=end;p++)
	{
		int t = *p;
		q=p;
		while(q>begin&&*(q-1)>t)
		{
			*q=*(q-1);
			--q;
		}
	       *q=t;
	}
}

3.二分查找

int *binaryD(int *begin,int *end,int n)                                        //二分查找
{
    int *mid=NULL;
	mid = begin+(end-begin+1)/2;
	int *ret=NULL;
	if(begin>end)
	{
		ret = NULL;
	}
	if(*mid>n)
	{
		end=mid-1;
	    ret = binaryD(begin,end,n);
	}else if(*mid<n)
	{
		begin=mid+1;
		ret = binaryD(begin,end,n);
	}else
	{
		ret = mid;
	}
    return ret;
}

4.输入/输出字符串

void Gets(char *s)                       //输入字符串
{
	do
	{
		*s = getchar();
	}while(*s++!='\n');
	s--;
	*s='\0';
}
 
void Puts(const char *p)                //输出字符串
{
	while(*p!='\0')
	{
		putchar(*p);
		++p;
	}
	putchar('\n');
}

5.相关输出

int main(void)
{
	int a[5]={1,2,4,3,5};
	int i=0;
	//nixuArray(a,a+4);      //逆序的输出
	//paixuArray(a,a+4); //排序的输出(charu)
	//int x=3;
	//int *ret = binaryD(a,a+4,5);
	//printf("%d\n",*ret);            //二分查找的输出
	
	//for(i=0;i<5;i++)
	//{
	//printf("%d",a[i]);
	//}
	//putchar('\n');
	return 0;
}