11.29作业 冒泡排序 函数完成对数组的操作 交换数组

本文详细介绍了如何在C语言中实现冒泡排序算法,以及如何操作整型数组,包括初始化为全0,打印数组元素,数组逆置,以及交换两个数组的内容。

//冒泡排序 实现一个对整形数组的冒泡排序

//从大到小排列

#include <stdio.h>

int main()

{

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

 int temp;

 int len;

 int i,j;



 len=sizeof(a)/sizeof(a[0]);

for (i=0; i<=len-1; i++)

 {

 for (j=i; j<=len-1; j++) //1 2

 {

 if (a[i]<a[j])//

 {

 temp=a[j];

 a[j]=a[i];

 a[i]=temp;

}

 }

 }

 for (i=0; i<=len-1;i++)  

{  printf(" %d",a[i]);

}

return 0;

}

//创建一个整形数组,完成对数组的操作

 值得注意的一点:c语言sizeof的重要用途之一就是求数组长度,但是sizeof必须在数组定义的位置使用。不能作为参数传入函数并在函数中使用sizeof;否则会求得是指针的大小。

//实现函数init() 初始化数组为全0

//实现print()  打印数组的每个元素

//实现reverse()  函数完成数组元素的逆置。

//要求:自己设计以上函数的参数,返回值。

#include <stdio.h>



void intt(int arr[],int len)

{ int i;



  for(i=0;i<len;i++)

  {

    arr[i]=0;

  }

}

void print(int arr[],int len)

{

  int i;

  for(i=0;i<len;i++)

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

  }

  printf("\n");

}

void reverse_string(int arr[],int len)


{

  int left = 0;

  int right = len - 1;

  while (left < right)

  {
        //交换

    char tmp = arr[left];

    arr[left] = arr[right];

    arr[right] = tmp;

    left++;

    right--;

  }

}



int main()

{

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

 int len=sizeof(a)/sizeof(a[0]);

 print(a,len);

 reverse_string(a,len);

 print(a,len);

 intt(a,len);

 print(a,len);

return 0;

}

//交换数组

将数组A中的内容和数组B中的内容进行交换。(数组一样大)

