我眼中的数组和冒泡排序

一维数组

数组是一个定长的容器，可以放相同类型的数据。
数组中的元素可以是任何数据类型，包括基本数据类型和引用数据类型

专业解释

数组（Array）是一种线性表数据结构。它用一组连续的内存空间，来存储一组具有相同类型的数据。
线性表，顾名思义，线性表就是数据排成像一条线一样的结构。每个线性表上的数据最多只有前和后两个方向。
数组具有连续的内存空间和相同的数据类型

数组的声明

dataType[] arrayName;
注：数组在声明时不能指定数组长度，即dataType[n] arrayName；是不合法的

数组的创建

arrayName = new dataType[n];

动态创建（初始化）

dataType[] arrayName = new dataType[n];

静态创建（初始化）

dataType[] arrayName = new dataType[]{value1,value2,......,valueN};

数组的内存模型

数组的声明即数组变量名存储在栈中，数组的创建在堆中，即在堆中开辟连续的对应数组长度的空间（所有引用类型的创建都在堆中）

所有引用类型的变量名存的都是地址。

数组创建后的初始默认值

引用类型的数组元素默认初始值是null
字符类型的数组元素默认初始值是空格(0对应的字符)
整数类型的数组元素默认初始值是0
浮点数类型的元素默认初始值是0.0
布尔类型的元素默认初始值是false

为什么数组索引值从0开始呢?

从数组存储的内存模型上来看，“下标”最确切的定义应该是“偏移（offset）”。如果用 a 来表示数组的首地址，a[0] 就是偏移为 0 的位置，
也就是首地址，a[k] 就表示偏移 k 个 type_size 的位置，所以计算 a[k] 的内存地址只需要用这个公式：

a[k]_address = base_address + k * type_size

但是，如果数组从 1 开始计数，那我们计算数组元素 a[k] 的内存地址就会变为：

a[k]_address = base_address + (k-1)*type_size
对比两个公式，我们不难发现，从 1 开始编号，每次随机访问数组元素都多了一次减法运算，对于 CPU 来说，就是多了一次减法指令。数组作为非常基础的数据结构，通过下标随机访问数组元素又是其非常基础的编程操作，效率的优化就要尽可能做到极致。所以为了减少一次减法操作，数组选择了从 0 开始编号，而不是从 1 开始。
也有可能是历史原因
C 语言设计者用 0 开始计数数组下标，之后的 Java、JavaScript 等高级语言都效仿了 C 语言，或者说，为了在一定程度上减少 C 语言程序员学习 Java 的学习成本，因此继续沿用了从 0 开始计数的习惯。实际上，很多语言中数组也并不是从 0 开始计数的，比如 Matlab。甚至还有一些语言支持负数下标，比如 Python。

数组与链表的区别

链表适合插入和删除，时间复杂度是O(1),数组支持随机访问，根据下标随机访问的时间复杂度为O(1)。

增强for循环遍历数组

按照数组下标顺序，依次将冒号右边数组中的每个元素赋值给冒号左边的变量，数组长度为for循环的次数
for(数组元素类型 变量名 : 数组名){
语句;
}

编写一个长度为5的整型数组，每个元素赋值为0-10的随机整数，遍历该数组，输出每个元素。
int[] arr = new int[5];
Random r = new Random();
for(int i = 0; i < arr.length; i++){
arr[i] = r.nextInt(10);
}
for(int t : arr){
System.out.println(t);
}

多维数组

数据类型是数组的数组

动态初始化

数组名 = new 数据元素类型[ 行数 ] [ 列数 ] ;
行数不能为空

静态初始化

数组类型 数组名[ ][ ] = new 数据类型[ ][ ] { {元素11，元素12，…} , {元素21，… } }

一维数组冒泡排序

