Java 数据结构与算法基础到深入1（稀疏数组、环形队列）

数据结构和算法的介绍

• 数据(data)结构(structure)是一门研究组织数据方式的学科，有了编程语言也就有了数据结构。学好数据结构可以编写出更加漂亮的，更有效率的代码。
• 要学习好数据结构就要多多考虑如何将生活中遇到的问题，用程序去解决。
• 程序 = 数据结构 + 算法
• 数据结构是算法的基础，要学好算法，需要把数据结构学到位。

线性结构和非线性结构

• 数据结构包括线性结构和非线性结构
• 线性结构
  • 线性结构作为最常用的数据结构，其特点是数据元素之间存在一对一的关系，比如a[0] = 10
  • 线性结构有两种不同的存储结构，即顺序存储结构和链式存储结构。顺序存储的线性表成为顺序表，顺序表中的存储元素的地址是连续的。
  • 链式存储的线性表称为链表，链表中的存储元素不一定是连续的，元素节点中存放数据元素以及相邻元素的地址信息。
  • 线性结构常见的有数组、队列、链表和栈。
• 非线性结构：二维数组、多维数组、广义表、树结构、图结构。

稀疏数组和队列

• 为什么用稀疏数组？
  比如一个五子棋棋盘中，可以看成一个二维数组，下了的把他存为1或2。而其他没有下的就全为0，这样就记录了很多没有意义的数据，所以就可以用稀疏数组。
• 当一个数组大部分元素为0或者为同一个值的数组时，可以使用稀疏数组来保存该数组。
• 稀疏数组的处理方法是：
  • 记录数组一共有几行几列，有多少个不同的值。
  • 把具有不同值的元素的行列记录在一个小规模的数组中，从而缩小程序的规模
    
• 二维数组转稀疏数组的思路：
  • 遍历原始的二维数组，找到有效数据sum。
  • 根据sum就可以创建稀疏数组sparseArr[sum + 1][3].
  • 将二维数组的有效数据存入稀疏数组。
• 稀疏数组转二维数组的思路：
  • 先读取稀疏数组的第一行，创建几行几列的原始二维数组。
  • 读取稀疏数组后几行的数据，并赋给二维数组即可。
• 代码实现：

public class SpraseArray {
    public static void main(String[] args) {
        //创建原始11*11二维数组
        int[][] array = new int[11][11];
        array[1][2] = 1;
        array[2][3] = 2;
        int sum = 0;//用来计数二维数组的不同个数
        //创建稀疏数组
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                if (array[i][j] != 0){
                    sum++;
                }
            }
            System.out.println();
        }
        //将二维数组转为稀疏数组
        //创建稀疏数组
        int[][] sprasearr = new int[sum + 1][3];
        //稀疏数组的第0行
        sprasearr[0][0] = 11;
        sprasearr[0][1] = 11;
        sprasearr[0][2] = sum;
        //稀疏数组后几行的赋值
        int count = 0;//计数第几行
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
             if (array[i][j] != 0){
                 count++;
                 sprasearr[count][0] = i;
                 sprasearr[count][1] = j;
                 sprasearr[count][2] = array[i][j];
             }
            }
        }
        for (int i = 0; i < sprasearr.length; i++) {
            for (int j = 0; j < sprasearr[i].length; j++) {
                System.out.print(sprasearr[i][j] + "\t");
            }
            System.out.println();
        }

        //将稀疏数组转为原始数组

        int[][] array1 = new int[sprasearr[0][0]][sprasearr[0][1]];
        for (int i = 1; i < sprasearr.length; i++) {
            array1[sprasearr[i][0]][sprasearr[i][1]] = sprasearr[i][2];
        }
        for (int i = 0; i < array1.length; i++) {
            for (int j = 0; j < array1[i].length; j++) {
                System.out.print(array1[i][j] + "\t");
            }
            System.out.println();

        }


    }
}

队列

队列介绍

• 例如银行取号就是就是利用队列，先取号排队，先取号的会先办业务。
• 队列是先进先出。

初始队列

• 将front与rear初始都指向-1。
• 如果rear == maxsize -1时，队列满。
• 如果rear == front 时，队列空。
• 这样就会导致队列不能服用，只能用一次。
• 所以就要用环形队列来解决这个问题

环形队列

• 将front和rear初始都指向0，并且规定rear始终指向队列数据最后一个的后一位。
• 如果(rear + 1) % maxsize == front 时，队列满。这样取模的操作就会解决初始队列不能复用的问题。
• 如果rear == front 时，队列为空。
• 此时队列的有效数据量为(rear + maxsize - front) % maxsize。
• 代码实现

import java.util.Scanner;

public class CicleArrayQueue {

	public static void main(String[] args) {
		CicleArrayQueue1 queue = new CicleArrayQueue1(4);
		Scanner in = new Scanner(System.in);
		boolean loop = true;
		char key = ' ';
		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 = in.next().charAt(0);
			switch (key) {
			case 's':
				queue.showQueue();
				break;
			case 'a':
				System.out.println("输入一个数");
				int value = in.nextInt();
				queue.addQueue(value);
				break;
			case 'g':
				try {
					int res = queue.getQueue();
					System.out.println("取出的数据是:" + res);
				} catch (Exception e) {
					// TODO: handle exception
					System.out.println(e.getMessage());	
				}
				break;
			case 'h':
				try {
					int res1 = queue.headQueue();
					System.out.println("队列头是:" + res1);
				} catch (Exception e) {
					// TODO: handle exception
					System.out.println(e.getMessage());
				}
				break;
			case 'e':
				in.close();
				loop = false;
				break;
			default:
				break;
			}
		}
		System.out.println("程序退出");
		
		
	}

}
//使用数组模拟队列-编写一个ArrayQueue的类
class CicleArrayQueue1 {
	private int maxsize;   //最大容量
	private int rear;    //尾部
	private int front;   //头部
	private int[] arr;   //用数组模拟队列
	
	//创建队列的构造器
	public CicleArrayQueue1(int arrMaxsize) {
		maxsize = arrMaxsize;
		arr = new int[maxsize];
		rear = 0;
		front = 0;
	}
	
	//判断队列是否满
	public boolean isFull() {
		return (rear + 1) % maxsize == front;
	}
	
	//判断队列是否为空
	public boolean isEmpty() {
		return rear == front;
	}
	
	//添加队列
	public void addQueue(int n) {
		if(isFull()) {
			System.out.println("队列已满" + isFull() + front + rear);
			return;
		}else {
			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("队列为空");
		}else {
			for (int i = front; i < front + size(); i++) {
				System.out.println("arr[" + (i % (maxsize-1)) + "]=" + arr[i % maxsize]);
			}
		}
	}
	//获取数据总数
	public int size() {
		return (rear + maxsize - front) % maxsize;
	}
	//显示队列头
	public int headQueue() {
		if(isEmpty()) {
			throw new RuntimeException("队列为空，没有数据");
		}else { 
			return arr[front];
		}
		
	}
	
}