【考研用】【java版】数据结构与算法汇总 之 线性数据结构

线性数据结构

更新时间：2023.8.5

1.线性表

//顺序表（数组实现）
public class MyArray {
    private int[] elements;

    //构造器
    public MyArray(){
        elements = new int[0];
    }

    public int size(){
        return elements.length;
    }

    public int get(int index){
        return elements[index];
    }

    public void set(int index,int num){
        check(index);
        elements[index] = num;
    }

    public void show(){
        //打印 所有元素
        System.out.println(Arrays.toString(elements));
    }

    public void check(int index){
        //检查index下标是否越界
        if(index<0 || index>elements.length-1){
            throw new RuntimeException("数组下标越界");
        }

    }

    public void add(int num){
        //添加元素.数组无法自己完成扩容，必须借助新数组？
        //新建临时数组,扩容.这里注意，建立数组时的数组长度从1开始
        int[] newArr = new int[elements.length+1];
        //复制
        for(int i =0; i<elements.length;i++){
            newArr[i] = elements[i];
        }
        //数组下标从0开始
        newArr[elements.length] = num;
        //复制回去。
        elements = newArr;
    }

    public void delete(int index){
        //删除下标为index的元素.同样需要一个临时数组才能进行
        check(index);

        int[] newArr = new int[elements.length-1];
        for(int i=0; i<elements.length-1;i++){
            newArr[i] = elements[i];
        }
        elements = newArr;
    }

    public void insert(int index, int num){
        check(index);
        int[]newArr = new int[elements.length+1];
        for (int i = 0; i < elements.length; i++) {
            if(i<index){
                newArr[i] = elements[i];
            }else{
                newArr[i+1] = elements[i];
            }

        }
        newArr[index] = num;
        elements = newArr;
    }
    //下面是常用的数组类算法

    //线性查找
    public int search(int target){
        int index = -1;//游标归零.-1时为没找到

        for (int i = 0; i < elements.length; i++) {
            if(elements[i] == target){
                index = i;
                break;
            }
        }
        return index;
    }

    //二分查找
    public int BinarySearch(int target){
        //游标
        int index = -1;
        //当前范围上届
        int begin = 0;
        //当前范围下届
        int end = elements.length-1;
        //当前范围中间位置
        int mid = (begin + end)/2;//java向前取整

        while(true){
            if(begin>=end){
                break;
            }
            if(elements[mid] == target){
                index = mid;
                break;
            }else{
                if(elements[mid]>target){
                    end = mid-1;
                }else{
                    begin = mid+1;
                }
                mid = (begin+end)/2;
            }

        }
        return index;
    }

}

2.栈

package linear;

/**
 * @author Shaw Yu
 * @version 1.0
 */
public class MyStack {
    //顺序栈，数组存储
    int data[];
    int top;//栈顶指针

    public static int MAXSIZE = 100;
    //初始化栈，将栈顶指针归零
    void InitStack(MyStack S){
        S.top = -1;
    }
    //判空
    boolean IsEmpty(MyStack S){
        if(S.top == -1){
            return true;
        }else{
            return false;
        }
    }
    //压栈
    void push(MyStack S, int a){
        if(S.top ==MAXSIZE-1){
            throw new ArrayIndexOutOfBoundsException("栈溢出");

        }else {
            S.top++;
            S.data[top] = a;
        }
    }
    //弹栈
    int pop(MyStack S){
        if(S.top ==-1 ){
            return -1;
        }else{
            int res = S.data[S.top];
            S.top--;
            return res;
        }

    }


}

3.队列

普通队列

package linear;

/**
 * @author Shaw Yu
 * @version 1.0
 */
public class MyQueue {
    //顺序队列，使用数组存储
    int[]data;

    int size;
    int front;//队头
    int rear;//队尾

    //初始化
    void init(MyQueue Q){
        Q.front = 0;
        Q.rear = 0;
    }

    //创建一个有具体容量的队列
    void init(MyQueue Q, int capacity){
        data = new int[capacity];
        Q.size = capacity;
        Q.front = 0;
        Q.rear = 0;
    }
    boolean isEmpty(MyQueue Q){
        if(Q.front == 0 && Q.rear == 0 ){
            return true;
        }else{
            return false;
        }

    }

    //入队
    void enQueue(int num,MyQueue Q){
        if(Q.rear == Q.size){
            throw new RuntimeException("队列已满");

        }else{
            Q.data[Q.rear] = num;
            Q.rear++;
        }
    }

    int deQueue(MyQueue Q){
        if(isEmpty(Q)){
            return -1;
        }else{
            int res = Q.data[front];
            Q.front++;
            return res;
        }
    }



}

循环队列（仅在出入队上有区别）

//循环队列的实现，主要区别在入队出队上
    boolean enQueue(MyQueue Q, int x){
        if((Q.rear+1)%size == Q.front){
            //队满
            return false;
        }else{
            Q.data[Q.rear] = x;
            Q.rear = (Q.rear+1)%size;
            return true;
        }
    }
    //出队
    int deQueue(MyQueue Q,int x){
        if((Q.front-1)%size == Q.rear){
            throw new ArrayIndexOutOfBoundsException("队空");

        }else{
            int res = Q.data[front];
            Q.front = (Q.front+1)%size;
            return res;
        }
    }