一、排序（冒泡排序、选择排序、插入排序）
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()条件稍微改一下
同理，改过之后也可以对其它数组进行排序，如类的数组
禁止转载
张岩