• 数组的常用操作


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

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

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

    禁止转载

    张岩

  • 相关阅读:
    MySQL——UPDATE更新
    MySQL——WHERE字句
    MySQL——查询数据
    MySQL——删除数据表
    MySQL——插入数据
    MySQL——创建数据表
    MySQL——数据类型
    MySQL——选择数据库
    MySQL——删除数据库
    MySQL——创建数据库
  • 原文地址:https://www.cnblogs.com/zhang-yan/p/7373513.html
Copyright © 2020-2023  润新知