day2 稀疏数组 和环形数列

稀疏数组的应用场景 在一个数组中有多个相同的数据的时候 
可以使用稀疏数组来保存该数组来达到缩小数组规模的效果
例子 对一个五子棋棋盘的存盘与复盘  练习写的例子

import java.util.ArrayList;
import java.util.List;

public class xssz {
    public static void main(String[] args) {
        //假设数组x是五子棋棋盘
        int [][]x = new int[5][5];
        x[0][3] = 1;
        x[4][2] = 2;
        x[2][4] = 1;
        x[3][1] = 2;
        System.out.println("正常的表示方法");
        ErInt(x);

        //将数组转为稀疏数组z

        List<Integer> zc = new ArrayList<Integer>();
        for (int i = 0; i < x.length; i++) {
            for (int j = 0; j < x[i].length; j++) {
                //如果有不同于重复数据的数
                if (x[i][j]!=0){
                    //分别记录这个数的行 列 值
                    zc.add(i);
                    zc.add(j);
                    zc.add(x[i][j]);
                }
            }
        }
        //看有多少不是重复的数据 来创建相应大小的稀疏数组
        int count = zc.size()/3;
        int [][]z = new int[count+1][3];
        z[0][0] = x.length;//原来数组的行数
        z[0][1] = x[0].length;//原来数组的列数
        z[0][2] = count; //原来数组有多少个不同于重复数据的数
        int index = 0;//用来将集合zc的值遍历存给z
        for (int i=1;i<z.length;i++){
            for (int j = 0; j < z[i].length; j++) {
                z[i][j] = zc.get(index);
                index++;
            }
        }
        System.out.println("转换为稀疏数组-存盘");
        ErInt(z);

        //将存盘的稀疏数组恢复成棋盘
        int [][]hf = new int[z[0][0]][z[0][1]];//其中重复的数据为零
        // 而数组中的值没有赋值的情况下默认为0所以不用恢复重复数组 其实第一行
        // 第三个储存其中有效数据个数这个值没啥用？存储为重复的值不好嘛..
        for (int i = 1; i <= z[0][2]; i++) {
            hf[z[i][0]][z[i][1]] = z[i][2];
        }
        System.out.println("通过稀疏数组恢复后的棋盘");
        ErInt(hf);
    }
    public static void ErInt(int x[][]){
        for (int i = 0; i < x.length; i++) {
            for (int j = 0; j < x[i].length; j++) {
                System.out.print(x[i][j]+"\t");
            }
            System.out.println();
        }
    }
}

环形队列 ：可以用数组实现，也可以使用循环链表实现 队列的特点是取出的时候从头部取出 加入的时候从尾部加入 练习写的例子

import java.util.Scanner;

public class queueTest {
    public static void main(String[] args) {
        Scanner sr = new Scanner(System.in);
        queue dl = new queue(5);
        while (true){
            System.out.print("请输入指令:");
            String order = sr.next();
            if (order.equals("get")){
                //取出
                try {
                    String g = dl.getQueue();
                    System.out.println("取出："+g);
                 //如果爆出异常就输出异常内容
                }catch (Exception g){
                    System.out.println(g.getMessage());
                }
            }
            if (order.equals("add")){
                System.out.print("请输入数据：");
                String addvalue = sr.next();
                dl.addQueue(addvalue);
            }
            if (order.equals("look")){
                dl.lookQueue();
            }
            if (order.equals("gethead")){
                try {
                    String gh = dl.gethead();
                    System.out.println("头数据为："+gh);
                    //如果爆出异常就输出异常内容
                }catch (Exception gh){
                    System.out.println(gh.getMessage());
                }
            }
            if (order.equals("exit")){
                System.out.println("关闭队列");
                sr.close();
                break;
            }
        }
    }
}
 class queue{
    int maxSize;//队列的长度
    int head;//队列头
    int tail;//队列尾部
    String []list;//队列
    //创建队列 构造方法
    public queue(int maxSizevalue){
        maxSize = maxSizevalue;
        list = new String[maxSize];
        head = 0;//队列头 表示队列头数据的位置
        tail = 0;//队列尾  表示队列尾数据的后一个位置 为了避免只有一个数据时head也等于tail 无法判断是否为空
    }
    //查看队列是否为空
    public boolean isEmpty(){
        return head==tail;
    }
    //查看队列是否满了
    public boolean isFull(){
        return (tail+1)%maxSize==head;//tail（尾部数据索引+1）+1 % maxSize然后取余队列的长度 ==head 如果等于头部的索引 那么队列已满
        //这个公式会使队列的真实长度是给定的最大长度-1 也就是会空闲一个队列 如果不空闲一格 将tail后面的+1去掉 那么就会出现队列既为空 又 满了的情况
    }
    //加入队列
     public void addQueue(String value){
        //查看队列是否满了
        if (isFull()){
            System.out.println("队列已满");
            return;
        }
        if (tail==maxSize){
            tail=0;
        }
        list[tail] = value;
        tail++;
        System.out.println(tail+"  "+isFull());
     }
     //取出数据
     public String getQueue(){
        //查看队列是否为空
        if (isEmpty()){
            //因为是有返回值的方法所以抛出异常而不是输出提示
            throw new RuntimeException("队列为空，无法取得数据");
        }
        if (head==maxSize){
            head=0;
        }
        head++;
        return list[head-1];
     }
     //查看队列情况
     public void lookQueue(){
         //查看队列是否为空
         if(isEmpty()){
             System.out.println("队列为空!无法查看队列");
             return;
         }
         int index = head;
         int sx = 1;
         System.out.println(index+"   "+(tail));
         //结束条件是当索引index=尾部
         while (index!=tail){
             //如果已经到最后一格那个不使用的空格子了 就从头开始
             if (index==maxSize){
                 index = 0;
             }
             System.out.println(sx+"号:"+list[index]);
             sx++;
             index++;
         }
     }
     //获取队列的头
     public String gethead(){
         //查看队列是否为空
        if (isEmpty()){
            throw new RuntimeException("队列为空!无法获取头数据");
        }
        return list[head];
     }
}