稀疏数组和队列

稀疏数组

当一个数组中大部分元素为０，或者为同一个值的数组时，可以使用稀疏数组来保存该数组。

稀疏数组的处理方法是:

1. 记录数组一共有几行几列，有多少个不同的值
2. 把具有不同值的元素的行列及值记录在一个小规模的数组中，从而缩小程序的规模
   
   [0] 表示有6行7列共8个数据
   

public class SparseArray {
  public static void main(String[] args) {
    // 创建 11 * 11 数组
    // 0: 没有棋子 1 黑子  2 白子
    int chessArr1[][] = new int[11][11];
    chessArr1[1][2] = 1;
    chessArr1[2][3] = 2;
    chessArr1[4][5] = 2;
    System.out.println("原始二维数组");
    for (int[] row : chessArr1) {
      for (int data : row) {
        System.out.printf("%d\t", data);
      }
      System.out.println();
    }

    // 转为稀疏数组
    // 1. 遍历数组 得到有多少个棋子
    int sum = 0;
    for (int i = 0; i < 11; i++) {
      for (int j = 0; j < 11; j++) {
        if (chessArr1[i][j] != 0) {
          sum++;
        }
      }
    }

    // 2. 构造稀疏数组
    int sparseArr[][] = new int[sum + 1][3];

    sparseArr[0][0] = 11;
    sparseArr[0][1] = 11;
    sparseArr[0][2] = sum;

    int count = 0; //count 是第几个棋子
    for (int i = 0; i < 11; i++) {
      for (int j = 0; j < 11; j++) {
        if (chessArr1[i][j] != 0) {
          count++;
          sparseArr[count][0] = i;
          sparseArr[count][1] = j;
          sparseArr[count][2] = chessArr1[i][j];
        }
      }
    }

    System.out.println();
    System.out.println("稀疏数组为");
    for (int i = 0; i < sparseArr.length; i++) {
      System.out.printf("%d\t%d\t%d\t\n", sparseArr[i][0], sparseArr[i][1], sparseArr[i][2]);
    }
    System.out.println();

    //1. 根据稀疏数组第一行前两个值作为大小创建二维数组
    int chessArr2[][] = new int[sparseArr[0][0]][sparseArr[0][1]];

    //2. 填充
    for (int i = 1; i < sparseArr.length; i++) {
      chessArr2[sparseArr[i][0]][sparseArr[i][1]] = sparseArr[i][2];
    }
  }   
}

队列

队列是一个有序列表，可以用数组或是链表来实现，遵循先入先出的原则。

数组模拟队列

public class ArrayQueueDemo {
	public static void main(String[] args) {
		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("g(get): 取数据");
			System.out.println("h(head): 查看头数据");
			key = scanner.next().charAt(0); //接收一个字符
			switch (key) {
			case 's':
				queue.showQueue();
				break;
			case 'a':
				int value = scanner.nextInt();
				queue.addQueue(value);
				break;
			case 'g': 
				try {
					int res = queue.getQueue();
					System.out.printf("取出的是%d\n", res);
				} catch (Exception e) {
					System.out.println(e.getMessage());
				}
				break;
			case 'h': 
				try {
					int res = queue.headQueue();
					System.out.printf("队头是%d\n", res);
				} catch (Exception e) {
					System.out.println(e.getMessage());
				}
				break;
			case 'e': 
				scanner.close();
				loop = false;
				break;
			default:
				break;
			}
		}	
		System.out.println("退出");
	}
}

class ArrayQueue {
	private int maxSize; 
	private int front; // 指向第一个元素的前面
	private int rear;  // 指向最后一个元素
	private int[] arr; 

	// 构造函数
	public ArrayQueue(int arrMaxSize) {
		maxSize = arrMaxSize;
		arr = new int[maxSize];
		front = -1;  
		rear = -1;  
	}

	public boolean isFull() {
		return rear == maxSize - 1;
	}

	public boolean isEmpty() {
		return rear == front;
	}