#include <stdio.h>
#include <stdlib.h>
int main()
{
	int a[5] = {1,2,3,4,5};
	int b[5] = {88 ,90,23,63,2};
	int c[5];
	int i,j;
	for (i=0 ; i < 5; i++)
	{
		c[i] = a[i];
		a[i] = b[i];
		b[i] = c[i];
	}
	printf("数组a是:\n");
	for (i = 0; i < 5; i++)
	{
		printf("%d\n", a[i]);
	}
	printf("数组b是:\n");
	for (i = 0; i < 5; i++)
	{
		printf("%d\n", b[i]);
	}
 return 0;

基于径向基函数神经网络RBFNN的自适应滑模控制学习(Matlab代码实现)内容概要:本文介绍了基于径向基函数神经网络(RBFNN)的自适应滑模控制方法,并提供了相应的Matlab代码实现。该方法结合了RBF神经网络的非线性逼近能力和滑模控制的强鲁棒性,用于解决复杂系统的控制问题,尤其适用于存在不确定性和外部干扰的动态系统。文中详细阐述了控制算法的设计思路、RBFNN的结构与权重更新机制、滑模面的构建以及自适应律的推导过程,并通过Matlab仿真验证了所提方法的有效性和稳定性。此外,文档还列举了大量相关的科研方向和技术应用,涵盖智能优化算法、机器学习、电力系统、路径规划等多个领域,展示了该技术的广泛应用前景。; 适合人群:具备一定自动控制理论基础和Matlab编程能力的研究生、科研人员及工程技术人员,特别是从事智能控制、非线性系统控制及相关领域的研究人员; 使用场景及目标:①学习和掌握RBF神经网络与滑模控制相结合的自适应控制策略设计方法;②应用于电机控制、机器人轨迹跟踪、电力电子系统等存在模型不确定性或外界扰动的实际控制系统中,提升控制精度与鲁棒性; 阅读建议:建议读者结合提供的Matlab代码进行仿真实践,深入理解算法实现细节,同时可参考文中提及的相关技术方向拓展研究思路,注重理论分析与仿真验证相结合。
<think> 我们之前计算了在`Double[3]`数组元素全部未实例化(即null)的情况。现在,如果`Double[3]`数组元素全部实例化(即每个数组元素都是一个Double对象),则每个`Double[3]`数组的内存占用会发生变化。 ### 修改点(针对每个`Double[3]`数组): - 之前,每个`Double[3]`数组(元素未实例化)占用32字节(对象头12字节 + 长度4字节 + 3个引用×4字节=28字节,对齐到32字节)。 - 现在,每个`Double[3]`数组的每个元素(即每个Double对象)都被实例化。每个Double对象占用24字节(对象头12字节 + double值8字节 + 对齐填充4字节)。一个`Double[3]`数组有3个这样的对象,所以3个Double对象占用3×24=72字节。 - 同时,数组本身的结构不变,仍然是32字节(注意:数组存储的是引用,即使引用指向了实际对象,数组本身的大小不变,还是32字节)。所以,每个`Double[3]`数组加上其元素的总内存占用为:数组32字节 + 3个Double对象72字节 = 104字节。 ### 重新计算单个键值对的内存占用(值部分): - 值(`HashMap<Integer, Double[3]>`,含40条记录): - `HashMap`实例结构:1,584字节(不变) - `HashMap`的键(Integer对象):40个×24字节=960字节(不变) - `HashMap`的值(`Double[3]`数组):现在每个`Double[3]`数组占用104字节(数组32字节+3个Double对象72字节),40个数组:40×104=4,160字节。 - 值总计:1,584 + 960 + 4,160 = 6,704字节。 - 单个键值对总计:键80字节 + 值6,704字节 = 6,784字节。 ### 总内存占用: - 键值对内容:3000 × 6,784 = 20,352,000字节。 - ConcurrentHashMap结构:122,432字节(不变)。 - 总计:20,352,000 + 122,432 = 20,474,432字节(约19.53 MB)。 ### 关键说明: - 与之前未实例化相比,总内存从11.29MB增加到了19.53MB,增加了约8.24MB(因为每个`Double[3]`数组多出了72字节,40个数组多出2,880字节,再乘以3000条数据,共8,640,000字节,即8.24MB)。 - 注意:这里没有考虑Integer对象和Double对象的缓存(如Integer缓存了-128~127,但这里我们假设都是新创建的Integer对象,且不在缓存范围内)。 §§相关问题§§ 1. 如果使用基本类型数组(如`double[3]`)替代`Double[3]`,每个`double[3]`数组的内存占用是多少? 2. 在`HashMap`中,如果键(Integer)使用自动装箱,且数值在缓存范围内(如-128~127),内存占用会有何变化? 3. 当`Double[3]`数组元素全部实例化时,垃圾回收的频率是否会显著增加?为什么? 4. 在多层嵌套的集合结构中,如何设计数据结构以减少内存碎片? 5. 如果实际数据中,部分`Double[3]`数组的元素为null,部分被实例化,如何动态估算内存占用? </think> ### 内存占用更新(基于 **`Double[3]` 数组元素全部实例化**) 在 `ConcurrentHashMap<String, HashMap<Integer, Double[3]>> map` 中,若每个 `Double[3]` 数组的 **3 个元素全部实例化**(即每个元素都是 `Double` 对象),其他条件不变(3000 条主键,每个 `HashMap` 含 40 条记录)。以下是更新后的内存计算(基于 **64位JVM开启指针压缩**): #### 1. **单个键值对的内存占用变化** - **键(String)**:80 字节(不变)。 - **值(`HashMap<Integer, Double[3]>`)**: - `HashMap` 实例结构:1,584 字节(不变)。 - `Integer` 键对象:40 × 24 字节 = **960 字节**(不变)。 - **`Double[3]` 数组**(元素全部实例化): - 数组结构:32 字节(对象头 12 字节 + 长度 4 字节 + 3 个引用 × 4 字节 + 填充 4 字节)。 - 元素对象:3 个 `Double` × 24 字节(对象头 12 字节 + `double` 值 8 字节 + 填充 4 字节)= **72 字节**。 - **每个 `Double[3]` 总计**:32 + 72 = **104 字节**。 - 40 个数组:40 × 104 = **4,160 字节**。 - **值总计**:1,584(HashMap) + 960(Integer) + 4,160(Double数组及元素) = **6,704 字节**。 - **单个键值对总计**:80 + 6,704 = **6,784 字节**。 #### 2. **ConcurrentHashMap 结构占用** - 不变:32(实例) + 96,000(Node) + 16,400(桶数组) + 10,000(其他) = **122,432 字节**。 #### 3. **总内存占用** - **键值对内容**:3000 × 6,784 字节 = **20,352,000 字节**。 - **总计**:20,352,000 + 122,432 = **20,474,432 字节**(约 **19.53 MB**)。 #### 对比与关键结论 - **与未实例化的差异**: | 场景 | 总内存占用 | 增加幅度 | |---------------------|------------|----------| | `Double[3]` 元素未实例化 | 11.29 MB | - | | `Double[3]` 元素全实例化 | 19.53 MB | +73% | - **主要开销来源**: - 实例化的 `Double` 对象:每个占用 24 字节(对象头占 50%)。 - 多层嵌套结构:`ConcurrentHashMap` → `HashMap` → `Double[3]` → `Double` 导致内存放大。 - **优化方向**: ```java // 方案1:使用基本类型数组(直接存储 double) ConcurrentHashMap<String, HashMap<Integer, double[3]>> map; // 每个 double[3] 仅占 32 字节(无对象头,无引用开销) // 方案2:减少嵌套层级(例如合并键) ConcurrentHashMap<String, double[3][40]> map; // 直接二维数组存储 ```
评论 1
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值