
  1 #include <stdio.h>
  2 
  3 int main()
  4 {
  5     int *p;
  6 
  7     printf("%p",p);
  8     printf("%d",*p);
  9                                                                                                                                                                  
 10     return 0;
 11 }


Segmentation fault (core dumped)

因此，我们要对指针进行初始化，让指针有明确的指向：可以指向空指针（不能修改里面的东西）


     int a = 18;
     int *p = &a;||int *p = NULL；


int *p,q;//p是指针类型，q是int型
int *p,*q;//此时定义了两个int*类型的变量p,q;
          //定义的时候*修饰变量名的，表示定义的是指针类型的变量

赋值：


int *p;
p = NULL;//正确，因为p和NULL都是指针类型，直接赋值即
*p = NULL;//错误

指针作为函数参数：

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

实参：要修改谁，就把谁的地址传过去

值传递：只是实参数据赋值给了形参

地址传递：可以实现被调函数修改主调函数的值

指针加一维数组：

int a[5]：

//一维整型数组

//类型：数组类型int [5]

//值：数组首元素地址--- 常量

数组名a是个常量，即数组首地址，不能改变，所以a不能做自增自减运算a++(x);

谁能代表数组所在空间的首地址？

数组名--即数组首地址元素 a等价&a[0]

a[0]的数据类型 --int型

&a[0]的数据类型---int*类型

如何定义指针指向数组？pp

int *p =a;(等价于int *p = &a[0]);

指针的运算：

int a[5] = {1,2,3,4,5};

int *p = a;

p+n(表示跳过了n个基类型)

*(p+n)==a[i]==*(a+i);


   void printArray(int *a,int len)
   {
       int i = 0;
       int *p = a;
       for(i = 0;i < len; i++)
       {
          printf("a[%d] = %d\n",i,a[i]);
          printf("a[%d] = %d\n",i,*(a+i));
          printf("a[%d] = %d\n",i, *(p+i));
          printf("a[%d] = %d\n",i, *a++);
          printf("a[%d] = %d\n",i,*p++);
      }
  }

指针比较：> >= < <= == !=

指针只能做减法（p-q）

指针之间加法乘法除法都是无效操作

指针实现一维数组逆序：


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

指针实现选择排序：


  void chooseSort(int *begin,int *end)
  {
      int *p = begin;
      int *q = NULL;
  
      for(p = begin; p < end; p++)//第一个依次和后面的相比，要走到倒数第二个
      {
          for(q = p + 1; q <= end; q++ )//要走到最后一个
          {
              if(*p > *q)
              {
                  int temp;
                  temp= *p;
                  *p = *q;
                  *q = temp;
              }
          }
      }
  }

指针实现冒泡排序：


  void bubble(int *begin,int *end)
  {
      int *p = begin;
      int *q = NULL;
  
      for(p = end ; p > begin;p--)//控制趟数
      {
          for(q = begin;q < p;q++)//控制比较次数
          {
              if(*(q+1) < *q)
              {
                  int temp = *q;
                  *q = *(q+1);
                  *(q+1) = temp;
              }
          }                                                                                                                                                                                                 
      }
  }

指针实现插入排序：


  void inserSort(int *begin,int *end)
  {
      int *p = begin;
      int *q = NULL;
  
      for (p = begin+1; p <= end; p++)//第0个直接赋值，从第一个开始判断
      {
          int temp = *p;
          q = p;
          while(q > begin && *(q-1) > temp)//忌q>0
          {
              *q = *(q - 1);
              q--;
          }
          *q = temp;
      }
  }

指针实现一维整型数组二分查找（有序数组前提下）：


  int* binarySort(int *begin,int *end,int n)
  {
     int *mid = NULL;
     int *ret = NULL;
 
     while(begin <= end)
     {
         mid = begin + (end-begin)/2;
         if(*mid > n)
         {
             end = mid - 1;
         }
         else if(*mid < n)
         {
                begin = mid + 1;
         }
         else
         {
             ret = mid;
             break;
         }
     }
         return ret;
 } 
 int main()
 {
     int a[10] = {1,2,3,4,5,6,7,8,9,10};
     int len = sizeof(a)/sizeof(a[0]);
     int n;
     scanf("%d",&n);
     int* ret = binarySort(a,a+len-1,n);
     if(ret == NULL)
     {
         printf("not found\n");
     }
     else
     {
         printf("found  %d\n",*ret);
     }
     return 0；
}

指针实现一维数组快速排序：


 void quickSort(int *begin,int *end)
 {
     int *k = begin;
     int *p = begin;
     int *q = end;
 
     if(begin >= end)
     {
         return;
     }
     while(begin < end)
     {
     while(begin < end && *end >= *k)//右一半找比基准值小的
     {
         end--;
     }
     while(begin < end && *begin <=*k)//左一半找比基准值大的
     {
         begin++;
     }
     int t = *begin;//右边找到比基准值小的数，左边找到比基准值大的数，两者交换位置,重复操 
                                                             //作，直到begin = end;
     *begin = *end;
     *end = t;
     }
     int temp;//交换基准值与begin,end相遇的地方的值，确定一个数正确的位置
     temp = *k;
     *k = *begin;
     *begin = temp;
     quickSort(p,end-1);//左一半递归                                                                                                                                                                       
     quickSort(begin+1, q);//右一半递归
 }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/小惠珠哦/article/detail/968340