首页 > 编程语言 > 详细

数组的常用操作

时间:2017-08-16 16:46:42      阅读:1062      评论:0      收藏:0      [点我收藏+]

一、排序(冒泡排序、选择排序、插入排序)

  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()条件稍微改一下

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

 

 

禁止转载

张岩

数组的常用操作

原文:http://www.cnblogs.com/zhang-yan/p/7373513.html

(0)
(0)
   
举报
评论 一句话评论(0
关于我们 - 联系我们 - 留言反馈 - 联系我们:wmxa8@hotmail.com
© 2014 bubuko.com 版权所有
打开技术之扣,分享程序人生!