数据结构顺序表——用Java实现顺序表（接口以及接口的实现）

蔚落 2023-06-10 05:26 88阅读 0赞

1，接口的定义

  1. package seqlist;
  2.  interface SeqList {
  4. // 打印顺序表    
  5.  public void display() ;
  6. // 在 pos 位置新增元素    
  7.  public void add(int pos, int data);
  8. // 判定是否包含某个元素    
  9.  public boolean contains(int toFind);
  10. // 查找某个元素对应的位置    
  11.  public int search(int toFind);
  12. // 获取 pos 位置的元素    
  13.  public int getPos(int pos) ;
  14. // 给 pos 位置的元素设为 value    
  15.  public void setPos(int pos, int value) ;
  16. // 删除第一次出现的关键字key    
  17.  public void remove(int toRemove);
  18. // 获取顺序表长度    
  19.  public int size() ;
  20. // 清空顺序表    
  21.     public void clear() ;
  22. }

2，顺序表类的定义以及实现接口

  1. package seqlist;
  3. import java.util.Arrays;
  5. public class SeqListImpl implements SeqList {
  7.     private int[] elemant;
  8.     private int usedSide;
  10.     public SeqListImpl() {
  12.         this.elemant = new int[10];
  13.         this.usedSide = 0;
  14.     }
  15.     // 打印顺序表  
  16.     @Override
  17.     public void display() {
  19.         if (this.isEmpty()) {
  21.             System.out.println("顺序表为空！");
  22.         }
  23.         for (int i = 0; i <this.usedSide ; i++) {
  25.             System.out.print(this.elemant[i]+" ");
  26.         }
  27.         System.out.println();
  28.     }
  29.     //判断数组是否满
  30.     private boolean isFull() {
  32.         return this.usedSide == this.elemant.length;
  33.     }
  35.     // 在 pos 位置新增元素
  36.     @Override
  37.     public void add(int pos, int data) {
  39.         //判断pos的合法性
  40.         if (pos < 0 || pos > this.usedSide) {
  42.             System.out.println("输入不合法！");
  43.         }
  44.         //如果为满，使原来数组扩大为原来的2倍
  45.         if (isFull()) {
  47.             this.elemant = Arrays.copyOf(this.elemant,this.elemant.length*2);
  48.         }
  49.         //使pos之后的元素都向后移动
  50.         for (int i = usedSide - 1; i >=pos ; i--) {
  52.             elemant[i+1] = elemant[i];
  53.         }
  54.         elemant[pos] = data;
  55.         usedSide++;
  56.     }
  57.     // 判定是否包含某个元素  
  58.     @Override
  59.     public boolean contains(int toFind) {
  61.         for (int i = 0; i < this.usedSide; i++) {
  63.             if (elemant[i] == toFind) {
  65.                 return true;
  66.             }
  67.         }
  68.         return false;
  69.     }
  70.     //判断是否为空
  71.     public boolean isEmpty() {
  73.         return this.usedSide == 0;
  74.     }
  75.     // 查找某个元素对应的位置
  76.     @Override
  77.     public int search(int toFind) {
  79.         if (isEmpty()) {
  81.             return -1;
  82.         }
  83.         for (int i = 0; i < this.usedSide; i++) {
  85.             if (elemant[i] == toFind) {
  87.                 return i;
  88.             }
  89.         }
  90.         return -1;
  91.     }
  92.     // 获取 pos 位置的元素  
  93.     @Override
  94.     public int getPos(int pos) {
  96.         return this.elemant[pos];
  97.     }
  98.     // 给 pos 位置的元素设为 value    
  99.     @Override
  100.     public void setPos(int pos, int value) {
  102.         elemant[pos] = value;
  103.     }
  104.     // 删除第一次出现的关键字key    
  105.     @Override
  106.     public void remove(int key) {
  108.         if (contains(key)) {
  110.             int index = search(key);
  111.             for (int i = index; i < this.usedSide -1; i++) {
  113.                 this.elemant[i] = this.elemant[i+1];
  114.             }
  115.             this.elemant[this.usedSide - 1] = 0;
  116.             this.usedSide--;
  117.         }
  118.     }
  119.     // 获取顺序表长度
  120.     @Override
  121.     public int size() {
  123.         return this.elemant.length;
  124.     }
  125.     // 清空顺序表
  126.     @Override
  127.     public void clear() {
  129.         for (int i = 0; i < this.usedSide ; i++) {
  131.             this.elemant[i] = 0;
  132.         }
  133.         this.usedSide = 0;
  134.     }
  135. }

3，测试类

  1. package seqlist;
  3. public class TestSeqList {
  5.     public static void main(String[] args) {
  7.         SeqListImpl seqList = new SeqListImpl();
  8.         for (int i = 0; i < 6; i++) {
  10.             seqList.add(i,i+1);
  11.         }
  12.         seqList.display();
  13.         System.out.println("判断是否包含数字2："+seqList.contains(2));
  14.         System.out.println(seqList.getPos(2));
  15.         System.out.println(seqList.search(3));
  16.         seqList.remove(2);
  17.         seqList.display();
  18.         seqList.remove(1);
  19.         seqList.display();
  20.         seqList.remove(3);
  21.         seqList.display();
  22.         seqList.clear();
  23.         seqList.display();
  24.     }
  25. }

4，运行结果

  1. 1 2 3 4 5 6 
  2. 判断是否包含数字2：true
  3. 3
  4. 2
  5. 1 3 4 5 6 
  6. 3 4 5 6 
  7. 4 5 6 
  8. 顺序表为空！
  11. Process finished with exit code 0

发表评论

表情：
评论列表 （有 0 条评论，88人围观）

还没有评论，来说两句吧...

相关阅读