数组模拟实现数据结构

Posted 2023-04-29 邪童的博客

通过数组模拟实现链表、栈、队列、堆

数组模拟链表实现

① 单链表: 邻接表 (存储图和树)

② 双链表: 优化某些问题

单链表

int e[N] 存储 val , int ne[N] 存储 next

//单链表模板

int head,e[N],ne[N],idx;
//head表示头节点的下标,e[i]表示节点i的值,ne[i]表示节点i的指针是多少,idx存储当前已经用到了哪个点

void init() //初始化

    head=-1;
    idx=0;


void add_to_head (int x) //将x插到头节点

    e[idx]=x;
    ne[idx]=head;
    head=idx++;


void add (int k,int x) //将x插到下标是k的点后面

    e[idx]=x;
    ne[idx]=ne[k];
    ne[k]=idx++;


void remove (int k) //删除下标是k的点的下一个点

    ne[k]=ne[ne[k]];

双链表

每个节点有两个指针, 指向上一个和下一个节点

int l[N],r[N];
0: head	  //下标为0的点作为头节点
1: tail   //下标为1的点作为尾节点

//双链表模板

int e[N],l[N],r[N],idx;
//e[]表示节点的值,l[]表示节点的左指针,r[]表示节点的右指针,idx表示当前用到了哪个节点

void init() //初始化

    r[0]=1,l[1]=0;	//0是左端点,1是右端点
    idx=2;


void add_to_right (int a,int x) //在节点a的右边插入一个数x

    e[idx]=x;
    l[idx]=a,r[idx]=r[a];
    l[[r[a]]]=idx,r[a]=idx;
    idx++;


void remove (int k) //删除节点k

    l[r[k]]=l[k];
    r[l[k]]=r[k];

---

数组模拟栈实现

//数组模拟栈模板

int stk[N],tt=0; //tt表示栈顶

stk[++tt]=x;  //向栈顶插入一个数x

tt--;	//向栈顶弹出一个数

stk[tt];	//栈顶的值

if(tt>0)	//判断栈是否为空

单调栈

常见模型: 找出每个数左边离它最近的比它大/ 小的数

int stk[N],tt=0;
for(int i=1;i<=n;i++)

    while(tt&&check(stk[tt],a[i]))tt--;
    stk[++tt]=a[i];

---

数组模拟队列实现

//数组模拟队列模板

int q[N],hh=0,tt=-1;  //hh表示队头,tt表示队尾

q[++tt]=x;	//向队尾插入一个数x

hh++;	//从队头弹出一个数

q[hh];	//队头的值

if(hh<=tt)	//判断队列是否为空

单调队列

常用模型: 找出滑动窗口中的最大值/ 最小值

int q[N],hh=0,tt=-1;
for(int i=1;i<=n;i++)

    while(hh<=tt&&check_out(q[hh]))hh++;  //判断队头是否滑出窗口
    while(hh<=tt&&check(q[tt],a[i]))t--;
    q[++tt]=a[i];

---

数组模拟堆实现

堆是一棵完全二叉树

对于小根堆: 每一个点都小于等于左右两个子节点

存储方式(完全二叉树的存储方式): 用一维数组存储

堆数组下标从1开始(1为根节点)

x的左儿子是 2x , x的右儿子是 2x+1

如何手写一个堆?

1. 插入一个数 heap[++size] = x , up(size)
2. 求集合中的最小值 heap[1]
3. 删除最小值 heap[1] = heap[size] , size-- , down(1)
4. 删除任意一个元素 heap[k] = heap[size] , size-- , down(k) , up(k)
5. 删除任意一个元素 heap[k] = x , down(k) , up(k)

//堆数组操作模板

//O(n)建堆
for(int i=n/2;i;i--)down(i);

//down操作
void down (int u)

    int t=u;		//t最终存储最小值下标
    if(u*2<=size&&h[u*2]<h[t])t=u*2;
    if(u*2+1<=size&&h[u*2+1]<h[t])t=u*2+1;
    if(u!=t)
    
        swap(h[u],h[t]);
        down(t);
    


//up操作
void up (int u)

    while(u/2&&h[u/2]>h[u])
    
        swap(h[u/2],h[u]);
        u/=2;
    

