指针(二)(13)

一、指针变量初始化

如果指针变量没有初始化，此时是随机值。 ---野指针

初始化可以让指针变量 有明确指向。 

赋值:
int * p;
p = NULL;

    
int a;
int *p;
p = &a;

如果这样定义的话：int *p,q;

那么p是指针类型 int * ，q是int型

int *p,*q; //此时表示定义了两个 int*类型的变量 p 和q 

注意:  

  定义时候的 * 修饰变量名的 表示定义的是一个指针类型的变量

为啥需要指针?
   被调修改主调     //指针 80%  用途

要实现被调修改主调:

二、指针作为函数参数 

形参   -- 指针类型 变量 ，用来接收实参 (实参是要操作的内存空间的地址)

实参   -- 要修改谁，就把谁的地址传过去 
             //要保证 空间有效 
             注意: 被调函数中 一定要有 *p 运算 //(间接访问的操作)

值传递          //只是 实参数据 赋值了形参  
地址(指针)传递  //传的是地址 --可以实现被调修改主调 

练习:
   实现两个数的求和 
   结果，通过参数带出来 

#include<stdio.h>

void add(int a,int b,int *sum)
{
	*sum = a+b;
}

int main(void)
{
	int a,b,sum;
	scanf("%d%d",&a,&b);

	add(a,b,&sum);

	printf("h = %d\n",sum);

	return 0;
}

练习:
   找出两个中最大值 和 最小值 //写函数

#include<stdio.h>

void max(int a,int b,int *max)
{
	*max = a>b?a:b;
}

void min(int a,int b,int *min)
{
	*min = a<b?a:b;
}

int main(void)
{
	int a,b,ma,mi;
	scanf("%d%d",&a,&b);

	max(a,b,&ma);
	min(a,b,&mi);

	printf("max = %d\n",ma);
	printf("min = %d\n",mi);

	return 0;
}

练习:交换两个数
    int a = 1,b = 2; 
    swap()

#include<stdio.h>

void swap(int *a,int *b)
{
	int temp;
	temp = *a;
	*a = *b;
	*b = temp;
}

int main(void)
{
	int a,b;
	scanf("%d%d",&a,&b);

	swap(&a,&b);

	printf("a = %d b = %d\n",a,b);
	return 0;
}

三、指针 + 一维整型数组

int a[5]; //一维整型数组 
          //数组名 
          //    类型  --- 数据类型 int[5]
          //    值    --- 数组首元素的地址 --- 常量 
          //数组名是个常量，不能做自增自减运算 

        eg：*a++（a是个数组名，是个常量，不能做自增减的运算所以会报错）

1.定义一个什么类型的指针变量?

  int *p = a;
  int *p = &a[0];

2.谁能代表数组所在空间的首地址?
   数组名 -- 数组首元素的地址  
   
   这个地址值的类型  
   a <=>  &a[0] 
          //a[0]的数据类型 -- int型 
          //&a[0]  地址的类型 -- int * 

int *p = a; //表示 p指向数组a 

*p  <=> a[0] 
 

指针的运算: 
&
*  

int *p; //p 的类型 int *

*&p //地址 
   //int* * 

p+1   //加n 表示 跳过了n个基类型 
p-1
p++
p--

p - q     //表示差了多少元素(基类型)
          //必须是同一类型的指针  
          
p + q     //不行 +-*/都不行

*(p+i) <=> a[i] <=> *(a+i)

 //
 a[i]  <=> *(a+i)
 i[a]  <=> *(i+a) 

数组作为函数参数 
  形参 -- 数组形式  //本质上是一个指针类型变量
                   int *a                   
          数组长度 
                   int len
  实参 -- 数组名 
              数组名代表数组首地址 
          数组长度 

练习:
    准备一个数组，找数组中的最大值

int maxarray(int *a,int len)
{
	int max;
	max = *a;
	int i = 0;
	for(i = 1;i < len;++i)
	{
		if(max < *(a+i))
			max = *(a+i);
	}
	return max;
}

迭代输出数组

void printArrayP(int *begin,int *end)
{
	while (begin <= end)	
	{
		printf("%d ",*begin++);
	}
	putchar('\n');
}

练习:
    数组逆序    // 迭代的方式实现

void reverse(int *begin,int *end)
{
	int temp;
	while(begin <= end)
	{
		temp = *begin;
		*begin = *end;
		*end = temp;
		++begin;
		--end;
	}
}

练习:
    排序    //迭代的方式

选择：

void sort(int *begin,int *end)
{
	int t;

	int *p = begin;
	int *q = NULL;
	for(p;p<=end;++p)
	{
		for(q=p+1;q<=end;++q)
		{
			if(*p>*q)
			{
				t = *p;
				*p = *q;
				*q = t;
			}
		}

	}
}

插入：

void sort(int *begin,int *end)
{
	int t;

	int *p = begin;
	int *q = NULL;
	for(p=begin+1;p<=end;++p)
	{
		t = *p;
		q = p;
		while(q>begin && *(q-1)>t)
		{
			*q=*(q-1);
			--q;
		}
		*q = t;
	}
}

冒泡：

void sort(int *begin,int *end)
{
	int t;

	int *p = begin;
	int *q = NULL;
	for(p;p<end;++p)
	{
		for(q = begin;q<end;++q)
		{
			if(*q>*(q+1))
			{
				t = *q;
				*q = *(q+1);
				*(q+1) = t;
			}
		}

	}
}

可参考：

练习查找：

int * binaryFind(int *begin,int *end,int n)
{
	int *mid;
	while(begin <= end)
	{
		mid = (end-begin)/2+begin;
		if(*mid>n)
		{
			end = mid-1;
		}else if(*mid < n)
		{
			begin = mid +1;
		}else
		{
			break;
		}
	}
	if(begin <= end)
	{
		return mid;
	}else{
		return NULL;
	}
}

也可用递归的方法进行查找：

int * binaryFindPlus(int *begin,int *end,int n)
{
	int *ret = NULL;
	int *mid;
	mid = (end-begin)/2+begin;

	if(begin > end)
	{
		return NULL;
	}

	if(*mid>n)
	{
		end = mid -1;
		ret = binaryFindPlus(begin,end,n);
	}else if(*mid<n)
	{
		begin = mid +1;
		ret = binaryFindPlus(begin,end,n);
	}else if(*mid = n)
	{
		ret = mid;
	}

	return ret;
}

可参考：

快速排序：

#include<stdio.h>

void swap(int *a,int *b)
{
	int temp = *a;
	*a = *b;
	*b = temp;
}

void printfarray(int *begin,int *end)
{
	while(begin <= end)
	{
		printf("%d ",*begin++);
	}
	putchar('\n');
}

void quickSort(int *begin,int *end)
{
	if(begin >= end)
		return;
	int *p = begin;
	int *q = end;

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

int main(void)
{
	int a[]={4,2,2,7,23,14,34,54,23,4};
	int len = sizeof(a)/sizeof(a[0]);
	
	printfarray(a,a+len-1);
	quickSort(a,a+len-1);
	printfarray(a,a+len-1);

	return 0;
}