数据结构

数据结构 大体上分为了 线性结构和非线性结构

　　如果再细分，可以把非线性结构分为 图 和 树，多维数组(2维以上)，再加上集合(一般不研究)

线性结构

　　1.数据元素之间存在一对一的关系

　　2.数据存储有两种方式，顺序存储(一维数组)和链式存储(链表)，

　　　　其中顺序存储的叫做线性表，存储的元素物理上是连续的，链式存储的叫做链表，物理上不一定连续

　　3.常见的线性结构

 　　　　　数组，链表，栈，队列

数组

　　稀疏数组：当一个数组里面大部分的值都一样的时候，可以使用稀疏数组(列永远是3)

　　只记录不同值所在的行，列，以及值(存到一个更小的数组中)，以及原数组的大小和不同值的个数

　　比如五子棋

 

左边是正常数组 右边是稀疏数组，右边的意思是

上边的红框存储原数组的大小和有不同的值的个数，下边的红框表示第0行第2列有一个值为1的数据 同理 第0行第3列有一个值为2的数据........

这样存储的容量小于左边的

二维转稀疏

　　获得当前不同值的个数(遍历)n

　　创建稀疏数组 int [n+1] [3]

　　保存数据，第一行一定是二维数组的行，列，n

稀疏转二维

　　先读取第一行，获得n行，m列值 创建二维数组 int [n] [m]

　　 去读后边的数据

import java.io.*;

public class MainTest {
    public static void main(String[] args) throws IOException {
            //直接赋值
            int[][] arr1={{0,0,0,0,0},{1,0,4,0,51},{0,0,0,0,0},{0,0,0,0,0},{0,0,0,0,0}};
            //创建一个对象
           /* int[][] arr2=new int[5][5];
            arr2[1][0]=1;
            arr2[1][2]=4;
            arr2[1][4]=51;*/
           //打印arr1
        System.out.println("二维数组：");
            for(int[] row:arr1) {
                for (int i : row) {
                    System.out.print(i);
                    System.out.print(" ");
                }
                System.out.println();
            }
        //遍历arr1二维数组
            int count=0;
            for(int i=0;i<arr1.length;i++){
                for(int j=0;j<arr1[i].length;j++){
                    if(arr1[i][j]!=0)
                        count++;
                }
            }
            //创建稀疏数组 行为个数+1
            int[][] arrmix=new int[count+1][3];
            arrmix[0][0]=5;
            arrmix[0][1]=5;
            arrmix[0][2]=count;

            //把二维数组的值存入
         //稀疏数组的行 第0行已经存过数据了,从第一行开始
        int n=1;
        for(int i=0;i<arr1.length;i++){
            for(int j=0;j<arr1[i].length;j++){
                    if(arr1[i][j]!=0) {
                        arrmix[n][0] = i;
                        arrmix[n][1] = j;
                        arrmix[n][2] = arr1[i][j];
                        n++;
                    }
                }
            }
        //打印稀疏数组
        System.out.println("稀疏数组：");
        /*System.out.println(arrmix[0][0]);
        System.out.println(arrmix[0][1]);
        System.out.println(arrmix[0][2]);*/
        for(int[] row:arrmix) {
            for (int i : row) {
                System.out.print(i);
                System.out.print(" ");
            }
            System.out.println();
        }

        //恢复为二维数组
        int[][] arr2=new int[arrmix[0][0]][arrmix[0][1]];
        for(int i=1;i<count+1;i++){
            arr2[arrmix[i][0]][arrmix[i][1]]=arrmix[i][2];
        }
        System.out.println("打印恢复后的");
        for(int[] row:arr2){
            for(int i:row){
                System.out.print(i);
                System.out.print(" ");
            }
            System.out.println();
        }

        //保存稀疏数组
        File file =new File("E:"+File.separator+"Data.data");
        System.out.println("保存稀疏数组");
        OutputStream fos = new FileOutputStream(file);
        for(int i=0;i<count+1;i++){
            for(int j=0;j<3;j++){
                fos.write(arrmix[i][j]);
            }
        }
        fos.close();
        System.out.println("保存稀疏数组完成");
        //读取稀疏数组
        System.out.println("读取稀疏数组");
        InputStream fis = new FileInputStream(file);
        int [][] arrymixnew = new int[((int)file.length())/3][3];
        for(int i=0;i<((int)file.length())/3;i++){
           for(int j=0;j<3;j++){
               arrymixnew[i][j]=fis.read();
           }
        }
        for(int[] row:arrymixnew){
            for(int i:row){
                System.out.print(i);
                System.out.print(" ");
            }
            System.out.println();
        }
        System.out.println("读取稀疏数组完成");
    }
}

打印结果

 

队列： 有序，先进先出，先进队列的则先出去，比如排队买东西，又或者营业厅的叫号

数组可以实现队列

package SF;

public class ArrayQueue {
    private int maxSize;
    int a[];
    private int front;  //指向队列头前一个位置
    private int rear;   //指向队列尾数据

    public ArrayQueue(int maxSize){
        this.maxSize=maxSize;
        a=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("队列满");
        }
        rear++;
        a[rear]=n;
    }
    public int getQueue(){
        if(isEmpty()){
            throw new RuntimeException("队列为空");
        }
        front++;
        return a[front];
    }
    public void showQueue(){
        if(isEmpty()){
            System.out.println("队列为空");
        }
        for(int i=0;i<a.length;i++){
            System.out.println(a[i]);
        }
    }
    public int peekQueue(){
        if(isEmpty()){
            throw new RuntimeException("队列为空");
        }
        return a[front+1];
    }
}

循环队列：队列的重复利用(预留一个空数据位)

当然判断队列是否是满的条件也会发生变化，判断队列为空 rear==front

