浅谈数组

• 数组的出现，是为了我们方便的去操作多个数据
• 数组，相当于一个容器，可以存储一组，相同数据类型的元素
• 数组既可以存储基本数据类型，也可以存储引用数据类型
• 数组的定义格式

int[] arr=new int[10];
double arr2[]=new double[10];

数组初始化

• Java中的数组必须先初始化然后才能使用
• 所谓初始化：就是为数组中的数组元素分配内存空间，并为每个数组元素赋值
• 初始化的分类：
  • a:动态初始化：只指定长度，由系统给出初始化值
  • b:静态初始化：给出初始化值，由系统决定长度
  • 注意事项：这两种方式，只能使用一种，不能进行动静结合
    动态初始化的格式：
  • 数据类型[] 数组名=new数据类型[数组长度]
  • 数组长度其实就是数组中元素的个数。
    举例：int[] arr=new int[3];定义了一个int类型的数组arr，这个数组可以存放3个int的值。

知识捡漏静态初始化写法

int[] arr=new int[]{10,20,30,40};
//简写方法
double[] arr={3.14，2，56，48};

数组操作：反转

    public static void main(String[] args) {int[] arr={10,80,50,4,5,6};for(int i=0;i<arr.length/2;i++) {int temp=arr[i];arr[i]=arr[arr.length-1-i];arr[arr.length-1-i]=temp;}System.out.println(Arrays.toString(arr));}

二维数组

