本篇文章有部分内容摘抄至尚硅谷

1.数据结构与算法概述

1.1数据结构和算法的关系

数据结构与算法的关系

1. 数据(data)结构(structure)是一门研究组织数据方式的学科

2. 程序=数据结构+算法

3. 数据结构是算法的基础

1.2数据结构和非线性结构

线性结构:

1. 线性结构作为最常用的数据结构,其特点是数据元素之间存在一对一的线性关系

2. 线性结构有两种不同的存储结构,顺序存储结构和链式存储结构 顺序存储结构的线性表称顺序表,顺序表中的存储元素是连续的

3. 链式存储的线性表称为链表,链表中的存储不一定是连续的,元素节点中存放数据元素以及相邻元素的地址信息

4. 线性结构常见的有:数组,队列,链表和栈

非线性结构:

1. 非线性结构包括:二维数组,多维数组,广义表,树结构,图结构

2.稀疏数组和队列

2.1稀疏数组

在一个棋盘中有很多没用的数据,因此提出稀疏数组

1. 记录数组一共有几行几列,有多少个值

2. 把具有不同值的元素的行列及值记录在一个小规模的数组中,从而缩小规模

 代码实现:

package SparseArraysAndQueues;

public class SparseArray {
    public static void main(String[] args) {
        int[][]arr=new int[10][10];//创建棋盘
        arr[1][2]=1;//黑
        arr[2][3]=2;//白
        arr[3][4]=1;
        arr[4][5]=2;
        //将原棋盘有棋的地方打印出来
        int count=0;//定义记录第几个棋子
        int[][]newArr=new int[5][3];//稀疏数组用来存放棋盘
        newArr[0][0]=10;//存放原棋盘行
        newArr[0][1]=10;//列
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                if(arr[i][j]!=0){
                    count++;
                    newArr[count][0]=i;
                    newArr[count][1]=j;
                    newArr[count][2]=arr[i][j];
                }
            }
        }
        newArr[0][2]=count;//用来存放棋子个数
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j <arr[i].length ; j++) {
                System.out.print(arr[i][j]+" ");
            }
            System.out.println("");
        }
        System.out.println("===============");
        for (int i = 0; i < newArr.length; i++) {
            for (int j=0;j<newArr[i].length;j++){
                System.out.print(newArr[i][j]+" ");
            }
            System.out.println();
        }
    }
}

2.2队列

2.2.1数组实现队列

• 队列是一个有序列表,可以用数组或是链表来实现

• 遵循先进先出的原则,即先存入队列的数据,要先取出 后存入的要后取出

import com.sun.org.apache.xpath.internal.SourceTree;

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        ArrayQueue arrayQueue = new ArrayQueue(10);
        arrayQueue.isEmpty();
        arrayQueue.isFull();
        Scanner sc = new Scanner(System.in);
        boolean a=true;
        while (a){
            System.out.println("====================");
            System.out.println("选择执行的操作");
            System.out.println("1.添加数据 2.取出数据 3.展示队列 0.退出队列");
            int n=sc.nextInt();
            switch (n){
                case 1:
                    System.out.println("输入要添加的数据");
                    arrayQueue.addQueue(sc.nextInt());
                    break;
                case 2:
                    try {
                        System.out.println("成功取出数据"+arrayQueue.getNumber());
                    }catch (RuntimeException e){
                        System.out.println("队列为空不能删除数据");
                    }
                    break;
                case 3:
                    arrayQueue.showQueue();
                    break;
                case 0:
                    a=false;
                    break;
            }
        }
        System.out.println("程序结束欢迎下次使用");
    }

}
class ArrayQueue{
    private int front;
    private int rear;
    private int maxSize;
    private int arr[];
    public ArrayQueue(int maxSize){
        front=-1;
        rear=-1;
        arr=new int[maxSize];
        this.maxSize=maxSize;
    }
    //判断队列是否满了
    public boolean isFull(){
        return this.rear==this.maxSize-1;
    }
    //判断队列是否为空
    public boolean isEmpty(){
      return this.rear==this.front;
    }
    //添加数据
    public void addQueue(int n){
        if(isFull()){
            System.out.println("队列满了不能添加数据");
            return;
        }
        rear++;
        arr[rear]=n;
        System.out.println("成功添加"+n);
    }
    //删除数据
    public void deleteQueue(){
        if(isEmpty()){
            System.out.println("队列为空不能删除数据");
            return;
        }
        front++;
        arr[front]=0;
    }
    //得到某个数据
    public int getNumber(){
        if(isEmpty()){
            throw new RuntimeException();
        }
        front++;
        int n=arr[front];
        arr[front]=0;
        return n;
    }
    //显示队列数据
    public void showQueue(){
        if(isEmpty()){
            System.out.println("队列没有数据");
            return;
        }
        for (int i = front+1; i <=rear ; i++) {
            System.out.println(arr[i]);
        }
    }
}

2.2.2数组实现循环队列

1. front变成指向队列的第一个元素 初识front=0

2. rear变成最后一个元素后一个位置 rear初识为0 因为希望空出一个空间作为约定

3. (rear+1)%maxSize=front(满)

4. 队列为空条件rear==front空

5. 判断有多少个元素(rear+maxsize-front)%maxsize

class CircularQueue1 {
    private int[] array;
    private int front;
    private int rear;
    private int capacity;

    public CircularQueue1(int capacity) {
        this.capacity = capacity;
        this.array = new int[capacity];
        this.front = 0;
        this.rear = 0;
    }

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

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

    public boolean enqueue(int item) {
        if (isFull()) {
            return false;
        }
        array[rear] = item;
        rear = (rear + 1) % capacity;
        return true;
    }

    public int dequeue() {
        if (isEmpty()) {
            return -1;
        }
        int item = array[front];
        front = (front + 1) % capacity;
        return item;
    }
    public void show(){
        for (int i = 0; i <array.length ; i++) {
            System.out.println(array[i]);
        }
    }
}