判断队列是否是满的 (rear+1)%maxSize==front

队列有效的数据个数 (rear+maxsize-front)%maxSize

 数组实现循环列表

package SF;

public class CircleArrayQueue {

    private int maxSize;
    int a[];
    private int front;  //指向队列头数据
    private int rear;   //指向队列尾数据的后一个位置

    public CircleArrayQueue(int maxSize) {
        this.maxSize = maxSize;
        a = new int[maxSize];
        //front和rear默认wei0
    }

    public boolean isFull() {
        return (rear+1)%maxSize==front;

    }

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

    public void addQueue(int n) {
        if (isFull()) {
            System.out.println("队列满");
        }
        a[rear] = n;
        rear=(rear+1)%maxSize;
    }

    public int getQueue() {
        if (isEmpty()) {
            throw new RuntimeException("队列为空");
        }
        int i = front;
        front=(front+1)%maxSize;
        return a[i];
    }

    public void showQueue() {
        if (isEmpty()) {
            System.out.println("队列为空");
        }
        for (int i = front; i < getNum(); i++) {
            System.out.println(a[i%maxSize]);
        }
    }

    public int peekQueue() {
        if (isEmpty()) {
            throw new RuntimeException("队列为空");
        }
        return a[front + 1];
    }

    public int getNum(){
        return (rear+maxSize-front)%maxSize;
    }
}

 

链表

链表是以节点方式存储

每个节点包含数据域和next域

next域指向下一个节点(存储下一个节点的位置)

物理上不一定连续，其中还分为带头(头结点)链表和不带头(不带头链表)

不排序的带头链表

package SF;

public class SingleLinkListDemo {
    public static void main(String[] args){
       PersonNode personNode1 = new PersonNode(1,"zhangsan",1);
       PersonNode personNode2 = new PersonNode(2,"lisi",2);
       PersonNode personNode3 = new PersonNode(3,"wangwu",3);
       SingleLinkList sll = new SingleLinkList();
       sll.addNode(personNode1);
       sll.addNode(personNode2);
       sll.addNode(personNode3);
       sll.list();
    }
}
class SingleLinkList{
    //先初始化一个头节点
    private PersonNode pn = new PersonNode(0,"",0);
    //添加节点
    public void addNode(PersonNode personNode){
       PersonNode temp = pn;
       //遍历链表寻找最后一个节点
       while(true){
           //找到了
           if(temp.nextPersonNode==null){
               break;
           }
           //没找到
           temp=temp.nextPersonNode;
       }
       //找到后推出循环，此时temp指向最后一个节点，并将传入的新节点赋给temp，此时的temp.nextPesonNode指向新节点
       temp.nextPersonNode=personNode;
    }
    //显示节点
    public void list(){
        //判断是否为空链表
        if(pn.nextPersonNode==null){
            System.out.println("链表为空");
        }
        //辅助节点
        PersonNode temp = pn.nextPersonNode;
        //遍历
        while(true){
            if(temp == null){
               break;
            }
            System.out.println(temp);
            temp=temp.nextPersonNode;
        }
    }
}
//定义节点
class PersonNode{
    private int id;
    private String name;
    private int age;
    public PersonNode nextPersonNode;
    public PersonNode(int id,String name,int age){
        this.id=id;
        this.name=name;
        this.age=age;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public PersonNode getNextPersonNode() {
        return nextPersonNode;
    }

    public void setNextPersonNode(PersonNode nextPersonNode) {
        this.nextPersonNode = nextPersonNode;
    }

    //方便显示
    @Override
    public String toString() {
        return "PersonNode{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

排序的带头链表

public void addByOrder(PersonNode personNode){
        PersonNode temp = pn;
        //确保不会重复添加
        boolean flag=false;
        while(true) {
            //temp是最后一个节点
            if (temp.nextPersonNode == null) {
                break;
            }
            if(temp.nextPersonNode.getId()>personNode.getId()){//找到位置temp后插入
                break;
            }else if(temp.nextPersonNode.getId()==personNode.getId()){  //相同id已经存在
                    flag=true;
                    break;
            }else {
                temp=temp.nextPersonNode;
            }
        }
        if(flag){
            System.out.println("要插入数据已存在，不能重复插入");
        }else{
            //下边两句顺序不能搞反，不然找不到了
            personNode.nextPersonNode = temp.nextPersonNode;
            temp.nextPersonNode = personNode;
        }
    }

删除节点

public void del(PersonNode personNode){
       boolean flag=false;
       if(pn.nextPersonNode==null){
           System.out.println("链表为空，不能删除");
       }
       PersonNode temp = pn;
       while(true){
           if(temp.nextPersonNode==null){
               break;
           }
           if (temp.nextPersonNode.getId()==personNode.getId()){
               flag=true;
               break;
           }
           temp=temp.nextPersonNode;
       }
        if(!flag){
            System.out.println("没有找到要删除的节点");
        }else{
            temp.nextPersonNode=temp.nextPersonNode.nextPersonNode;

        }

    }

修改节点

public void update(PersonNode personNode){
        if(pn.nextPersonNode==null){
            System.out.println("链表为空");
        }
        PersonNode temp = pn.nextPersonNode;
        //判断是否找到的标志
        boolean flag = false;
        while(true){
            //遍历完毕没找到
            if(temp==null){
                break;
            }
            if(temp.getId()==personNode.getId()){
                flag = true;
                break;
            }
                temp=temp.nextPersonNode;
        }
        if(!flag){
            System.out.println("未找到要修改的节点");
        }else{
            temp.setName(personNode.getName());
            temp.setAge(personNode.getAge());
        }
    }

 

 ------------------------------------------未完待续，继续补充---------------------------------------------------------------