1. import java.util.Arrays;
    3. class StaticSeq {
    4.     public int Maxsize;
    5.     int[] elem = new int[Maxsize];//数据域
    6.     public int size;//有效元素个数
    7.     public StaticSeq(int capacity) {
    8.         this.Maxsize = capacity;//构造方法，用来确定静态顺序表的容量
    9.     }
    10. }
    11. class DynamicSeq {
    12.     public int[] elem;//数据域引用
    13.     public int size;//有效元素个数
    14. }
    16. public class SeqList {
    17.     public int[] elem;
    18.     public int size;
    19.     public SeqList() {
    20.         this.initSeqList();
    21.     }
    22.     //初始化顺序表
    23.     public void initSeqList(){
    24.         this.elem = new int[10];
    25.     }
    26.     // 打印顺序表
    27.     public void display() {
    28.         for (int i = 0; i < this.size; i++) {
    29.             System.out.print(this.elem[i] + "  ");
    30.         }
    31.         System.out.println();
    32.     }
    33.     // 在 pos 位置新增元素
    34.     public void add(int pos, int data) {
    35.         if (this.elem == null) {
    36.             this.initSeqList();
    37.         }
    38.         if (pos < 0 || pos > this.size) {
    39.             System.out.println("插入位置非法！");
    40.             return;
    41.         }
    42.         if (isFull()) {
    43.             this.elem = Arrays.copyOf(this.elem, 2 * this.elem.length);
    44.         }
    45.         for (int i = size - 1; i >= pos; i--) {
    46.             this.elem[i+1] = this.elem[i];
    47.         }
    48.         this.elem[pos] = data;
    49.         this.size++;
    50.     }
    51.     public boolean isFull() {
    52.         return this.size == this.elem.length;
    53.     }
    54.     public boolean isEmpty() {
    55.         return this.size == 0;
    56.     }
    57.     // 判定是否包含某个元素
    58.     public boolean contains(int toFind) {
    59.         for (int j : this.elem) {
    60.             if (j == toFind) {
    61.                 return true;
    62.             }
    63.         }
    64.         return false;
    65.     }
    66.     // 查找某个元素对应的位置
    67.     public int search(int toFind) {
    68.         for (int i = 0; i < this.size; i++) {
    69.             if (this.elem[i] == toFind) {
    70.                 return i;
    71.             }
    72.         }
    73.         return -1;
    74.     }
    75.     //顺序插入元素
    76.     public void seqAdd(int value) {
    77.         if (this.elem == null) {
    78.             this.initSeqList();
    79.         }
    80.         if (this.isFull()) {
    81.             this.elem = Arrays.copyOf(this.elem, 2 * this.elem.length);
    82.         }
    84.         this.elem[this.size] = value;
    85.         this.size++;
    86.     }
    87.     // 获取 pos 位置的元素
    88.     public int getPos(int pos) {
    89.         if (pos < 0 || pos >= this.size) {
    90.             System.out.println("位置非法！");
    91.             return -1;
    93.         }
    94.         return this.elem[pos];
    95.     }
    96.     // 给 pos 位置的元素设为 value
    97.     public void setPos(int pos, int value) {
    98.         if (pos < 0 || pos >= this.size) {
    99.             System.out.println("修改位置非法！");
    100.             return;
    101.         }
    102.         this.elem[pos] = value;
    103.     }
    104.     //删除第一次出现的关键字key
    105.     public void remove(int toRemove) {
    106.         if (isEmpty()) {
    107.             System.out.println("顺序表为空！");
    108.             return;
    109.         }
    110.         for (int i = 0; i < this.size; i++) {
    111.             if (this.elem[i] == toRemove) {
    112.                 for (int j = i; j < this.size - 1; j++) {
    113.                     this.elem[j] = this.elem[j+1];
    114.                 }
    115.                 this.size--;
    116.                 return;
    117.             }
    118.         }
    119.         System.out.println("未找到！");
    120.     }
    121.     // 获取顺序表长度
    122.     public int size() {
    123.         return this.size;
    124.     }
    125.     // 清空顺序表
    126.     public void clear() {
    127.         this.size = 0;
    128.     }
    129.     //
    130.     //清空顺序表
    131.     public void clear() {
    132.         this.usedSize = 0;//简单类型
    134.         //如果是引用数据类型，就要将所有的数据都要置为空
    135.         /*for (int i = 0; i < usedSize; i++) {
    136.             this.elem[i] == null;
    137.         }
    138.          this.usedSize = 0;
    139.         */
    140.     }
    142. }
    1. public class MyArrayList{
    2.     public int[] elem;
    3.     public int usedSize;//表示当前有效数据个数
    5.     public MyArrayList(){
    6.         this.elem = new int[10];
    7.     }
    8.      //打印顺序表
    9.     public void display() {
    10.         for (int i = 0; i < this.usedSize; i++) {
    11.             System.out.print(this.elem[i] +" ");
    12.         }
    13.         System.out.println();
    14.     }
    15.     //获取顺序表长度
    16.     public int size() {
    17.         return this.usedSize;
    18.     }
    19.     //在pos位置新增元素
    20.     public void add(int pos, int data){
    21.         if(pos < 0 || pos > usedSize){
    22.             System.out.println("pos位置不合法");
    23.             return;
    24.         }
    25.         if(isFull()){
    26.             this.elem = Arrays.copyOf(this.elem,this.elem.length * 2);
    27.         }
    28.         for(int i = this.usedSize - 1;i >= pos;i--){
    29.             this.elem[i+1] = this.elem[i];
    30.         }
    31.         this.elem[pos] = data;
    32.         this.usedSize++;
    33.      }
    34.     public boolean isFull(){
    35.         return this.usedSize == this.elem.length;
    36.     }
    37.     //判定是否包含某个元素
    38.     public boolean contains(int toFind) {
    39.         for (int i = 0; i < this.usedSize; i++) {
    40.             if (this.elem[i] == toFind){
    41.                 return true;
    42.             }
    43.         }
    44.         return false;
    45.     }
    46.     //查找某个元素对应的位置
    47.      public int search(int toFind) {
    48.         for (int i = 0; i < this.usedSize; i++) {
    49.             if (this.elem[i] == toFind){
    50.                 return i;
    51.             }
    52.         }
    53.         return -1;
    54.     }
    55.     //获取pos位置的元素
    56.     public int getPos(int pos) {
    57.         if (pos < 0 || pos >= this.usedSize){
    58.             System.out.println("pos位置不合法");
    59.             return -1;
    60.         }
    61.         if (isEmpty()){
    62.             System.out.println("顺序表为空");
    63.             return -1;
    64.         }
    65.         return this.elem[pos];
    66.     }
    67.     public boolean isEmpty(){
    68.         return this.usedSize == 0;
    69.     }
    70.     //给pos位置的元素设为/更新 value
    71.     public void setPos(int pos, int value) {
    72.         if (pos < 0 || pos >= this.usedSize){
    73.             System.out.println("pos位置不合法");
    74.             return;
    75.         }
    76.         if (isEmpty()){
    77.             System.out.println("顺序表为空");
    78.             return;
    79.         }
    80.         this.elem[pos] = value;
    81.     }
    82.     //删除第一次出现的关键字key
    83.      public void remove(int toRemove) {
    84.         if (isEmpty()){
    85.             System.out.println("顺序表为空");
    86.             return;
    87.         }
    88.        int index = search(toRemove);
    89.         if (index == -1){
    90.             System.out.println("没有要删除的数字");
    91.             return;
    92.         }
    93.         for (int i = index; i < this.usedSize - 1; i++) {
    94.             this.elem[i] = this.elem[i + 1];
    95.         }
    96.         this.usedSize--;
    97.     }
    98.     //清空顺序表
    99.     public void clear() {
    100.         this.usedSize = 0;//简单类型
    102.         //如果是引用数据类型，就要将所有的数据都要置为空
    103.         /*for (int i = 0; i < usedSize; i++) {
    104.             this.elem[i] == null;
    105.         }
    106.          this.usedSize = 0;
    107.         */
    108.     }