数据类型[][] 变量名= new 数据类型[m][n];
m:二维数组有多少个一维数组
n:每个一维数组的元素个数
其他格式;a:数据类型 数组名[][]=new 数据类型[m][n];b:数据类型 数组名[][]=new 数据类型[m][n];

 public static void main(String[] args) {int[][] arr=new int[3][4];System.out.println(arr);//输出二维数组的地址System.out.println(arr[0]);//输出一维数组的地址System.out.println(arr[1]);//给二维数组里面的每个元素int[][] arr2=new int[][]{{20,62,4},{80,30,95},{10,101}};//输出最后一个元素的索引=数组的长度-1System.out.println(arr[arr.length-1][arr[arr.length-1].length-1]);}

数组的练习：根据数组元素查找该元素第一次在数组中出现的索引

方法1：挨个遍历查找法

public static void main(String[] args) {int[] array={10,15,78,96,45,2,16};int index=getIndexByEle(array,2);System.out.println(index);}private static int getIndexByEle(int[] array,int ele) {for(int i=0;i< array.length;i++) {if(ele==array[i]) {return i;}}//没有找到返回-1return -1;}

方法2：二分查找法

• 使用二分查找的条件：
  • 该数组的元素必须有序
• 二分查找的思想：
  • 每一次查找中间的元素，比较大小就能减少一半的元素
    

package 数组;import java.util.Scanner;public class 二分查找 {public static void main(String[] args) {//二分查找，数组必须有顺序，否则，使用普通查找int[] array={10,20,30,40,50,60,70,80,90};System.out.println("请输入你要查找的数字【10~100的整十的整数】：");Scanner scanner=new Scanner(System.in);int ele= scanner.nextInt();scanner.close();int index=getIndexByEle(array,ele);if(index==-1) {System.out.println("不好意思，没有这个元素");}else {System.out.println("元素的索引为："+index);}}private static int getIndexByEle(int[] array, int ele) {int minIndex=0;int maxIndex= array.length-1;int centerIndex=(minIndex+maxIndex)/2;while (minIndex<=array[maxIndex]) {if(ele==array[centerIndex]) {return centerIndex;}else if(ele<array[centerIndex]) {maxIndex= centerIndex-1;}else if(ele>array[centerIndex]) {minIndex=centerIndex+1;}//需重新计算centerIndex的值centerIndex=(minIndex+maxIndex)/2;}//找不到返回-1return -1;}
}

二 数组常见的八大排序方法

2.1 冒泡排序

排序原理：数组元素两两比较，交换位置，大元素往后放，那么经过一轮比较后，最大的元素，就会出现在最大索引处。

图解

举个栗子

package 数组;import java.util.Arrays;
//冒泡排序
public class BubbleSort {public static void main(String[] args) {int[] array={1,15,14,88,99,75,65,999};for(int i=1;i<array.length;i++) {boolean flag=false;for(int j=0;j<array.length-i;j++) {if(array[j]>array[j+1]) {int temp=array[j];array[j]=array[j+1];array[j+1]=temp;flag=true;}if(!flag) {continue;}}}System.out.print(Arrays.toString(array));/*for(int i:array) {System.out.print(i+"\t");}*/}
}

2.2 选择排序

• 排序原理：从0索引处开始，依次和后面的元素进行比较，小的元素往前放，经过一轮比较后，最小的元素就出现在了最小索引处

图解

举个栗子

package 数组;import java.util.Arrays;
//选择排序
public class SelectSort {public static void main(String[] args) {//选择排序原理：从0索引处开始，依次和后面的元素进行比较，// 小的元素往前放，经过一轮比较后，最小的元素就出现在了最小索引处int[] arr={66,88,55,77,99,11};for (int index = 0; index < arr.length; index++) {for (int i = index+1; i < arr.length; i++) {if(arr[index]>arr[i]) {int temp=arr[index];arr[index]=arr[i];arr[i]=temp;}}}System.out.println(Arrays.toString(arr));}
}

2.3 插入排序

• 排序原理：算法思路：直接插入排序，是一种最简单的排序方法.他的基本操作是将一个记录插入
  到一个长度为m的有序表中使之仍保持有序
  49,38,65,97,76.13,27 原始数据
  [49],38.65.97.76.13,27 从1索引开始插入
  [38,49],65,97,76,13,27
  [38.49,65],97,76.13,27
  [38,49,65,97],76,13,27
  [38,49,65,76,97]13,27
  [13,27,38,49,65,76,97],27
  [13,27,38,49,65,76,97]

package 数组;import java.util.Arrays;
//插入排序
public class InsertSort {public static void main(String[] args) {int[] arr={14,89,23,45,87,12,56};for (int i = 1; i < arr.length; i++) {for(int j=i;j>0;j--) {if(arr[j-1]>arr[j]) {int temp=arr[j-1];arr[j-1]=arr[j];arr[j]=temp;}}}System.out.println(Arrays.toString(arr));}
}

2.4 希尔排序【基于插入排序，大大提高插入排序的执行效率】

• 希尔排序又称缩小增量排序。
  • 基本思想：先将原表按增量ht分组，每个子文件按照直接插入法排序。同样，用下一个增量ht/2将文件再分为子文件，再直接插入法排序。直到ht-1时整个文件排好序。
  • 关键：选择合适的增量。
  • 希尔排序算法9-3：可以通过三重循环来实现。
• 1. 希尔排序的核心思想：是选取合理的选取增量，经过一轮排序后，就会让排序大致有序
• 1. 然后再不断的缩小增量，进行插入排序，直到增量为1
• 1. 直接插入排序，其实就是增量为1的希尔排序
     
• 增量的合理选择：最普通的选择就是使用数组长度的一半，这种增量从效率来说不是很好。

正常序列

package 数组;import java.util.Arrays;
//希尔排序
public class ShellsSort {public static void main(String[] args) {//希尔排序思想--快速排序的优化，合理的选取这个增量//第一次这个增量选取数组长度的一半，然后不断减半int[] arr={78,56,12,23,88,50,64,25,78,40,63};for(int h=arr.length/2;h>0;h/=2) {for(int i=h;i<arr.length;i++) {for(int j=i;j>h-1;j-=h) {if(arr[j]<arr[j-h]) {swapValue(arr,j,j-h);}}}}System.out.println(Arrays.toString(arr));}public static void swapValue(int[] arr,int i,int j) {int temp=arr[i];arr[i]=arr[j];arr[j]=temp;}
}

伯努利序列

package 数组;
//希尔排序
public class ShellSort2 {public static void main(String[] args) {//克努特序列//h=1//h=h*3+1 1,4,13,40,121,364int[] arr={78,56,12,23,88,50,64,25,78,40,63};int interval=1;while(interval<=arr.length/3) {interval=interval*3+1;}for(int h=interval;h>0;h=(h-1)/3) {for(int i=h;i< arr.length;i++) {for(int j=i;j>h-1;j-=h) {if(arr[j]<arr[j-h]) {swapValue(arr,j,j-h);}}}}for(int x:arr) {System.out.print(x+"\t");}}public static void swapValue(int[] arr,int i,int j) {int temp=arr[i];arr[i]=arr[j];arr[j]=temp;}
}

2.5 快速排序

原理

• 分治法：比大小，再分区
  • 1.从数组中取出一个数，作为基准数
  • 2.分区：将比这个数大或等于的数全放到他的右边，小于他的数全放到他的左边
  • 3.再对左右区间重复第二步，直到各区间只有一个数

实现思路

• 挖坑填数
  • 1.将基准数控出形成第一个坑
  • 2.由后向前找比他小的数，找到后控出此数填到前一个坑中
  • 3.由前向后找比他大或等于的数，找到后也控出此数填到前一个坑中。
  • 4.再重复执行2，3两步骤。

package 数组;import java.util.Arrays;
//快速排序 挖坑填数
public class QuickSort {public static void main(String[] args) {//定义一个数组int[] arr={13,15,78,-1,22,21,100,56,36,46,98};//调用方法，进行快速排序，传入数组，传入起始位置，传入结束位置Quicksort(arr,0,arr.length-1);System.out.println(Arrays.toString(arr));}public static void Quicksort(int[] arr, int start, int end) {if(start<end) {int index=getIndex(arr,start,end);Quicksort(arr,start,index-1);Quicksort(arr,index+1,end);}}/** 将基准数挖出形成第一个坑*有后向前找比它小的数，找到后挖出此数填到前一个坑中* 有前向后找比它大的数，找到后挖出此数填到前一个坑中* 再重复执行2，3步骤。* */private static int getIndex(int[] arr, int start, int end) {int i=start;int j=end;int x=arr[i];while(i<j) {//有后向前找比它小的数，找到后挖出此数填到前一个坑中while(i<j && arr[j]>=x) {j--;}if(i<j) {arr[i]=arr[j];i++;}//有前向后找比它大的数，找到后挖出此数填到前一个坑中while(i<j && arr[i]<x) {i++;}if(i<j) {arr[j]=arr[i];j--;}}arr[i]=x;//将基准数填入最后一个坑中return i;}
}

2.6 归并排序

• 归并排序（MergeSort）就是利用归并的思想实现排序的方法。
• 它的原理是假设初始序列有N个记录，则可以看成是N个有序的子序列，每个子序列的长度为1，然后两两归并，得到N/2个长度为2或1的有序子序列，再两两归并…如此重复，直至得到一个长度为N的有序序列为止，这种排序方法称为2路归并排序。

package 数组;import java.util.Arrays;//归并排序
public class MergeSort {public static void main(String[] args) {int[] arr={10,20,8,2,-20,-15,55,99,30};//拆分split(arr,0, arr.length-1);//归并merge(arr,1,arr.length/2,arr.length-1);//输出数组System.out.println(Arrays.toString(arr));}private static void split(int[] arr, int startIndex, int endIndex) {//计算中间数组int centerIndex=(startIndex+endIndex)/2;if(startIndex<endIndex) {split(arr,startIndex,centerIndex);split(arr,centerIndex+1,endIndex);merge(arr,startIndex,centerIndex,endIndex);}}private static void merge(int[] arr, int startIndex, int centerIndex, int endIndex) {//定义一个临时数组int[] tempArr=new int[endIndex-startIndex+1];//定义左边数组的起始索引int i=startIndex;//定义右边数组的起始索引int j=centerIndex;//定义临时变量数组的起始索引int index=0;//比较左右两个数组的元素大小，往临时数组中放while(i<centerIndex && j<endIndex) {if(arr[i]<=arr[j]) {tempArr[index]=arr[i];i++;}else {tempArr[index]=arr[j];j++;}index++;}//处理剩余元素while(i<=centerIndex) {tempArr[index]=arr[i];i++;index++;}while(j<endIndex) {tempArr[index]=arr[j];j++;index++;}//将临时数组的值取到原数组if (tempArr.length >= 0) System.arraycopy(tempArr, 0, arr,  startIndex, tempArr.length);}
}

2.7 基数排序

• 基数排序不同于之前所介绍的各类排序。
• 前边介绍到的排序方法或多或少的是通过使用比较和移动记录来实现排序
• 而基数排序的实现不需要进行对关键字的比较
• 只需要对关键字进行“分配与“收集”两种操作即可完成

package 数组;import java.util.Arrays;
//温馨提示：此排序方法不可以对负数进行排序
//基数排序:通过分配再收集的方式进行排序
public class RadixSort {public static void main(String[] args) {int[] arr={1,5,21,32,444,545,124,903,9999};//确定排序轮次//基数排序sortArray(arr);//输出排序后的数组System.out.println(Arrays.toString(arr));}private static void sortArray(int[] arr) {//定义二维数组，放10个桶int[][] tempArr=new int[10][arr.length];//定义统计数组int[] counts=new int[10];//获取数组中的最大值int max=getMax(arr);//获得循环次数，==最大值的位数int len=String.valueOf(max).length();//循环轮次for(int i=0,n=1;i<len;i++,n*=10) {for(int j:arr) {//获取每个位上的数字int bitValue=j/n%10;tempArr[bitValue][counts[bitValue]++]=j;}//取出桶中的元素int index=0;for(int k=0;k<counts.length;k++) {if(counts[k]!=0) {for(int h=0;h<counts[k];h++) {//从桶中取出元素放回原数组arr[index]=tempArr[k][h];index++;}counts[k]=0;//清除上一次统计的数组}}}}private static int getMax(int[] arr) {int temp=arr[0];for(int x:arr) {if(temp<x) {temp=x;}}return temp;}
}

2.7 堆排序

堆排序是利用堆这种数据结构而设计的一种排序算法，堆排序是一种选择排序

• 堆排序的基本思想是
  • 1. 将待排序序列构造成一个大顶堆，此时，整个序列的最大值就是堆顶的根节点
  • 1. 将其与未尾元素进行交换，此时末尾就为最大值
  • 1. 然后将剩余n-1个元素重新构造成一个堆，这样会得到n个元素的次小值
  • 1. 如此反复执行，便能得到一个有序序列了

package 数组;import java.util.Arrays;//堆排序
public class HeapSort {public static void main(String[] args) {//定义一个数组int[] arr={1,0,6,7,2,3,4};//调整成大顶堆的方法//定义开始调整的位置int startIndex=(arr.length-1)/2;//循环开始调for(int i=startIndex;i>=0;i--) {toMaxHeap(arr,arr.length,i);}//经过上面的操作后，已经把数组变成一个大顶堆，把根元素和最后一个元素进行调换for(int i=arr.length-1;i>0;i--) {int temp=arr[0];arr[0]=arr[i];arr[i]=temp;//换完之后，再把剩余的元素调成大队堆toMaxHeap(arr,i,0);}System.out.println(Arrays.toString(arr));}/**** @param arr 要调整的数组* @param size 调整的元素个数* @param index 从哪里开始调整*/private static void toMaxHeap(int[] arr, int size, int index) {//获取左右子节的索引int leftNodeIndex=index*2+1;int rightNodeIndex=index*2+2;//查找最大节点所对应的索引int maxIndex=index;//leftNodeIndex<size  rightNodeIndex<size ——防止下标越界if(leftNodeIndex<size && arr[leftNodeIndex]>arr[maxIndex]) {maxIndex=leftNodeIndex;}if(rightNodeIndex<size && arr[rightNodeIndex]>arr[maxIndex]) {maxIndex=rightNodeIndex;}//来调换位置if(maxIndex!=index) {int temp=arr[maxIndex];arr[maxIndex]=arr[index];arr[index]=temp;//调换完之后，可能会影响到下面的子树，不是大顶堆，所以还需要再次调换toMaxHeap(arr,size,maxIndex);}}
}

Java数组与八大排序相关推荐

1. java数组元素的排序_java学习之数组元素排序，冒泡排序和选择排序

   java学习之数组元素排序 选择排序 *返回值类型 void *参数列表 int[] arr * 分析:选择排序 * 第一次arr[0]与arr[1-4]比较,总共比较4次 * 第二次arr[1]与a ...

2. java 数组和List排序方式汇总

   前言 在工作中使用java, 需要存储一列数据时,脑子里只剩下List一种数据类型了--因为工作场景,很多时候数据个数是位置的,那为了不会有数据溢出或是节省存储空间,List类型是最方便的. 然而,刷 ...

3. java数组给名字排序_用Java给数组排序

   public class BubbleDemo { public static void main(String[] args) { int arr[]={1,3,5,7,2,4,6,8,9}; bu ...

4. 距离矢量路由算法的java代码_八大排序算法比较（附Java代码）

   冒泡排序 /*** 冒泡排序 比较好理解* 两两相比 较大的放后面* 时间复杂度O(n^2)*//*** 改进前的冒泡排序算法进行100,000数据排序运行时间为:3829ms* 优化后的冒泡排序算法 ...

5. Java数据结构之八大排序算法

   目录 一.排序算法的介绍 1.排序算法 2.算法时间的频度 时间频度 3.时间复杂度 4.常见的时间复杂度 5.平均时间复杂度和最坏时间复杂度 6.空间复杂度 二.冒泡排序 1.基本介绍 2.模拟冒泡 ...

6. Java八大排序详解及源码

   今天介绍一下java中的八大排序,首先看一下这八种排序之间的关系: 排序目录 1. 直接插入排序 1.1基本思想 1.2实例 1.3实现代码 1.4运行结果 2.希尔排序(最小增量排序) 2.1基本思 ...

7. java 快排_八大排序-快速排序（搞定面试之手写快排）

   概要 快速排序由C. A. R. Hoare在1960年提出,是八大排序算法中最常用的经典排序算法之一.其广泛应用的主要原因是高效,核心算法思想是分而治之.快速排序经常会被作为面试题进行考察,通常的考 ...

8. 八大排序算法的java实现

   八大排序算法的java实现 有时间再贴算法分析图 JDK7的Collections.sort()的算法是TimSort, 适应性的归并排序, 比较晦涩难懂, 这里没有实现 public class m ...

9. 八大排序:Java实现八大排序及算法复杂度分析

   目录 QUESTION:八大排序:Java实现八大排序及算法复杂度分析 ANSWER: 一:冒泡排序 1.算法分析 2.时间复杂度分析 3.代码 二:选择排序 1.算法分析 2.时间复杂度分析 3.代 ...

最新文章

1. 检测jQuery.js是否已加载的判断代码
2. python程序开发入门_Python开发入门14天集训营-第一章
3. ML：MLOps系列讲解之《基于ML的软件的三个层次之02 Model： Machine Learning Pipelines——2.5 Different forms of ML workfl》解读
4. 惠普服务器显示灯闪红灯,惠普打印机指示灯闪烁什么意思? 惠普2130打印机故障灯大全图解...
5. ***关于WP的邮件无法发送问题的总结（原创）
6. 从Hotspot JIT编译器打印生成的汇编代码
7. 数据结构铁轨问题_每天5分钟用C#学习数据结构（20）图 Part 1
8. Python面试题大全（五）：测试、大数据、数据结构、架构
9. cyber atomic hash map
10. oracle hwm的位置,Oracle 高水位(HWM)教程(2)
11. bit是python最快的bitcoin库_新的Bitcoinpython节点比以前的Python库快100倍
12. 【一分钟知识】依存句法分析
13. W3CSchool CHM API 帮助文档（全）
14. B-树、B+树、B*树
15. 【笨嘴拙舌WINDOWS】Dj,oh!nonono,It is about DC
16. 我模仿了一个自助装机的页面，可是有一个功能一直实现不了。请求高手帮我看看。
17. 配置全局使用的scss样式公用样式函数（后台框架整体颜色改变）
18. 白浩然计算机学院,信息数理学院2015年上半年团员推优汇总表.doc-附件：.doc
19. C语言求一元二次方程的根，这题很简单嘛？看看这种想法很惊奇！
20. LInux的网络设置之（Bridged）桥接模式

热门文章

1. 关于电影主题HTM5网页设计作业成品——千与千寻在线电影(9个页面) HTML+CSS+JavaScript
2. postgresql 连接超时_解决PostgreSQL 执行超时的情况
3. 基于php后台的购物商城微信小程序的设计与实现
4. Direct3D 12——学习——初始化D3D——2——创建D3D驱动D3D12CreateDevice
5. TCPUDP 常见的错误码
6. 一道数量遗传学题：如何计算育种值
7. CSDN开发者周刊：互联网公司接连上演反腐风暴，GitHub 公布了托管平台与美国贸易管制的相关细节！
8. PJzhang:查看你的微信、QQ、新浪微博都授权给过谁
9. MySQL-8.0.26-winx64安装时出现服务正在启动，服务无法启动解决方法
10. 数据库备份的两种方法