您的位置: 首页  >  IT文章  >  Java中数组的几个常用算法：插入算法，删除算法，冒泡排序算法

Java中数组的几个常用算法：插入算法，删除算法，冒泡排序算法

分类: IT文章 • 2022-07-26 19:15:36

前言：

在Java中我们常常会用数组，提到数组就不得不介绍数组中常用到的几个算法。

有插入算法，删除算法，冒泡排序算法等。

在学习这几个数组的算法前，我们先来了解一下关于数组一些基本知识。

数组的基本知识：

数组的定义：数组(Array)是相同数据类型的数据的有序集合。

数组是引用数据类型。

数组的三个特点：

[1]数组长度是确定。数组一旦申请完空间，长度不能发生变化，用length属性访问。

[2]数组的元素都是同一数据类型。

[3]数组是有序的 。每个元素通过下标/索引标记,索引从0开始。

关于内存的空间的一些知识：

内存分为两类:

栈(stack)内存:基本数据类型分配在栈内存，栈内存空间不需要开发者回收，系统会自动回收。栈空间占整个内存空间的比例较小。

堆(heap)内存:引用数据类型分配在堆内存，堆内存一定要开发者通过new 来申请，开发者申请的内存使用完成后一定要回收。jvm中有专门的垃圾回收机制(gc)回收使用完的堆内存。堆空间占整个内存空间的比例较大。

数组的几种声明方法：

例如

（1）int[] arr = new int[5];

　　 arr[0] = 10;
        arr[1] = 20;
        arr[2] = 30;
        arr[3] = 40;
        arr[4] = 50;

 ( 2 ) int[] arr2;
        arr2 = new int[]{10,20,30,30,50};

（3）int[] arr2 = {10,20,30,40,50};

数组的算法：

（1）插入算法：一个数组有序，添加一个元素后，数组依然有序。

代码如下：

 1 import java.util.Scanner;
 2 
 3 public class Test05{
 4     public static void main(String[] args){
 5         //一个数组有序，添加一个元素后，数组依然有序。
 6         int[] arr = {1,3,7,9,10,13,0};
 7         
 8         Scanner input = new Scanner(System.in);
 9         System.out.println("请添加一个数:");
10         int t = input.nextInt();
11         //int t = 8;
12         //（1）找出位置
13         int loc = -1;
14         for(int i = 0;i < arr.length-1;i++){
15             if(arr[i] > t){
16                 loc = i;
17                 break;
18             }
19         }
20         System.out.println("loc=" + loc );
21         //（2）调t的位置
22         if(loc < 0){           //t在最后一位
23             arr[arr.length-1] = t;
24         }else{                         //将loc后面几位数往后移动
25             for(int j = arr.length-1;j>loc;j--){
26                 arr[j]=arr[j-1];
27             }
28             //将t放进去
29             arr[loc] = t;
30         }
31         //检验，遍历数组
32         for(int i = 0;i < arr.length;i++){
33             System.out.print(arr[i]+ "	");
34         }          
35     }
36 }

 

（2）删除算法：一个有序的数组，删除一个元素后依然有序。

代码如下：

 1 import java.util.Scanner;
 2 public class Test06{
 3     public static void main(String[] args){
 4         
 5         //一个有序的数组，删除一个元素后依然有序。
 6         int[] arr = {1,3,5,7,9,10,17,23};
 7         
 8         //删除t
 9         Scanner input = new Scanner(System.in);
10         System.out.println("请输入要删除的数：");
11         int t = input.nextInt();
12         //int t = 3;
13         
14         //(1)找出要删除的数的位置
15         int loc = -1;
16         for(int i = 0;i < arr.length;i++){
17             if(arr[i] == t){
18                 loc = i;
19                 break;
20             }
21         }
22         
23         //(2)移动元素
24         if(loc < 0){
25             System.out.println(t+"不在数组中");
26         }else{
27             for(int j = loc;j < arr.length-1;j++){
28                 arr[j] = arr[j+1];
29             }
30         }
31         //最后一个元素置0
32         arr[arr.length-1] = 0;
33         //检验，遍历数组
34         for(int i = 0;i < arr.length;i++){
35             System.out.print(arr[i] + "	");
36         }
37     }
38 }

（3）冒泡排序算法作用：将一个无序的数组排列成有序的数组

代码如下：

 1 public class Test07{
 2     public static void main(String[] args){
 3         //冒泡排序算法：用于将无序的数组排列成有序的
 4         int[] arr = {3,2,1,4,7,5,9};
 5         int temp = 0;
 6         // 外层循环控制趟数
 7         for(int i=0;i<arr.length;i++){
 8             for(int j = 0;j < arr.length-1-i;j++){  //内层循环控制两两交换
 9                 if(arr[j] > arr[j+1]){
10                     temp = arr[j];
11                     arr[j] = arr[j+1];
12                     arr[j+1] = temp;
13                 }
14             }
15         }
16         //验证,遍历数组
17         for(int i = 0;i < arr.length;i++){
18             System.out.print(arr[i]+"	");
19         }
20     }
21 }

相关推荐