一起学算法（顺序表篇）

概念：

1.顺序表的定义

       用一段地址连续的存储单元依次存储数据的线性表被称为数据表，在Java中顺序表一般是数组或者是ArrayList实现的

先把代码放这里，接下来一一给大家进行讲解：

public class SeqList {
    private Object[] data;  // 用数组存储元素
    private int size;       // 当前元素个数

    public SeqList(int capacity) {
        data = new Object[capacity];
        size = 0;
    }

    // 在末尾添加元素
    public void add(Object element) {
        if (size >= data.length) {
            // 扩容
            Object[] newData = new Object[data.length * 2];
            System.arraycopy(data, 0, newData, 0, data.length);
            data = newData;
        }
        data[size] = element;
        size++;
    }

    // 在指定位置插入元素
    public void insert(int index, Object element) {
        if (index < 0 || index > size) {
            throw new IndexOutOfBoundsException("Index out of range");
        }
        if (size >= data.length) {
            // 扩容
            Object[] newData = new Object[data.length * 2];
            System.arraycopy(data, 0, newData, 0, index);
            System.arraycopy(data, index, newData, index + 1, size - index);
            data = newData;
        } else {
            System.arraycopy(data, index, data, index + 1, size - index);
        }
        data[index] = element;
        size++;
    }

    // 删除指定位置的元素
    public void remove(int index) {
        if (index < 0 || index >= size) {
            throw new IndexOutOfBoundsException("Index out of range");
        }
        System.arraycopy(data, index + 1, data, index, size - index - 1);
        size--;
        data[size] = null;  // 将最后一个元素置为 null，方便垃圾回收
    }

    // 获取指定位置的元素
    public Object get(int index) {
        if (index < 0 || index >= size) {
            throw new IndexOutOfBoundsException("Index out of range");
        }
        return data[index];
    }

    //给定target,返回其索引
    public int findIndex(int target){
        int index=-1;
        for(int i=0;i<data.length;i++){
              if(data[i]==target){
                   index=i;
}
          }
      return index;
     }

    // 获取顺序表的大小
    public int size() {
        return size;
    }

    // 判断顺序表是否为空
    public boolean isEmpty() {
        return size == 0;
    }
}

2.顺序表的遍历

1.遍历的含义

对顺序表的元素进行一次访问的过程被称为遍历

2.动画演示

 黄色代表第一个被遍历的元素，紫色代表已经遍历的元素，红色代表正在遍历的元素

3.代码实现

public void traversal(int[] num){
    for(int i=0;i<num.length;i++){
         //获取对应索引上的元素值
         int m=num[i];
}
}

3.顺序表的调试

1.调试的含义

调试的含义就是通过一些可视化的方式将顺序表打印出来，利用遍历的方式就可以实现

2.动画演示

 3.代码实现

 public static void main(String[] args) {
         int[] num={2,5,6,4,9,6};
         for(int i=0;i<num.length;i++){
             System.out.print(num[i]);
         }
    }

4.顺序表元素的索引

1.索引的含义

顺序表的索引就是给定一个下标i,通过下标进行数据访问的过程

2.动画演示

 黄色的部分就代表这个顺序表的第6个元素，因为索引是从0开始的，所以num[5]就可以取到这个值

3.代码实现

   // 获取指定位置的元素
    public Object get(int index) {
        if (index < 0 || index >= size) {
            throw new IndexOutOfBoundsException("Index out of range");
        }
        return data[index];
    }

由于顺序表元素存储在连续的内存空间中，所以通过下标进行访问，其中[i]代表了第i+1个元素，调用时需要注意i的取值，必须为非负整数且小于数组的最大长度，查找的时间复杂度是O(1)

5.顺序表元素的查找

1.插入的含义

给定的一个位置k和插入的元素，将它插到顺序表的第k个位置上，并且将后面的元素依次往后移动

2.动画演示

 插入元素必然导致顺序表元素的后移，最后将需要插入的元素赋值给对应位置的元素

3.代码实现

    // 在指定位置插入元素
    public void insert(int index, Object element) {
        if (index < 0 || index > size) {
            throw new IndexOutOfBoundsException("Index out of range");
        }
        if (size >= data.length) {
            // 扩容
            Object[] newData = new Object[data.length * 2];
            System.arraycopy(data, 0, newData, 0, index);
            System.arraycopy(data, index, newData, index + 1, size - index);
            data = newData;
        } else {
            System.arraycopy(data, index, data, index + 1, size - index);
        }
        data[index] = element;
        size++;
    }

       如果索引越界直接抛出异常，如果数组已经没有空余位置，直接进行扩容，如果原数组中还有空余的位置，对原数组的index~最后 移动到index+1~最后，将索引index对应的位置空出来，然后将插入元素填入index位置上，这就完成了插入操作

6.顺序表元素的删除

1.删除的含义

给定一个位置k，代表需要删除的元素，将它进行删除，并且将后面的元素往前移动

2.动画演示

 3.代码实现

    // 删除指定位置的元素
    public void remove(int index) {
        if (index < 0 || index >= size) {
            throw new IndexOutOfBoundsException("Index out of range");
        }
        System.arraycopy(data, index + 1, data, index, size - index - 1);//左闭又开
        size--;
        data[size] = null;  // 将最后一个元素置为 null，方便垃圾回收
    }

7.顺序表的查找

1.查找的含义

通过遍历顺序表找到和给定data相等的元素并返回它的下标

2.动画的演示

 3.代码实现

  //给定target,返回其索引
    public int findIndex(int target){
        int index=-1;
        for(int i=0;i<data.length;i++){
              if(data[i]==target){
                   index=i;
}
          }
      return index;
     }

8.顺序表的修改

1.修改的含义

通过查找到顺序表的下标并对给定位置的元素进行修改

2.动画演示

 3.代码实现

public void update(int i,int val){
     data[i]=val;
}

leetcode题单：

拿硬币

class Solution {
      public int minCount(int[] coins) {
     if(coins==null||coins.length==0){
         return 0;
     }
     int count=0;
        for (int i = 0; i <coins.length; i++) {
            count+=(coins[i]&1)==0?(coins[i]/2):((coins[i]/2)+1);
        }
        return count;
    }
}

K个元素的最大和

class Solution {
    public int maximizeSum(int[] nums, int k) {
       if(nums==null||nums.length==0){
           return 0;
       }
       int ans=0;
       //执行k次循环
       while(k!=0){
         //保存最大值的下标
         int maxIndex=0;
         for(int i=0;i<nums.length;i++){
             if(nums[i]>nums[maxIndex]){
                 maxIndex=i;        
                      }
         }
          ans+=nums[maxIndex];
        nums[maxIndex]+=1;
         k--;
       }
       return ans;
    }
}

数组元素和与数字和的绝对差

class Solution {
    public int differenceOfSum(int[] nums) {
     int sum=Arrays.stream(nums).sum();
     int sum1=0;
       for(int item:nums){
           int n=item/10;
           if(n==0){
               sum1+=item;
               continue;
           }
           if(n>0){
               while(item!=0){
                   sum1+=item%10;
                   item=item/10;
               }
           }
       }
       return Math.abs(sum-sum1);
    }
}