精华内容
下载资源
问答
  • 将一个5×5的数组中的最大值放到数组的中心位置 分析:遍历数组,找到最大的元素,然后将该元素中心位置的元素交换位置 #include #include #include using namespace std; int main( void) { void ...

    将一个5×5的数组中的最大值放到数组的中心位置

    分析:遍历数组,找到最大的元素,然后将该元素与中心位置的元素交换位置

    #include<iostream>
    #include <stdlib.h>
    #include <time.h>
    using namespace std;
    int main( void)
    {
    	 void changeArrayData(int *arrayAddress1, int *arrayAddress2);//声明交换元素的函数·
    	 int array[5][5] = {0};
    	 int i = 0, j = 0;
    	 int *arrayMax = 0;
    	 /*给数组赋值*/
    	 srand((unsigned long)time(0));//初始化rand函数
    	 while(i <25){
    		   *(*array + i++) = rand()%100;//100以内的随机数
    	 }
    	 i = 0;
    	 arrayMax = array[0];
    	 while(++i < 25)
    	 {
    		  if(*(*array + i) > *arrayMax)//找最大值
    		   arrayMax = *array + i;
    	 }
    	 if(arrayMax != array[2] + 2)
    	 {
    		  changeArrayData(arrayMax, array[2] + 2);//交换最大值
    	 }
    	 /*输出数组*/
    	 for(i = 0; i < 5; i++)
    	 {
    		  for(j = 0; j < 5; j++)
    		  cout<<*(*(array+i)+j)<<"\t";
    		  cout<<endl;
    	 }
    	 cout<<endl;
    	 return 0;
    }
    /******************************************************
     函数功能:    交换两个整形地址单元的值
    ******************************************************/
    void changeArrayData(int *arrayAddress1, int *arrayAddress2)
    {
        int temp = 0;
        temp = *arrayAddress1;
        *arrayAddress1 = *arrayAddress2;
        *arrayAddress2 = temp;
    }

    运行界面:


    代码分析:

    使用rand函数对数组赋初值,然后通过“打擂台”的方法,遍历数组的所有元素,找到最大的元素。

    然后把arrayMax获取最大元素的地址,将arrayMax和中间的元素(array[2][2])的地址传递给函数changeArrayData,进行位置的变换。

    将一个5×5的数组中的最大值放到数组的中心位置,将最小值放到数组的第一个元素的位置。

    #include<iostream>
    #include <stdlib.h>
    #include <time.h>
    using namespace std;
    int main( void)
    {
    	 void changeArrayData(int *arrayAddress1, int *arrayAddress2);
    	 int array[5][5] = {0};
    	 int i = 0, j = 0;
    	 int *arrayMax =*(array +2)+2, *arrayMin=*(array);
    	 /*给数组赋值*/
    	 srand((unsigned long)time(0));
    	 while(i <25){
    		   *(*array + i++) = rand()%100;//100以内的随机数
    	 }
    	 i = 0;
    	 while(++i < 25)
    	 {
    		  if(*(*array + i) > *arrayMax)//找最大值
    		   arrayMax = *array + i;
    		  if(*(*array + i) < *arrayMin)//找最小值
    		   arrayMin = *array + i;
    	 }
    	 if(arrayMax != array[2] + 2)
    	 {
    		  changeArrayData(arrayMax, array[2] + 2);//交换最大值
    	 }
    	 if(arrayMin != array[0] )
    	 {
    		  changeArrayData(arrayMin, array[0]);//交换最小值
    	 }
    	 /*输出数组*/
    	 for(i = 0; i < 5; i++)
    	 {
    		  for(j = 0; j < 5; j++)
    		  cout<<*(*(array+i)+j)<<"\t";
    		  cout<<endl;
    	 }
    	 cout<<endl;
    	 return 0;
    }
    /******************************************************
     函数功能:    交换两个整形地址单元的值
    ******************************************************/
    void changeArrayData(int *arrayAddress1, int *arrayAddress2)
    {
    	 int temp = 0;
    	 temp = *arrayAddress1;
    	 *arrayAddress1 = *arrayAddress2;
    	 *arrayAddress2 = temp;
    }

    运行界面:



    代码分析:
    arrayMax用来获取数组中最大的元素的地址,然后通过changeArrayData函数和a[2][2]交换位置;
    arrayMin用来获取数组中最小的元素的地址,然后通过changeArrayData函数和a[0][0]交换位置。


    将一个5×5的数组中的最大值放到数组的中心位置,四个角分别放4个最小的元素。


    #include<iostream>
    #include <stdlib.h>
    #include <time.h>
    using namespace std;
    int main( void)
    {
    	 void changeArrayData(int *arrayAddress1, int *arrayAddress2);
    	 int Array[5][5] = {0};
    	 int i = 0, j = 0;
    	 int *arrayMax =*(Array +2)+2, *arrayMin[4]={Array[0],Array[0]+4,Array[4],Array[4]+4};
    	 /*给数组赋值*/
    	 srand((unsigned long)time(0));
    	 while(i <25){
    		   *(*Array + i++) = rand()%100;//100以内的随机数
    	 }
    	 i = 0;
    	 while(++i < 25)
    	 {
    		  if(*(*Array + i) > *arrayMax)//找最大值
    		   arrayMax = *Array + i;
    		  if(*(*Array + i) < *arrayMin[0])//找最小值
    		   arrayMin[0] = *Array + i;
    	 }
    	 if(arrayMax != Array[2] + 2)
    	 {
    		  changeArrayData(arrayMax, Array[2] + 2);//交换最大值
    		  arrayMax=Array[2]+2;
    	 }
    	 if(arrayMin[0] != Array[0] )
    	 {
    		  changeArrayData(arrayMin[0], Array[0]);//交换最小值
    		  arrayMin[0]=Array[0];
    	 }
    	 i=1;
         while(i++<25){
    	 for(j=1;j<4;j++){
    		             if(*(*Array + i)>*arrayMin[j-1]&&*(*Array + i)<*arrayMin[j])
    		             changeArrayData(*Array+i,arrayMin[j]);//如果数组中的元素值,大于arrayMin[j-1],小于arrayMin[j],就将该元素与arrayMin指向的元素交换位置
    			 }
    	}
    
    	 /*输出数组*/
    	 for(i = 0; i < 5; i++)
    	 {
    		  for(j = 0; j < 5; j++)
    		  cout<<*(*(Array+i)+j)<<"\t";
    		  cout<<endl;
    	 }
    	 cout<<endl;
    	 return 0;
    }
    /******************************************************
     函数功能:    交换两个整形地址单元的值
    ******************************************************/
    void changeArrayData(int *arrayAddress1, int *arrayAddress2)
    {
    	 int temp = 0;
    	 temp = *arrayAddress1;
    	 *arrayAddress1 = *arrayAddress2;
    	 *arrayAddress2 = temp;
    }

    运行界面:



    代码分析:

    将最大值放到中间的思路不变,然后将四个最小值的地址放到四个指针数组中。
    通过遍历获取最小值的地址,并放置到arrayMin[0]中。

    然后,再次遍历数组中的所有元素,和arrayMin数组中的元素相比较:

              i=1;
             while(i++<25){
    	    for(j=1;j<4;j++){
    		             if(*(*Array + i)>*arrayMin[j-1]&&*(*Array + i)<*arrayMin[j])
    		             changeArrayData(*Array+i,arrayMin[j]);//如果数组中的元素值,大于arrayMin[j-1],小于arrayMin[j],就将该元素与arrayMin指向的元素交换位置
    			   }
    	}

    变量数组中的元素,分别和arrayMin数组中的元素相比较,如果数组中的元素值,大于arrayMin[j-1],小于arrayMin[j],就将该元素与arrayMin指向的元素交换位置。

    然后就可以实现最小的四个元素分别在四个角上。

    展开全文
  • 数组中相邻两个数分在一组, 每次比较两个相邻数,将较大值交换至这两个数左边,较小值放于右边。 对大者组扫描一次找出最大值,对小者组扫描一次找出最小值。 代码(略) 比较1.5N-2次,但需要改变数组...

    解法一:

    扫描一次数组找出最大值;

    再扫描一次数组找出最小值。

    代码(略) 

    比较次数2N-2

     

    解法二:

    将数组中相邻的两个数分在一组, 每次比较两个相邻的数,将较大值交换至这两个数的左边,较小值放于右边。

    对大者组扫描一次找出最大值,对小者组扫描一次找出最小值。

    代码(略)

    比较1.5N-2次,但需要改变数组结构

     

    解法三:

    每次比较相邻两个数,较大者与MAX比较,较小者与MIN比较,找出最大值和最小值。

    代码如下:

    void GetMaxAndMin(int* arr, int len, Result* rlt)
    {
    for(int i=2; i< len-1; i=i+2)
    {
    if(NULL==arr[i+1])
    {
    if(arr[i]>rlt->Max)
    rlt
    ->Max=arr[i];
    if(arr[i]<rlt->Min)
    rlt
    ->Min=arr[i];
    }
    if(arr[i]>arr[i+1])
    {
    if(arr[i]>rlt->Max)
    rlt
    ->Max=arr[i];
    if(arr[i+1]<rlt->Min)
    rlt
    ->Min=arr[i+1];
    }
    if(arr[i]<arr[i+1])
    {
    if(arr[i+1]>rlt->Max)
    rlt
    ->Max=arr[i+1];
    if(arr[i]<rlt->Min)
    rlt
    ->Min=arr[i];
    }
    }
    }

    比较次数1.5N-2,但是不用改变原数组结构。

     

    解法四:

    分治法,算出前N/2个数的MAX和MIN,再算出后N/2个数的MAX和MIN。代码如下:

    void GetMaxAndMin1(int* arr, int len, Result* rlt)
    {
    if(len==0||!arr)
    return;
    if(len==1)
    {
    if(arr[0]>rlt->Max)
    rlt
    ->Max=arr[0];
    if(arr[0]<rlt->Min)
    rlt
    ->Min=arr[0];
    return;
    }
    GetMaxAndMin(arr, len
    /2, rlt);
    GetMaxAndMin(
    &arr[len/2], len-len/2, rlt);
    }

    需比较1.5/N-2次。

     

    试验代码:

    #include "stdio.h"
    #include
    "stdlib.h"

    #define LEN(arr) sizeof(arr)/sizeof((arr)[0])

    struct Result{
    int Max;
    int Min;
    };

    int main()
    {
    int test[10]={3,2,4,1,5,2,7,9,0};
    Result
    * rlt = (Result*)malloc(sizeof(Result));
    rlt
    ->Max = rlt->Min = test[0];
    int len=LEN(test);
    GetMaxAndMin(test, len, rlt);
    printf(
    "Max=%d\nMin=%d\n", rlt->Max, rlt->Min);
    getchar();
    }

     

    转载于:https://www.cnblogs.com/lovell-liu/archive/2011/09/07/2169644.html

    展开全文
  • 数组中的最大值与第一个元素交换,将数组中的最小值与最后一个元素进行交换** public class MaxAndMin{ public static void main(String[] args){ int[] arr={2,5,66,48,2156,45,545,5,6,3,54}; System.out....

    **课堂案例:
    将数组中的最大值与第一个元素交换,将数组中的最小值与最后一个元素进行交换**

    public class MaxAndMin{
        public static void main(String[] args){
            int[] arr={2,5,66,48,2156,45,545,5,6,3,54};
            System.out.println("交换之前:");
            print(arr);
            int max=getMax(arr);//调用最大值方法
            int maxIndex=getIndex(arr,max); //调用最大值索引的方法
            System.out.println("最大值为:"+max+",索引为:"+maxIndex);
            swap(arr,maxIndex,0);
    
            int min=getMin(arr);//调用最小值方法
            int minIndex=getIndex(arr,min); //调用最小值索引的方法
            System.out.println("最小值为:"+min+",索引为:"+minIndex);
    
            System.out.println("\n=====================");
    
            swap(arr,minIndex,arr.length-1);
            System.out.println("交换之后:");
            print(arr);
        }
    
    
        //求最大值的方法
        public static int getMax(int[] arr){
            int max=arr[0];
            for(int i=1;i<arr.length;i++){
                if(arr[i]>arr[0]){
                    max=arr[i];
                }
            }
            return max;
        }
    
        //求最小值的方法
        public static int getMin(int[] arr){
            int min=arr[0];
            for(int i=1;i<arr.length;i++){
                if(arr[i]<arr[0]){
                    min=arr[i];
                }       
            }
            return min;
        }
    
        //求数组中元素角标的方法
        public static int getIndex(int[] arr,int number){
            for(int i=0;i<arr.length;i++){
                if(arr[i]==number){
                    return i;
                }
            }
            return -1;//返回-1代表要查询的数在数组中不存在
        }
    
        //遍历数组的方法
        public static void print(int[] arr){
            for(int i:arr){
                System.out.print(i+"\t");
            }
            System.out.println();
        }
    
        //交换的方法
        public static void swap(int[] arr,int x,int y){ //x,y索引
            int temp=arr[x];
            arr[x]=arr[y];
            arr[y]=temp;
        }
    
    }
    展开全文
  • 记得记录一下最大值最小值的位置,方便后边题目要求的交换操作(这里我使用是pmax, pmin) 解答示范 #include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; #include&lt;time.h&gt; ...

    题目来源:大工慕课 链接
    作者:Caleb Sung

    注意事项

    • 记得记录一下最大值最小值的位置,方便后边题目中要求的交换操作(这里我使用的是pmax, pmin)

    解答示范

    #include<stdio.h>
    #include<stdlib.h>
    #include<time.h>
    void main(){
        int i, a[10], max, min, pmax, pmin, tmp; 
        srand(time(NULL));
        for(i=0; i<10; i++){
            a[i] = rand()%100+0;
        }
    
        printf("这十个数分别为:\n");
        for (i=0; i<10; i++){
            printf("%d\t", a[i]);
        }
    
        max = a[0];
        pmax = 0;
        for(i=1; i<10; i++){
            if(a[i] > max){
                max = a[i];
                pmax = i;
            }
        }
        printf("\n\n最大值:\t%d", max);
    
        min = a[0];
        pmin = 0;
        for(i=1; i<10; i++){
            if(a[i] < min){
                min = a[i];
                pmin = i;
            }
        }
        printf("\n最小值:\t%d", min);
    
        tmp = a[0];
        a[0] = a[pmin];
        a[pmin] = tmp;
    
        tmp = a[9];
        a[9] = a[pmax];
        a[pmax] = tmp;
    
        printf("\n\n经过调整过后的十个数分别为:\n");
        for (i=0; i<10; i++){
            printf("%d\t", a[i]);
        }
    
    } 
    展开全文
  • 交换JAVA数组中两数

    千次阅读 2010-05-25 09:26:00
    关于交换JAVA数组中两数问题 今天在BAIDU看到某楼主发帖,询问该问题,然后自己以为很简答,写了很长时间与楼主效果就是不同。 通过CSDN各位高手指点,略懂...将Array中的最大值与最小值交换位置 package Hamber_Bao
  • 输入一个整数数组(元素个数=10),选出最小值和最后一个元素交换,选出最大值和第一个元素交换,输出处理后的数组。 要求:用函数实现交换,并在交换中使用到指针。输入具体数据可以示例图不相同。 每天都...
  • 题目:输入数组最大的与第一个元素交换,最小的与最后一个元素交换,输出数组。 初看这题,觉得很简单,可实际操作起来,个情况还比较复杂。 后来明确了测试用例,再来研究下: 说明 测试...
  • 1.题目: 假定在矩阵中的最大值和最小值都仅有一 个,编写程序,交换矩阵中最大值与最小值所在的行。 2.具体代码: 3.运行结果:
  • 冒泡排序的思想是按照一定顺序如(左到右,下到上)所有相邻两个数依次比较,第一轮比较完成后,选出第一轮比较的最大值最小值,然后排除这一轮的最大值最小值,在进行第二次比较,依次下去,直到只有一个数,...
  • 数组的排序算法

    2019-10-08 23:27:01
    每次选择所要排序得数组中的最大值(由大到小排序,由小到大排序则选择最小值)的数组元素,将这个数组元组的值与最前面没有排序的数组元素进行交换, 第一次排序之后,最大的数字来到了第一位,再从第二个元素开始找,找到...
  • 数组选择排序算法

    2020-03-06 16:40:35
    通俗的理解就是在数组中,选出最大值或者最小值和数组中的第一个数交换,同理,在剩余数组中再次选出最大值最小值与第二个数交换。直至最后完成数组的升序或降序排序。 2 代码块 public static void main(String[]...
  • 数组的排序算法总结

    2021-01-22 12:07:27
    选择法排序指每次选择所要排序的数组中的最大值(由大到小排序,由小到大排序则选择最小值)的数组元素,将这个数组元素的值与最前面没有进行排序的数组元素的值互换。 下面以数字9、6、15、4、2为例,对这几个数字...
  • 3.输出数组中的最大值及地址; 4.对数组中的数字从小到大进行排序; 5.输出数组中的最小值及地址 6.交换最大值与最小值,并输出; #include<stdio.h> #define N 8 //函数声明 void input(int arr[...
  • ZZULIOJ【1120】最值交换数组

    千次阅读 2017-08-16 15:35:04
    1120: 最值交换 Time Limit: 1 Sec Memory Limit: 128 MB Submit: 4691 Solved:...请写一个程序,先把序列中的最小值与第一个数交换,再把最大值与最后一个数交换。输出转换好的序列。 分别编写两个函数MinIndex
  • 选择法排序是指每次选择索要排序的数组中的最小值(这里是由小到大排序,如果是由大到小排序则需要选择最大值)的数组元素,将这些数组元素的值与前面没有进行排序的数组元素值进行互换 代码实现需要注意的是:声明...
  • 本题要求编写程序,先将输入的一系列整数中的最小值与第一个数交换,然后将最大值与最后一个数交换,最后输出交换后的序列。 注意:题目保证最大和最小值都是唯一的。 输入格式: 输入在第一行中给出一个...
  • 项目使用过程,要求得到一天气温的最大值时间。传进来的是所有天数按时间排序BigDecimal数组,因为每一天数据较小,采用比较简单的冒泡排序。 冒泡排序,考虑到,最大的数在最后那个位置的数交换之前不会被交换...
  • 2020-11-16

    2020-11-16 16:51:58
    数组中交换最大值和最小值最小值与第一位交换最大值与最后一位交换,找到最大值最小值之后,要先交换最大(小)值,不可以一起交换,因为: 当最大值排到第一位时,最小值交换完毕后,最大值所对应下标发生了...
  • 1.获取数组中最大值最小值及其下标 2.将其调换到相应位置 注意事项: 1.避免重复交换 2.考虑特殊情况(如首位极值相反或已对应) 水平有限,望各位在评论区共同讨论。 #include "stdio.h" #include "stdlib.h" ...
  • 实验5一维数组

    2020-11-27 15:11:07
    请写一个程序,把序列中的最小值与第一个数交换最大值与最后一个数交换。输出转换好的序列。 Input 输入包括两行。 第一行为正整数n(1≤n≤10)。 第二行为n个正整数组成的序列。 Output 输出转换好的序列。数据...
  • if(arr[ii]>arr[mx]){ //如果当前值大于数组中的最小值 dtod(mx,ii); //数据交换 mx=colt(z,fi); //重新获取步长内的最小值 }} if(arr[ii]>arr[pi]){ //动态维护本段的最大...
  • C语言程序设计基础OJ练习题(实验六一维数组

    万次阅读 多人点赞 2019-01-17 14:03:21
    一、C语言实验——最值 Time Limit: 1000 ms Memory Limit: 65536 KiB ...请写一个程序,把序列中的最小值与第一个数交换最大值与最后一个数交换。输出转换好的序列。 Input 输入包括两行。 第...
  • 先将二维数组转化为一维数组,做4次冒泡排序之后,数组中最后4位就是4个最小值降序排列,然后将其需要交换的元素交换,然后转化为二维数组;找出其中最大值中心元素交换,输出二维数组。 代码缺陷: 在4次冒泡...
  • 选择排序是指每次选择所需排序数组中的最大值或者最小值(根据排序方式选择,从大到小选最大,从小到大选最小),将这个元素前面没有进行排序的元素交换。 下面以1 4 2 5 9 6这些乱序元素,来表现排序过程。 第...
  • 1457: 最值交换

    2020-12-05 01:19:38
    请写一个程序,先把序列中的最小值与第一个数交换,再把最大值与最后一个数交换。输出转换好的序列。 分别编写两个函数MinIndex()和MaxIndex()来计算最小值下标和最大值下标。 int MinIndex(int a[], int n); //函数...
  • zzulioj1120: 最值交换

    2021-04-23 17:31:58
    请写一个程序,先把序列中的最小值与第一个数交换,再把最大值与最后一个数交换。输出转换好的序列。 分别编写两个函数MinIndex()和MaxIndex()来计算最小值下标和最大值下标。 int MinIndex(int a[], int n); //函数...
  • zzulioj 1120: 最值交换

    2021-02-25 11:44:56
    请写一个程序,先把序列中的最小值与第一个数交换,再把最大值与最后一个数交换。输出转换好的序列。 分别编写两个函数MinIndex()和MaxIndex()来计算最小值下标和最大值下标。 int MinIndex(int a[], int n); //函数...

空空如也

空空如也

1 2 3 4 5 ... 8
收藏数 154
精华内容 61
关键字:

交换数组中的最大值与最小值