1. 插入算法思路

  • 检查输入，如果插入位置不合理，抛出异常
  • 检查数组，如果线性表的长度大于等于数组长度，则抛出异常或动态增加容量
  • 遍历后移，从最后一个元素开始向前遍历到第i个位置，分别将他们都向后移动一个位置
  • 插入数据，将要插入的数据填入i处
  • 表长加1，插入了一个元素，一定要增加线性表的长度
  1.  /**
  2.      * 在线性表中的第location个位置插入新元素value
  3.      * @param lineList  目标线性表
  4.      * @param location  目标位置
  5.      * @param value     插入的元素值
  6.      */
  7.     public static void elementInsert(LineList lineList,int location,int value){
  8.         //检查线性表是否已满
  9.         if(lineList.length==LineList.MAXSIZE){
  10.             System.out.println("线性表已满");
  11.             return;
  12.         }
  13.         //检查插入数据的位置是否合法
  14.         if(location < 1 || location > lineList.length){
  15.             System.out.println("插入数据的位置不合法");
  16.             return;
  17.         }
  18.         //若插入的元素不在表尾部，先将元素后移一位
  19.         if(location < lineList.length){
  20.             for (int i = lineList.length-1; i >= location - 1; i --) {
  21.                 lineList.date[i+1] = lineList.date[i];
  22.             }
  23.         }
  24.         //插入元素
  25.         lineList.date[location - 1] = value;
  26.         lineList.length++;
  27.         System.out.println("在线性表第"+location+"个位置成功插入"+value);
  28.         return;
  29.     }

2.删除算法的思路

  • 检查输入，如果删除位置不合理，抛出异常
  • 删除数据，取出删除的元素
  • 遍历前移，从删除元素位置开始遍历到最后一个元素，分别将他们都向前移动一个位置
  • 表长减1：删除了元素，不减表长会出错 
    1. /**
    2.   * 删除线性表第location个位置元素,并用value返回其值
    3.   * @param lineList  目标线性表
    4.   * @param location  要删除的位置
    5.   * @return  删除的值
    6.   */
    7.  public static int elementDelete(LineList lineList,int location){
    8.      int value = 0;
    9.      //检查输入是否合法
    10.      if (location < 1 || location > lineList.length){
    11.          System.out.println("想要删除数据的位置不合法");
    12.          return 0;
    13.      }
    14.      //删除数据
    15.      value = lineList.date[location-1];
    16.      lineList.date[location-1] = 0;
    17.      //删除的位置不是最后一位，将后后面的元素前移
    18.      if (location<lineList.length){
    19.          for (int i = location-1; i < lineList.length; i++) {
    20.              lineList.date[i] = lineList.date[i+1];
    21.          }
    22.      }
    23.      lineList.length--;
    24.      System.out.println("删除的数据为"+value);
    25.      return value;
    26.  }

3. C语言转换到java

  • c语言中的结构体可以理解为类的定义
  • 由于java中的对象为引用类型，所以可以用由类生成的对象作为参数，虽然存在差异，可以一定程度上来代替指针的。

LineList 类

  1. public class LineList {
  2.     final static int MAXSIZE = 20;
  3.     int[] date;
  4.     int length;
  5.     LineList(){
  6.         date = new int[MAXSIZE];
  7.         length = 0; 
  8.     }
  9. }

注意：如果想初始化一个不为空的链表，采用下面这个方法是不可行的。

  1.     //此方法初始化会出现数组越界
  2. //    LineList(int[] data){
  3. //        this.date = new int[MAXSIZE];
  4. //        this.date = data; //在这里会重新将线性表存储位置，更新为新传入的数组，而不是初始化的数组，无法插入元素
  5. //        length = data.length;
  6. //    }

这是我一开始用来初始化一个非空线性表的初始化函数

  1. //将会出现数组越界。此方法初始化会导致线性表的长度，为用来初始化的数组data的长度，导致无法插入数据
  2. //    public static LineList initList(int[] data){
  3. //        LineList lineList = new LineList(data);
  4. //        return lineList;
  5. //    }

这样写就相当于重新将线性表存到新给的数组中，而新给的数组是满的。例如：{1,2,3},再插入数据到线性表是数组溢出，会报错的。

4. 初始化线性表方法

  1. /**
  2.      * 初始化一个空的线性表
  3.      * @return lineList 返回一个空的线性表
  4.      */
  5.     public static LineList initList(){
  6.         LineList lineList = new LineList();//创建一个空的线性表
  7.         return lineList;
  8.     }
  10.     /**
  11.      * 初始化一个不为空的线性表
  12.      * @param data  传入线性表的数据
  13.      * @return  返回一个不为空的线性表
  14.      */
  15.     public static LineList initList(int[] data){
  16.         LineList lineList = new LineList();//创建一个空的线性表
  17.         for (int i = 0; i < data.length; i++) {//这样一个个赋值才不会让数组的存储位置发生改变
  18.             lineList.date[i] = data[i];
  19.         }
  20.         lineList.length = data.length;
  21.         return lineList;
  22.     }

5. 打印线性表

  1.    /**
  2.      * 打印线性表
  3.      * @param linkList  输入要打印的线性表
  4.      */
  5.     public static void printList(LineList linkList){
  6.         System.out.print("打印线性表:");
  7.         for(int i = 0;i < linkList.length;i++){
  8.             System.out.print(linkList.date[i]+" ");
  9.         }
  10.         System.out.println();
  11.     }

6.清空线性表

  1.     /**
  2.      * 清空线性表
  3.      * @param lineList  要清空的线性表
  4.      */
  5.     public static void listClear(LineList lineList){
  6.         for (int i = 0; i < lineList.length; i++) {
  7.             lineList.date[i] = 0;
  8.         }
  9.         lineList.length = 0;
  10.     }

7.按位置查找元素

  1.    /**
  2.      * 将先线性表中的第location个位置的元素返回
  3.      * @param lineList  目标线性表线性表
  4.      * @param location  要获取的位置
  5.      * @return
  6.      */
  7.     public static int getElement(LineList lineList, int location){
  8.         int value;
  9.         //检查要获取的元素是否存在
  10.         if(location > lineList.length){
  11.             System.out.println("线性表的第"+location+"个位置不存在");
  12.             return 0;
  13.         }else {
  14.             value = lineList.date[location-1];
  15.             System.out.println("线性表的第"+location+"个位置的元素为"+value);
  16.             return value;
  17.         }
  18.     }

8.按值查找元素

  1.   /**
  2.      * 在线性表中查询与给定值value相等的元素。
  3.      * 如果查询成功,返回该元素在表中的序号。
  4.      * 否则返回0，表示失败
  5.      * ===没有实现多个值相同的查询，这里只返回第一个匹配到的值==
  6.      * @param lineList
  7.      * @param value
  8.      * @return 返回元素的位置
  9.      */
  10.     public static int elementLocate(LineList lineList,int value){
  11.         for (int i = 0; i < lineList.length; i++) {
  12.             if(value == lineList.date[i]){
  13.                 return i+1;
  14.             }
  15.         }
  16.         return 0;
  17.     }