int[] arr = new int[]{4,45,1,13,89,7};
            int temp;
            for(int i = 0; i < arr.length; i++){
                  for(int j = 0; j < arr.length - 1;j++){
                        if(arr[j] > arr[j+1]){
                              temp = arr[j];
                              arr[j] = arr[j+1];
                              arr[j+1] = temp;
                        }
                  }
            }

优化

int[] arr = new int[]{4,45,1,13,89,7};
            int temp;
            boolean flag = false;
            for(int i = 0; i < arr.length; i++){
                  for(int j = 0; j < arr.length - i -1;j++){
                        if(arr[j] > arr[j+1]){
                              temp = arr[j];
                              arr[j] = arr[j+1];
                              arr[j+1] = temp;
                              flag = true;
                        }
                  }
                  //当没有数据交换时，证明数组已排序完成，退出子循环
                  if(!flag){
                        break;
                  }
            }

二维数组冒泡排序（两种方法）

创建二维数组

Random r = new Random();
            int[][] arr = new int[4][6];
            for(int i = 0; i < arr.length; i++){
                  for(int j = 0; j < arr[0].length;j++){
                        arr[i][j] = r.nextInt(100);
                        System.out.print(arr[i][j]+" ");
                  }
                  System.out.println();
            }
            int row = arr.length;
            int column = arr[0].length;

第一种方法

//二维数组转化为一维数组
int[] array = new int[row * column];
for(int i = 0; i < row; i++){
            for(int j = 0; j < column; j++){
                        array[i*column+j] = arr[i][j];
            }
}

//对一维数组进行冒泡排序
int temp;
boolean flag = false;
for(int i = 0; i < array.length; i++){
            for(int j = 0; j < array.length - i -1;j++){
                        if(array[j] > array[j+1]){
                                    temp = array[j];
                                    array[j] = array[j+1];
                                    array[j+1] = temp;
                                    flag = true;
                        }
            }
            if(!flag){
                        break;
            }
}
//输出排序后的一维数组
for(int i : array){
            System.out.print(i + " ");
}
System.out.println();
//将排序后的一维数组转化为二维数组
for(int i = 0; i < row; i++){
            for(int j = 0; j < column; j++){
                        arr[i][j] = array[i*column+j];
            }
}
//输出二维数组
for(int i = 0 ; i < arr.length;i++){
            System.out.println(Arrays.toString(arr[i]));
}

第二种方法


int temp = 0;
            boolean flag = false;
            //所有子数组完成排序需要的冒泡次数总和
            for(int t = 0; t < row * column; t++){
                  //遍历父数组，即第一维数组（行）的遍历
                  for(int z = 0; z < arr.length; z++){
                        //每个数组完成排序需要的冒泡次数
                        for(int i = 0; i < arr[0].length; i++){
                              //遍历子数组，并进行冒泡排序
                              for(int j = 0; j < arr[0].length - 1 -i;  j++){
                                    if(arr[z][j]>arr[z][j+1]){
                                          temp = arr[z][j];
                                          arr[z][j] = arr[z][j+1];
                                          arr[z][j+1] = temp;
                                          flag = true;
                                    }
                              }
                              //当没有数据交换时，证明数组已排序完成，退出子循环
                              if(!flag){
                                    break;
                              }
                        }
                        //输出每组的最大值
                        //System.out.println(arr[z][arr[0].length-1]);
                        //将每组的最大值与下一组的第一个值比较，若大于则交换
                        if(z < arr.length - 1 && arr[z][arr[0].length-1]  > arr[z+1][0]){
                              temp = arr[z][arr[0].length-1];
                              arr[z][arr[0].length-1] = arr[z+1][0];
                              arr[z+1][0] = temp;
                        }
                  }
            }
            //输出二维数组
            for(int i = 0 ; i < arr.length;i++){
                  System.out.println(Arrays.toString(arr[i]));
            }

原文地址：https://blog.51cto.com/13646338/2448934

时间： 2024-08-03 03:43:07

我眼中的数组和冒泡排序的相关文章

