数据结构和算法概述(java)

1.数据结构和算法的关系

1. 数据data结构是一门研究组织数据方式的学科，
2. 程序=数据结构+算法
3. 数据结构是算法的基础

2.线性结构和非线性结构

2.1线性结构

1. 线性结构作为最常用的数据结构，其特点是数据元素之间存在一对一的线性关系。
2. 线性结构有两种不同的存储结构，即顺序存储结构（数组）和链式存储结构（链表）。顺序存储的线性表成为顺序表，顺序表中的存储元素是连续的。
3. 链式存储的线性关系称为链表，链表中的存储元素不一定连续，
4. 线性结构常见的有：数组，队列，链表和栈。

2.2非线性链表

非线性链表包括：二维数组，多维数组，广义表，树结构，图结构。

3,稀疏数组和对列

因为二维数组的很多值是默认值0，或者一个值得数组时，可以使用稀疏数组。

稀疏数组的处理方法是：

1. 记录数组一共有几行几列，有多少不同的值
2. 把具有不同之的元素的行列及值记录在一个小规模的数组中，从而缩小程序的规模

稀疏数组的举例说明：

二维数组转换 稀疏数组思路：

1. 遍历原始的二维数组，得到有效数据的个数sum
2. 根据sum就可以创建稀疏数组
3. 将二维数组中的值存入稀疏数组

代码：

1.先遍历二维数组，获取二维数组中非0数据的个数
    int sum=0;
    //假设数组为a[][]
    //X表示行数，Y标识列数
    for(int i=0;i<X;i++){
        for(int j=0;j<Y;j++){
            if (a[i][j]!=0){
                sum++;
            }
        }
    }
    
2.创将对应的稀疏数组
//int[sum+1][3]-->[3]第一列表示二维数组的行数，第二列表示二维数组的列数，第三列表示非零个数。
    int sparseArr[][]=new int[sum+1][3];
    sparseArr[0][0]=X;
    sparseArr[0][1]=Y;
    sparseArr[0][3]=sum;
    
//遍历二维数组，将非0的值存入spareArr中
    int count=0；
    //记录是第几个非0数据
    for(int i=0;i<X;i++){
        for(int j=0;j<Y;j++){
            if(a[i][j]!=0){
                count++;
                sparseArr[count][0]=i;
                sparseArr[count][1]=j;
                sparseArr[count][3]=a[i][j];
            }
        }
    }

稀疏数组转换 二维数组思路：

1. 先读取稀疏数组第一行，根据第一行的数据闯将二维数组。
2. 再读取稀疏数组后几行的数据，并赋值给二维数组。

代码：

//1.定义数组b存放二维数组
	int b[][]=new int[sparseArr[0][0]][sparse[0][1]];
//2.在读取稀疏数组后的几行数据(从第二行开始)，并赋值肥原二维数组即可
    for(int i=1;i<sparseArr.length;i++){
        b[sparseArr[i][0]][sparseArr[i][1]]=sparseArr[i][2];
    }

4.队列

4.1队列介绍

1. 队列是一个有序列表，可以用数组或是链表来实现。
2. 遵循先入先出的原则。即：先存入队列的数据，要先取出。后存入的数据要后取出。

4.2.1数组模拟对队列思路

1. 队列本身是有序列表，若使用数组的结构来存储队列的数据，则队列中maxSize是该队列的最大容量。
2. 因为队列的输出，输入是分别从前后端来处理，因此需要两个变量front 及rear分别记录队列前后端的下标，front会随着数据输出而改变，而rear则是随着数据输入而改变，
3. 当我们将数据存入队列时称为“addQueue”，addQueue的处理需要有两个步骤：思路分析
   1. 将尾指针往后移：rear+1，当front==rear 空
   2. 若尾指针rear小于队列的最大下标maxSize-1，则将数据存入rear所指的数组元素中，否则无法存入数据。当rear==maxSize-1 队列满

代码：

(用数组模拟)

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;//指向队列头部，分析出front是指向队列头的前一个位置
		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++;//让rear后移
		arr[rear]=n;
	}
	
	//获取队列的数据，出队列
	public int getQueue(){
		if(isEmpty()){
			//通过抛出异常
			throw new RuntimeException("队列空，不能取数据");
		}
		front++;//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];
	}
}

#缺点：

该数组只能使用一次，没有达到复用效果。

4.2.2数组模拟对环形队列思路

对4.2.1中的数组模拟队列的优化，充分利用数组，因此将数组看作是一个环形的。(通过取模的方法来实现)

分析说明：

1. 尾索引的下一个为头索引时表示队列满，即将队列容量空出一个作为约定，这个再做判断队列满的时候需要注意(rear+1)%maxSize==front 则满。
2. rear=front 则空。

思路：

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

代码：

(用数组模拟)

class CircleArray{
	private int maxSize;//表示数组的最大容量
	private int front;//指向队列的第一个元素，也就是说arr[front]就是队列的第一个元素，
	//front的初始值=0
	private int rear;//队列尾
	//rear变量的含义：rear指向队列的最后一个元素的后一个位置，因为希望空出一个空间作为约定。
	//rear的初始值=0
	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=(rear+1)%maxSize;
	}
	
	//获取队列的数据，出队列
	public int getQueue(){
		if(isEmpty()){
			//通过抛出异常
			throw new RuntimeException("队