//维护映射关系的堆模板

int h[N],ph[N],hp[N],size;
//h[]存储堆中的值
//ph[k]存储第k个插入的点在堆中的位置
//hp[k]存储堆中下标是k的点是第几个插入的

//交换两个点,及其映射关系
void heap_swap (int a,int b)

    swap(ph[hp[a]],ph[hp[b]]);
    swap(hp[a],hp[b]);
    swap(h[a],h[b]);

数据结构 - 数组模拟非循环和循环队列(Java实现)

数组模拟非循环队列

思路分析

• (front:) 指向队头元素，(rear:) 指向队尾元素的后面一个元素，(maxSize:) 队列大小
• 队列为空：(rear == front)，队列满：(rear == maxSize)
• 进队列：直接加入到 (rear) 的位置，然后 (rear) 后移
• 出队列：记录当前 (front) 指向的值，然后 (front) 后移

??上图可以看出队列空间大小为 (6)，但是这样模拟队列会有一些问题，当取出数据的时候，下面的数组的位置已经不能被使用了，当 (rear = 5) 时队列已经满了，那么下面空的位置不能够被使用，此时叫做 "假溢出" 或者 "假满"，也就是数组的位置不能够被复用，我们使用循环队列就可以解决这个问题。

代码实现

import java.util.ArrayDeque;
import java.util.Queue;
import java.util.Scanner;

