一、数组实现队列、数组实现栈、稀疏数组二维数组转换

数组实现队列

/**
 * 数组实现队列
 */
public static class ArrayQueue {
    // 存放队列元素的数组
	private Integer[] arr;
	// 队列中数据的个数
	private Integer size;
	// 指向队列头
	private Integer start;
	// 指向队列尾
	private Integer end;

	public ArrayQueue(int initSize) {
		if (initSize < 0) {
			throw new IllegalArgumentException("The init size is less than 0");
		}
		arr = new Integer[initSize];
		size = 0;
		start = 0;
		end = 0;
	}

    /**
     * 返回队列头
     * @return
     */
	public Integer peek() {
		if (size == 0) {
			return null;
		}
		return arr[start];
	}


   /**
    * 添加元素
    * @param num
    */
	public void push(int num) {
	    // 判断队列是否已经满了
		if (size == arr.length) {
			throw new ArrayIndexOutOfBoundsException("The queue is full");
		}
		// 没有满，大小加一
		size++;
		// 队列尾赋值
		arr[end] = num;
		// 跟新队列尾的位置
		end = end == arr.length - 1 ? 0 : end + 1;
	}

   /**
    * 出队列
    * @return
    */
	public Integer poll() {
	    // 队列为空
		if (size == 0) {
			throw new ArrayIndexOutOfBoundsException("The queue is empty");
		}
		// 不为空的时候大小减一
		size--;
		// 记录当前队列头元素
		int tmp = start;
		// 更新队列头位置
		start = start == arr.length - 1 ? 0 : start + 1;
		// 返回队列头元素
		return arr[tmp];
	}
}

数组实现栈

    public static class ArrayStack {
		private Integer[] arr;
		private Integer size;

		public ArrayStack(int initSize) {
			if (initSize < 0) {
				throw new IllegalArgumentException("The init size is less than 0");
			}
			arr = new Integer[initSize];
			size = 0;
		}

        /**
         * 返回栈顶元素
         * @return
         */
		public Integer peek() {
			if (size == 0) {
				return null;
			}
			return arr[size - 1];
		}

        /**
         * 入栈
         * @param num
         */
		public void push(int num) {
			if (size == arr.length) {
				throw new ArrayIndexOutOfBoundsException("The queue is full");
			}
			arr[size++] = num;
		}


        /**
         * 出栈
         * @return
         */
		public Integer pop() {
			if (size == 0) {
				throw new ArrayIndexOutOfBoundsException("The queue is empty");
			}
			return arr[--size];
		}
	}

稀疏数组

package com.liaoxiang.sparseArray;

/**
 * @auther Mr.Liao
 * @date 2019/7/5 11:36
 * 二维数组-> 稀疏数组->二维数组
 */
public class SparseArray {
    public static void main(String[] args) {
        //原始二维数组：10*10
        int chessArray1[][] = new int[10][10];
        chessArray1[1][2] = 1;
        chessArray1[2][3] = 2;
        chessArray1[4][5] = 2;
        System.out.println("原始数组：");
        //1.遍历每一行
        for (int[] row : chessArray1) {
            //2.遍历每一行的数据
            for (int data : row) {
                System.out.printf("%d\t",data);
            }
            System.out.println();
        }

        /**
         * 将二维数组转化为稀疏数组
         */
        //1.获取原始数组中不为0的元素的个数
        int sum = 0;
        for (int[] row : chessArray1) {
            for (int data : row) {
                if (data != 0) {
                    sum++;
                }
            }
        }
        //2.根据sum创建稀疏数组
        int sparseArray[][] = new int [sum+1][3];
        sparseArray[0][0] = 10;
        sparseArray[0][1] = 10;
        sparseArray[0][2] = sum;
        //3.将二维数组中的有效数字存到稀疏数组
        int count = 0;//记录非0数据的个数
        for (int i = 0; i < 10; i++) {
            for (int j = 0; j < 10; j++) {
                if (chessArray1[i][j] != 0){
                    count++;
                    //有效元素在原二维数组中的位置
                    sparseArray[count][0] = i;
                    sparseArray[count][1] = j;
                    //有效元素的值
                    sparseArray[count][2] = chessArray1[i][j];
                }
            }
        }
        System.out.println("稀疏数组：");
        //1.遍历每一行
        for (int[] row : sparseArray) {
            //2.遍历每一行的数据
            for (int data : row) {
                System.out.printf("%d\t",data);
            }
            System.out.println();
        }

        /**
         * 将稀疏数组转化为原二维数组
         */
        //1.先获取原数组的大小，创建二维数组
        int chessArray2[][] = new int[sparseArray[0][0]][sparseArray[0][1]];
        //2.从第二行开始遍历稀疏数组，取出值赋值给二维数组
        for (int i = 1; i < sparseArray.length; i++) {
            chessArray2[sparseArray[i][0]][sparseArray[i][1]] = sparseArray[i][2];
        }
        System.out.println("恢复后的二维数组：");
        //3.输出新的二维数组
        for (int[] row : chessArray2) {
            //2.遍历每一行的数据
            for (int data : row) {
                System.out.printf("%d\t",data);
            }
            System.out.println();
        }

    }
}