数组，冒泡排序，简化

//    int array[] = {3, 2, 6, 9, 8, 5, 7, 1, 4}; //    int count = sizeof(array) / sizeof(array[0]); //    int flag = 1; //    for (int i = 0; i < count - 1 && flag == 1; i++) { //        flag = 0; //        for (int j = 0; j < count - i - 1

「C语言」「算法」数组的冒泡排序

1 #include<stdio.h> 2 #define N 10 3 4 //数组的冒泡排序 5 6 void sort(int b[]){ 7 int i,j; 8 for(i=0;i<N;i++){ 9 for(j=i+1;j<N;j++){ 10 if(b[i]>b[j]){ 11 b[i]^=b[j]; 12 b[j]^=b[i]; 13 b[i]^=b[j]; 14 } 15 } 16 } 17 } 18 19 int main() { 20 int a[N];

数组的冒泡排序

<!DOCTYPE html><html> <head> <meta charset="UTF-8"> <title></title> <script type="text/javascript"> //数组的冒泡排序 arr = [1, 4, 7, 2]; //a = 1, b = 4, c = 7, d = 2 //1. 2. 3. 4 //abcd四个人相遇了,他们要排队,身高

12.数组三--数组的冒泡排序与快速排序

一.冒泡排序 package com.atguigu.java; /* * 数组的冒泡排序的实现 * */ public class BubbleSortTest { public static void main(String[] args) { int[] arr = new int[]{43,32,76,-98,0,64,33,-21,32,99}; //冒泡排序 for(int i = 0;i < arr.length - 1;i++){ for(int j = 0;j < arr.l

数组，冒泡排序

<!DOCTYPE html> <html> <head lang="en"> <meta charset="UTF-8"> <title></title> </head> <body> <script> //求一组数中的所有数的和 和平均值 /* var arr = [10,20,30,10]; var len = arr.length; var sum =

二维数组与冒泡排序

记住数组顺序是从0开始的!!! 记住数组顺序是从0开始的!!! 记住数组顺序是从0开始的!!! 重要的事情说三遍! 二维数组的静态位 一,Arrays.sort(lsz),//排序操作针对于整型数据.如果是char型数据或者其他,则按照unicode的编码顺序排序 二,Arrays.copyOf(lsz , 2),//复制操作可以复制全部或者一部分的长度,上式中就是取前两位数组. Arrays.copyOfRange(lsz, from, to)//复制操作,注意力两点,首先这个段位的长度可以大

例题：青歌赛打分程序。去掉两个最高分，去掉两个最低分，再算平均分。主要学习数组和冒泡排序，什么情况下要定义数组

Console.Write("请输入评委人数:");//输入人数 int renshu = Convert.ToInt32(Console.ReadLine());//人数代入 int[] fenshu = new int[renshu];//定义一个分数的数组,长度为人数 if (renshu >= 5)//去掉连个最高分,去掉两个最低分,所以至少五个人 { for (int i = 0; i < renshu; i++) { Console.Write("请输

【2-28】数组及冒泡排序

一 数组定义:相同数据类型的元素按照一定顺序排列的集合,即把有限个类型相同的变量用同一个名字命名. 作用:方便操作大量数据 注意:数组内元素必须为同一类型:索引下标必须有长度限制,否则返回初始值0 (一)一维数组: (1)数据类型[] 变量名 = new 数据类型[长度]: (2)string[]变量名= new string[] { "字符串a", "字符串b", "字符串c", "字符串d", "字符串e&quo

数组与冒泡排序

1 package shuzu; 2 3 import java.util.Arrays; 4 5 public class ssss { 6 7 public static void main(String[] args) { 8 9 //一维数组 10 11 int myarry [] = new int [5]; 12 13 //索引从0开始 14 15 myarry[0] = 100; 16 17 myarry[2] = 200; 18 19 for(int i =0; i<myarry