//数组使用一次就不能使用,没有达到复用的效果
public class ArrayQueueTest {
    public static void main(String[] args) {
        //先进先出 FIFO
        ArrayQueue queue = new ArrayQueue(3);
        char key = ‘ ‘;
        Scanner scanner = new Scanner(System.in);
        boolean loop = true;
        while (loop) {
            System.out.println("s(show):显示队列");
            System.out.println("e(exit):退出程序");
            System.out.println("a(add):添加数据");
            System.out.println("d(del):取出数据");
            System.out.println("t(top):查看队头");
            key = scanner.next().charAt(0);
            switch (key) {
                case ‘s‘:
                    queue.showQueue();
                    break;
                case ‘e‘:
                    scanner.close();
                    loop = false;
                    break;
                case ‘a‘:
                    System.out.print("请输入要添加的数字:");
                    int value = scanner.nextInt();
                    queue.EnQueue(value);
                    break;
                case ‘d‘:
                    try {
                        int result = queue.DeQueue();
                        System.out.printf("取出的数据为:%d
", result);
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }
                    break;
                case ‘t‘:
                    try {
                        int top = queue.Top();
                        System.out.printf("队头数据为:%d
", top);
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }
                    break;
                default:
                    break;
            }
        }
        System.out.println("退出成功");
    }
}
//数组模拟队列
class ArrayQueue {
    private int maxSize; //数组最大容量
    private int front; //队尾
    private int rear; //队头
    private int[] array; //模拟队列

    public ArrayQueue(int maxSize) {
        this.maxSize = maxSize;
        array = new int[maxSize];
        front = 0;//front指向队头
        rear = 0;//指向队尾的后一个
    }
    //判断队列是否满
    public boolean isFull() {
        return rear == maxSize;
    }
    //判断队列是否为空
    public boolean isEmpty() {
        return rear == front;
    }
    //添加数据到队列
    public void EnQueue(int value) {
        if (isFull()) {
            System.out.println("队列已满,无法增加数据!");
            return;
        }
        array[rear ++] = value;
    }
    //出队列
    public int DeQueue() {
        if (isEmpty()) {
            throw new RuntimeException("队列为空,无法取数据");
        }
        int value = array[front ++];
        return value;
    }
    //显示所有数据
    public void showQueue() {
        if (isEmpty()) {
            System.out.println("队列为空,无法显示任何数据");
            return;
        }
        for (int i = front; i < rear; i++) {
            System.out.printf("array[%d] = %d
", i, array[i]);
        }
    }
    //显示队头
    public int Top() {
        if (isEmpty()) {
            throw new RuntimeException("队列为空,无法显示队头");
        }
        return array[front];
    }
}

数组模拟循环队列

思路分析

• 循环队列：首尾相接的顺序存储结构
  ??上面的图中我们可以发现，此时的队列的大小为 (5)，无论是队列满还是队列为空的时候，判断的条件都是 (front = rear)，此时我们使用的方法就是将这个循环队列预留出来一个空间，当这个环形队列中还剩一个空间时就表示这个队列已满，见下图。
  

??按照上述策略我们就可以区别开来队列满和队列空的判断条件，只是此时数组大小为 (5)，队列的实际大小为 (4)，因为我们预留出来的一个空间。

• (front:) 指向队头元素，(rear:) 指向队尾元素的后面一个元素，(maxSize:) 队列大小
• 队列为空：(rear == front)，队列满：((rear + 1) \% maxSize==front)
• 进队列：直接加入到 (rear) 的位置，然后 (rear) 后移，(rear = (rear + 1) \% maxSize)
• 出队列：记录当前 (front) 指向的值，然后 (front) 后移，(front = (front + 1) \% maxSize)
• 队列长度：当 (rear > front) 时，队列的长度为 (rear - front)，当 (rear < front) 时，此时队列的长度可以分成两段，一段是 (maxSize - front) (可以想象成非循环队列的画法来模拟循环队列)，另外一段就是 (rear)，总长度为 (rear + maxSize - front)，因此可以推出通用的计算的长度的公式：((rear + maxSize - front) \%maxSize)

代码实现

import java.util.Scanner;

public class CircleQueueTest {
    public static void main(String[] args) {
        //先进先出 FIFO
        CircleQueue queue = new CircleQueue(4);
        char key = ‘ ‘;
        Scanner scanner = new Scanner(System.in);
        boolean loop = true;
        while (loop) {
            System.out.println("s(show):显示队列");
            System.out.println("e(exit):退出程序");
            System.out.println("a(add):添加数据");
            System.out.println("d(del):取出数据");
            System.out.println("t(top):查看队头");
            key = scanner.next().charAt(0);
            switch (key) {
                case ‘s‘:
                    queue.showQueue();
                    break;
                case ‘e‘:
                    scanner.close();
                    loop = false;
                    break;
                case ‘a‘:
                    System.out.print("请输入要添加的数字:");
                    int value = scanner.nextInt();
                    queue.EnQueue(value);
                    break;
                case ‘d‘:
                    try {
                        int result = queue.DeQueue();
                        System.out.printf("取出的数据为:%d
", result);
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }
                    break;
                case ‘t‘:
                    try {
                        int top = queue.Top();
                        System.out.printf("队头数据为:%d
", top);
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }
                    break;
                default:
                    break;
            }
        }
        System.out.println("退出成功");
    }
}

//数组模拟队列
class CircleQueue {
    private int maxSize; //数组最大容量
    private int front; //队尾
    private int rear; //队头
    private int[] array; //模拟队列

    public CircleQueue(int maxSize) {
        this.maxSize = maxSize;
        array = new int[maxSize];
        front = 0;//front指向队头
        rear = 0;//指向队尾的后一个
    }
    //判断队列是否满
    public boolean isFull() {
        return (rear + 1) % maxSize == front;
    }
    //判断队列是否为空
    public boolean isEmpty() {
        return rear == front;
    }
    //添加数据到队列
    public void EnQueue(int value) {
        if (isFull()) {
            System.out.println("队列已满,无法增加数据!");
            return;
        }
        array[rear] = value;
        rear = (rear + 1) % maxSize;
    }
    //出队列
    public int DeQueue() {
        if (isEmpty()) {
            throw new RuntimeException("队列为空,无法取数据");
        }
        int value = array[front];
        front = (front + 1) % maxSize;
        return value;
    }
    //显示所有数据
    public void showQueue() {
        if (isEmpty()) {
            System.out.println("队列为空,无法显示任何数据");
            return;
        }
        for (int i = front; i < front + Length(); i++) {
            System.out.printf("array[%d] = %d
", i % maxSize, array[i % maxSize]);
        }
    }
    //显示队头
    public int Top() {
        if (isEmpty()) {
            throw new RuntimeException("队列为空,无法显示队头");
        }
        return array[front];
    }
    public int Length() {
        return (rear + maxSize - front) % maxSize;
    }
}