	public void addQueue(int n) {
		if (isFull()) {
			System.out.println("满了");
			return;
		}
		rear++; 
		arr[rear] = n;
	}

	public int getQueue() {
		if (isEmpty()) {
			throw new RuntimeException("为空，不能取");
		}
		front++; 
		return arr[front];
	}

	public void showQueue() {
		if (isEmpty()) {
			System.out.println("没有数据");
			return;
		}
		for (int i = 0; i < arr.length; i++) {
			System.out.printf("arr[%d]=%d\n", i, arr[i]);
		}
	}
	
	// 获取头的值
	public int headQueue() {
		if (isEmpty()) {
			throw new RuntimeException("为空");
		}
		return arr[front + 1];
	}
}

存在一个问题：当 front 和 rear 都指向最后一个位置时，此时虽然队列为空，但因为 rear == maxSize - 1 所以他会给当作已经满了

数组模拟环形队列

1. front 变量的含义做一个调整： front 就指向队列的第一个元素, 也就是说 arr[front] 就是队列的第一个元素
   front 的初始值 = 0
2. rear 变量的含义做一个调整：rear 指向队列的最后一个元素的后一个位置. 因为希望空出一个空间做为约定.
   rear 的初始值 = 0
3. 当队列满时，条件是 (rear + 1) % maxSize == front
4. 对队列为空的条件， rear == front
5. 当我们这样分析， 队列中有效的数据的个数 (rear + maxSize - front) % maxSize // rear = 1 front = 0

public class CircleArrayQueueDemo {
	public static void main(String[] args) {
		CircleArray queue = new CircleArray(4);  // 因为要空出来一个，实际上最多只有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("g(get): 取数据");
			System.out.println("h(head): 查看头数据");
			key = scanner.next().charAt(0);
			switch (key) {
			case 's':
				queue.showQueue();
				break;
			case 'a':
				System.out.println("Êä³öÒ»¸öÊý");
				int value = scanner.nextInt();
				queue.addQueue(value);
				break;
			case 'g': 
				try {
					int res = queue.getQueue();
					System.out.printf("È¡³öµÄÊý¾ÝÊÇ%d\n", res);
				} catch (Exception e) {
					System.out.println(e.getMessage());
				}
				break;
			case 'h': 
				try {
					int res = queue.headQueue();
					System.out.printf("¶ÓÁÐÍ·µÄÊý¾ÝÊÇ%d\n", res);
				} catch (Exception e) {
					System.out.println(e.getMessage());
				}
				break;
			case 'e': 
				scanner.close();
				loop = false;
				break;
			default:
				break;
			}
		}
		System.out.println("退出");
	}
}


class CircleArray {
	private int maxSize; 
	private int front;  // 默认是0
	private int rear; 
	private int[] arr; 
	
	public CircleArray(int arrMaxSize) {
		maxSize = arrMaxSize;
		arr = new int[maxSize];
	}
	
	public boolean isFull() {
		return (rear  + 1) % maxSize == front;
	}
	
	public boolean isEmpty() {
		return rear == front;
	}
	
	public void addQueue(int n) {
		if (isFull()) {
			System.out.println("满了");
			return;
		}
		arr[rear] = n;
		rear = (rear + 1) % maxSize;
	}
	
	public int getQueue() {
		if (isEmpty()) {
			throw new RuntimeException("空的");
		}
		int value = arr[front];
		front = (front + 1) % maxSize;
		return value;
	}
	
	public void showQueue() {
		if (isEmpty()) {
			System.out.println("空的");
			return;
		}
		for (int i = front; i < front + size() ; i++) {
			System.out.printf("arr[%d]=%d\n", i % maxSize, arr[i % maxSize]);
		}
	}
	
	public int size() {
		return (rear + maxSize - front) % maxSize;   
	}
	
	public int headQueue() {
		if (isEmpty()) {
			throw new RuntimeException("空的");
		}
		return arr[front];
	}
}