数组的常用操作

Posted 2020-10-03 再见残月

一、排序（冒泡排序、选择排序、插入排序）

　　1.冒泡排序

 1 /**
 2   * 对指定的 int 型数组按数字升序进行冒泡排序
 3   * @param a 待排序的数组
 4   */
 5 public static void sortBubble(int[] a) {
 6     int temp;
 7     for (int i = 1; i < a.length; i++) {
 8         for (int j = 0; j < a.length - i; j++) {
 9             if (a[j] > a[j+1]) {
10                 temp = a[j];//三步交换
11                 a[j] = a[j+1];
12                 a[j+1] = temp;
13             }
14         }
15     }
16 }  

 注：若要降序排序，仅需将if()条件里的">"改成"<"即可

　　2.选择排序

 1 /**
 2  * 对指定的 int 型数组按数字升序进行选择排序
 3  * @param a 待排序的数组
 4  */
 5 public static void sortSelection(int[] a) {
 6     int flag;//标记最小值得位置
 7     int temp;//用于交换的中间变量
 8     for (int i = 0; i < a.length; i++) {
 9         flag = i;
10         for (int j = i; j < a.length; j++) {
11             if (a[j] < a[flag]) {
12                 flag = j;
13             }
14         }
15         temp = a[i];//三步交换
16         a[i] = a[flag];
17         a[flag] = temp;
18     }
19 }

 注：若要降序排序，仅需将if()条件里的"<"改成">"即可

　　3.插入排序

 1 /**
 2  * 对指定的 int 型数组按数字升序进行插入排序
 3  * @param a 待排序的数组
 4  */
 5 public static void sortInsertion(int[] a) {
 6     int flag = 0;//标记需要插入的位置
 7     int temp = 0;//存储待插入的数
 8     for (int i = 1; i < a.length; i++) {
 9         temp = a[i];
10         for (int j = i; j > 0; j--) {
11             if (a[j-1] > temp) {
12                 a[j] = a[j-1];
13                 flag = j-1;
14             }else {
15                 flag = j;
16                 break;
17             }
18         }
19         a[flag] = temp;
20     }
21 }

 注：若要降序排序，仅需将if()条件里的">"改成"<"即可

 

二、查找（顺序查找、折半查找）

　　1.顺序查找

 1 /**
 2  * 使用线性搜索法来搜索指定的 int 型数组中搜索指定的值，以获得该的值的位置
 3  * @param a 要搜索的数组
 4  * @param key 要搜索的值 
 5  * @return -如果这个值被找到，则返回该值得索引，否则返回 -1<br>
 6  *         -如果数组中有多个可以匹配的值，则返回第一的值的索引<br>
 7  *         -调用该方法之前不需要对数组进行排序
 8  */
 9 public static int searchLinear(int[] a,int key) {
10     for (int i = 0; i < a.length; i++) {
11         if (a[i] == key) {
12             return i;
13         }
14     }
15     return -1;
16 }

　　注：线性搜索是最保险的查找方法，但也是效率最低的

　　2.折半查找

 1 /**
 2  * 使用二分查找来搜索指定的 int 型数组中搜索指定的值，以获得该的值的位置
 3  * @param a 要搜索的数组
 4  * @param key 要搜索的值 
 5  * @return -如果这个值被找到，则返回该值得索引，否则返回 -1<br>
 6  *         -如果数组包含多个等于指定对象的元素，则无法保证找到的是哪一个<br>
 7  *         -在进行此调用之前，必须根据元素的自然顺序对数组进行升序排序
 8  *         -如果没有对数组进行排序，则结果是不确定的
 9  */
10 public static int searchBinary(int[] a,int key) {
11     int minIndex = 0;//首位置
12     int maxIndex = a.length - 1;//末位置
13     int middleIndex;//中间位置
14     while (maxIndex >= minIndex) {
15         middleIndex = (minIndex + maxIndex)/2;
16         if (a[middleIndex] == key) {
17             return middleIndex;
18         }else if (a[middleIndex] > key) {
19             maxIndex = middleIndex - 1;
20         }else if (a[middleIndex] < key){
21             minIndex = middleIndex + 1;
22         }
23     }
24     return -1;
25 }

 注：折半查找有点绕，但相对来说也是效率最高的，但必须是已经排序完成的数组，且对排序的升序或者降序也有要求

 

三、插入

 1 /**
 2  * 插入--将一个int型数据插入到指定数组的指定位置
 3  * @param arr 待插入的数组
 4  * @param k 要插入的位置--从0开始算
 5  * @param a 要插入的数据
 6  * @return -返回插入后的新数组<br>
 7  *             -返回的是一个新数组，原待插入数组不变
 8  */
 9 public static int[] insert(int[] arr,int k,int a) {
10     int[] brr = Arrays.copyOf(arr, arr.length+1);
11     int flag = brr.length - 1;
12     for (int i = brr.length - 2; i >= k; i--) {
13         brr[i + 1] = brr[i];
14         flag = i;
15     }
16     brr[flag] = a;
17     return brr;
18 }

 看注释

 

四、删除

 1 /**
 2  * 从指定数组中删除指定的数  若没有找到要删除的数，则返回原数组
 3  * @param arr 待处理的数组
 4  * @param num 要删除的数
 5  * @return -返回处理后的新数组
 6  *             -原数组不会被改变
 7  */
 8 public static int[] delete(int[] arr,int num) {
 9     int flag = searchLinear(arr, num);//要删除值得索引
10     if (flag == -1) {//没有找到删除点
11         return arr;
12     }
13     int[] brr = new int[arr.length - 1];
14     for (int i = 0; i < flag; i++) {
15         brr[i] = arr[i];
16     }
17     for (int i = flag; i < brr.length; i++) {
18         brr[i] = arr[i + 1];
19     }
20     return brr;
21 }

 看注释

 

五、倒叙

 1 /**
 2  * 对int型数组进行倒叙操作  
 3  * 该方法直接对原数组进行操作，不会返回新的数组
 4  * @param arr 待反转的数组
 5  */
 6 public static void reversal(int[] arr) {
 7     int temp;
 8     for (int i = 0; i < arr.length/2; i++) {
 9         temp = arr[i];
10         arr[i] = arr[arr.length-i-1];
11         arr[arr.length-i-1] = temp;
12     }
13 }

 看注释

 

附加：对字符串数组进行排序

 1 /**
 2  * 对指定的 String 型数组按ASCII升序进行排序
 3  * @param str -要排序的数组
 4  */
 5 public static void sort(String[] str) {
 6     int flag = 0;//标记需要插入的位置
 7     String temp = "";//存储待插入的字符串
 8     for (int i = 1; i < str.length; i++) {
 9         temp = str[i];
10         for (int j = i; j > 0; j--) {
11             if (str[j-1].compareTo(temp) > 0) {
12                 str[j] = str[j-1];
13                 flag = j-1;
14             }else {
15                 flag = j;
16                 break;
17             }
18         }
19         str[flag] = temp;
20     }
21 }

 注：这也是普通的排序，仅仅需要把if()条件稍微改一下

同理，改过之后也可以对其它数组进行排序，如类的数组

 

 

禁止转载

张岩