数组易错题与课堂小结

5. 写1个函数返回指定的数据在数组中的下标.

  比如:

   int arr[3] = {10,20,30,50};

  找出这个数组中指定的元素的下标. 数组只是举个例子,你需要通过参数让调用者传递进来.

  如果不存在这个数据则返回-1;

 

#include <stdio.h>

 

 

int getFan(intarr[],int length,intnum){

 

    for (int i = 0;i < length; i++) {

       if (arr[i] == num ) {

           return i;

       }

    }return -1;

}

int main(intargc, const char* argv[]) {

    /*intarr[]= {2,34,45,67,78,23,34};

   int length = sizeof(arr)/sizeof(int);

   for (int i = 0; i < length - 1; i++) {

       for (int j = 0; j < length - 1 - i; j++) {

           if (arr[j] > arr[j+1]) {

//               int temp = arr[j];

//               arr[j] = arr[j+1];

//               arr[j+1] = temp;

               arr[j] = arr[j] ^ arr[j+1];

               arr[j+1] = arr[j] ^ arr[j+1];

               arr[j] = arr[j] ^ arr[j+1];

           }

       }

   }for (int i = 0 ; i < length; i++) {

       printf("%d  ",arr[i]);

   }*/

    

    /*5.写1个函数 返回指定的数据在数组中的下标.

    比如:

   int arr[3] = {10,20,30,50};

    找出这个数组中指定的元素的下标. 数组只是举个例子,你需要通过参数让调用者传递进来.

    如果不存在这个数据则返回-1;*/

    int arr[4] = {10,20,30,50};

    int length = sizeof(arr)/sizeof(int);

    int num;

    printf("请输入一个数据\n");

    scanf("%d",&num);

    int res = getFan(arr,length,num);

    printf("%d\n",res);

 

 

2. 有1个整型数组,请自己设计算法将这个数组中的元素进行翻转(此题选作*****)

比如: 有数组 int arr[5] = {10,11,3,45,6};

将元素的值设置为翻转        {6,45,3,11,10}

 

 int arr[5] = {10,11,3,45,6};

    int length = sizeof(arr)/sizeof(int);

    for (int i = 0; i < length - 1; i++) {

       for (intj = 0 ; j < length-1-i; j++) {

           arr[j] = arr[j]^arr[j+1];

           arr[j+1] = arr[j]^arr[j+1];

           arr[j] = arr[j]^arr[j+1];

       }

    }for (int i = 0;i < length; i++) {

       printf("%d ",arr[i]);

    }

    

  *************************************************

    

    for (int j = 0;j < length/2; j++) {

       arr[j] = arr[j]^arr[length-1-j];

       arr[length-1-j] = arr[j]^arr[length-1-j];

       arr[j] = arr[j]^arr[length-1-j];

    }for (int i = 0;i < length; i++) {

       printf("%d ",arr[i]);

    }

    return 0;

 

 

第一种方法里用冒泡排序的方法做，但是不对其大小进行对比；

第二种方法对数组进行一分为二，以免遍历到后面将前面已经换好的数据进行二次对换造成数据错误；

 

数组元素其实就是一个普通的变量，普通变量可以干什么，那么数组元素也可以干什么；

声明数组：

数组类型     数组名[数组长度]；

声明数组时，必须要有数组长度，但是作为参数时可以不写长度，长度可以另设一参数。

谨记：

调用一个局部变量中的值时，若在另一个函数中发生变化，并不影响，函数与函数之间的变量是相互独立的，但数组除外（是数组 不是数组元素）

 

换而言之，除了数组之外都是值传递；

数组是引用传递：形参发什么变化会直接影响到实参。

 

 

例：

 

#include <stdio.h>

 

 

void test(int num){//接收int类型参数的函数

    

    num =200;

}

 

void test2(intnums[]){

    

    nums[0]= 300;

}

 

int main(intargc, const char* argv[]) {

    

    int nums[5] = {10,20,30,40,50};

    

    test(nums[0]); //传递的是数组元素，是值传递，因为数组元素就可以理解为普通变量

    

    printf("%d\n",nums[0]);//10

 

   test2(nums); //传递数组，是引用传递

    printf("nums[0]=%d\n",nums[0]);//300

    

    return 0;

}

计算数组长度：

 

Intlength = sizeof(arr)/sizeof(int);

 

就是写一个函数，这个函数的功能是用来打印数组中的每个元素的

 

 

 注意：函数内是无法计算出传进来的数组的真实长度的

 

 

 以后如果要把数组作为函数的参数传递进去，那么必须再加一个参数，这个参数是用来传递数组长度的

 

 

冒泡排序：

 

详解版

其实就是把一个数组的元素，按照从小到大（从大到小）的顺序，重新排列起来，这种排序就叫冒泡排序

 

    int nums[5] = {3,2,6,5,9};

 

    //经过排序后

    下标0的元素变成了 2

    下标1的元素变成了 3

    下标2的元素变成了 5

    下标3的元素变成了 6

    下标4的元素变成了 9

 

    {2，3，4，6，9}

 

 核心思想：

        有N轮，每轮从第一个元素开始跟下一个元素进行比较，大的放在后面，小的放在前面

 

下标：   0   1   2   3   4

 ---------------------------

         5   4   3   2  1

  

 第一轮： 4   5   3   2   1    nums[0] > nums[0+1];  int temp = nums[0]; nums[0]=nums[0+1]

         4   3   5   2  1     nums[1] > nums[1+1];

         4   3   2   5  1     nums[2] > nums[2+1];

         4   3   2   1  5     nums[3] > nums[3+1];

                             这一轮比较了4次

 

 第二轮： 3   4   2   1   5   nums[0] > nums[0+1]

         3   2   4   1  5    nums[1] > nums[1+1]

         3   2   1   4  5    nums[2] > nums[2+1]

                             这一轮比较了3次

 

 第三轮：  2  3   1   4   5   nums[0] > nums[0+1];

          2  1   3   4  5    nums[1] > nums[1+1]

                             这一轮比较2次

 

 第四轮：  1  2   3  4   5   nums[0] > nums[0+1];

                            这一轮比较了1次

 

 

 外层循环：循环长度-1次

 

 内层循环：循环长度-1-j次

 

*/

 

#include <stdio.h>

 

int main(intargc, const char* argv[]) {

   

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

   

   /*

    //第一轮

    for (int i=0; i<4; i++) {

        

        if(nums[i] > nums[i+1]){

            

            int temp = nums[i];

            

            nums[i] = nums[i+1];

            

            nums[i+1] = temp;

        }

    }

    

    //第二轮

    for (int i=0; i<3; i++) {

        

        if (nums[i] > nums[i+1]) {

            

            int temp = nums[i];

            

            nums[i] = nums[i+1];

            

            nums[i+1] = temp;

        }

    }

    

    //第三轮

    for (int i=0; i<2; i++) {

        

        if (nums[i] > nums[i+1]) {

            

            int temp = nums[i];

            

            nums[i] = nums[i+1];

            

            nums[i+1] = temp;

        }

    }

    

    //第四轮

    for(int i=0;i<1;i++){

        

        if (nums[i] > nums[i+1]) {

            

            int temp = nums[i];

            

            nums[i] = nums[i+1];

            

            nums[i+1] = temp;

        }

    }

    */

   

    //冒泡排序初版

   for (intj=0; j<4; j++) {

       

        for (int i=0; i<4-j; i++) { //j的取值是0,1,2,3  总轮数4 4-0 = 4，4-1=3，4-2=2，4-3=1

           

           if(nums[i]> nums[i+1]){

               

               inttemp = nums[i];

               

               nums[i] = nums[i+1];

               

               nums[i+1] = temp;

           }

       }

   }

   

   

    //遍历数组

   for (inti=0; i<5; i++) {

       printf("%d  ",nums[i]);

   }

   

      return 0;

}