原始数组：
0	0	0	0	0	0	0	0	0	0	
0	0	1	0	0	0	0	0	0	0	
0	0	0	2	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	2	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	
稀疏数组：
10	10	3	
1	2	1	
2	3	2	
4	5	2	
恢复后的二维数组：
0	0	0	0	0	0	0	0	0	0	
0	0	1	0	0	0	0	0	0	0	
0	0	0	2	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	2	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	

Process finished with exit code 0

数组实现队列二（不用看）

class CircleArray {
    private int maxSize; // 表示数组的最大容量
    private int front;   // 队列头
    private int rear;    // 队列尾
    private int[] arr;   // 该数组用于存放数据, 模拟队列

    public CircleArray(int arrMaxSize) {
        maxSize = arrMaxSize;
        arr = new int[maxSize];
    }
    /**
     * 判断队列是否满、队列尾追上队列头
     * @return
     */
    public boolean isFull() {
        return (rear  + 1) % maxSize == front;
    }
    /**
     * 判断队列是否为空
     * @return
     */
    public boolean isEmpty() {
        return rear == front;
    }
    /**
     * 添加数据到队列
     * @param n
     */
    public void addQueue(int n) {
        // 判断队列是否满
        if (isFull()) {
            System.out.println("队列已满！");
            return;
        }
        //直接将数据加入
        arr[rear] = n;
        System.out.printf("添加的数据：arr[%d] = %d\n",rear,n);
        //将 rear 后移, 这里必须考虑取模
        rear = (rear + 1) % maxSize;
        System.out.println("添加数据后rear="+rear);
    }
    /**
     * 获取队列的数据, 出队列
     * @return
     */
    public int getQueue() {
        if (isEmpty()) {
            // 通过抛出异常
            throw new RuntimeException("队列为空！");
        }
        // 这里需要分析出front是指向队列的第一个元素
        // 1. 先把 front 对应的值保留到一个临时变量
        // 2. 取出后将front后移, 考虑取模
        // 3. 将临时保存的变量返回
        int value = arr[front];
        System.out.printf("取出的数据：arr[%d] = %d\n",front,value);
        front = (front + 1) % maxSize;
        System.out.println("取出数据后front="+front);
        return value;

    }
    /**
     * 显示队列的所有数据
     */
    public void showQueue() {
        if (isEmpty()) {
            System.out.println("队列为空！");
            return;
        }
        // 思路：从front开始遍历，遍历多少个元素
        System.out.println("rear="+rear+", front="+front);
        for (int i = front; i < front + size() ; i++) {
            System.out.printf("arr[%d]=%d\n", i % maxSize, arr[i % maxSize]);
        }
    }
    /**
     * 求出当前队列有效数据的个数
     */
    public int size() {
        System.out.println();
        return (rear + maxSize - front) % maxSize;
    }
    /**
     * 显示队列的头数据， 注意不是取出数据
     * @return
     */
    public int headQueue() {
        // 判断
        if (isEmpty()) {
            throw new RuntimeException("队列为空！");
        }
        System.out.printf("队列头位置：arr[%d]=%d\n",front,arr[front]);
        return arr[front];
    }
    /**
     * 显示原数组
     */
    public void realShow(){
        for (int i = 0; i < arr.length; i++) {
            System.out.printf("arr[%d]=%d\n", i, arr[i]);
        }
    }
}

添加三个数据
取出一个再添加一个
再取出一个，添加一个