数据结构与算法学习笔记Day1

程序=数据结构+算法

Day 1

 

增强for循环：实现对数组的遍历。

实现对二维数组的遍历：

 for(int [] row :chessArr1)

 {

 for (int data : row)

 {

 System.out.printf("%d\t",data);



 }

 System.out.printf("\n");

 }

}

 

在java中是没有真正的二维数组的。所以在外层循环中定义了一个字符串数组类型的变量，而内层是真正定义了一个字符串类型。

 

稀疏数组

package Arrayy;

public class SparseArray {

	public static void main(String[] args) {
	 int chessArr1[][]=new int [11][11];
	 chessArr1[1][2]=1;
	 chessArr1[2][3]=2;
	 chessArr1[5][6]=2;
	 for(int [] row :chessArr1)
	 {
		 for (int data : row)
		 {
			 System.out.printf("%d\t",data);
		 }
		 System.out.printf("\n");
	 }
	 
	 //遍历二维数组
	 int sum=0;
	for(int i = 0;i<11;i++)
	{
		for(int j=0;j<11;j++)
		{
			if(chessArr1[i][j]!=0)
			{
				sum++;
			}
		}
		
	}
	int SparseArray[][]=new int [sum+1][3];
	SparseArray[0][0]=11;
	SparseArray[0][1]=11;
	SparseArray[0][2]=sum;
	int count=0;
	for(int i = 0;i<11;i++)
	{
		for(int j=0;j<11;j++)
		{
			if(chessArr1[i][j]!=0)
			{
				count++;
				SparseArray[count][0]=i;
				SparseArray[count][1]=j;
				SparseArray[count][2]=chessArr1[i][j];
			}
		}
	}
	System.out.println();
	System.out.println("稀疏数组：");
	for (int i=0;i<SparseArray.length;i++) {
		
		System.out.printf("%d\t%d\t%d\t\n",SparseArray[i][0],SparseArray[i][1],SparseArray[i][2]);
	}
	//稀疏数组恢复为二维数组
	System.out.println("复原后的二维数组");
int chessArray2[][]=new int [SparseArray[0][0]][SparseArray[0][1]];
for (int i=1;i<SparseArray.length;i++) {
chessArray2[SparseArray[i][0]][SparseArray[i][1]]=SparseArray[i][2];
}
for(int [] row :chessArray2)
{
	 for (int data : row)
	 {
		 System.out.printf("%d\t",data);
	 }
	 System.out.printf("\n");
}
int sum1 = 0;
for(int [] row :chessArray2)
{
	 for (int data : row)
	 {
		sum1+=data ;
	 }
	 System.out.printf("");
}
System.out.printf("%d",sum1);
	}
}

 

=是赋值 == 是判断

 

队列（用数组实现）

 

rear指向数组的尾部数据，初始值为-1；

Front指向的是数组的头部的前一个数据，初始值也为-1；

判断队列为空，front==rear；

判断队列为满，rear=maxsize-1；

队列中的有效个数：rear-front

package Queue;

public class Queue {
	int maxSize;
	int front;
	int rear;
	int [] arr;
	//建立一个构造器实现方法的初始化
		public  Queue(int maxsize)
		{
			maxSize=maxsize;
			arr=new int [maxSize];
			front=-1;
			rear=-1;
		}
		
		public boolean isFull() {
			
			return rear == maxSize-1;
			
		}
		
		public boolean isEmpty() {
			
			return rear==front;
		}
	public void add(int n)
	{
		if(isFull()) {
		System.out.println("此队列已满");
			return;
		}
		rear++;
		arr[rear]=n;
	}
		public int  get()
		{
			if(isEmpty()) {
				throw new RuntimeException("队列为空");
			}else {
			front++;
			return arr[front];
			}
		}
	public void show() {
			if(isEmpty()) {
				System.out.println("队列为空");
			}
			for (int i = 0; i < arr.length; i++) {
				System.out.printf("arr[%d]=%d\n",i,arr[i]);
			}
				
			
		}

	
}
package Queue;

import java.util.*;

public class Queue1 {

	public static void main(String[] args) {
		Scanner in =new Scanner(System.in);
		Queue q =new Queue(30);
		boolean loop =true;
		String key ;
		while (loop) {
			System.out.println("输入s显示队列");
			System.out.println("输入a增加元素");
			System.out.println("输入g取出元素");
			key=in.next();
			switch (key) {
			case "s":
				q.show();
				break;
			case "a":
				System.out.println("输入一个值");
				int value =in.nextInt();
				q.add(value);
				break;
			case "g":
	
				break;
			default:
				break;
			}
		}
		}
	}

 

二维数组的练习

杨辉三角

package Arrayy;

import java.util.Scanner;

public class yanghuisanjiao {

public static void main(String[] args) {
	int yanghui[][]=new int [10][];
	for (int i = 0; i < yanghui.length; i++) {
		yanghui[i]=new int [i+1];
		//建立每行的元素多少
		yanghui[i][0]=yanghui[i][i]=1;//每一行的首末都为1
		for (int j = 1; j < yanghui[i].length-1; j++) {
			yanghui[i][j]=yanghui[i-1][j-1]+yanghui[i-1][j];
			
		}
	}
for (int i = 0; i < yanghui.length; i++) {
	for (int j = 0; j < yanghui[i].length; j++) {
		System.out.print(yanghui[i][j]+"");
	}
	System.out.println();
}
}
}

 

环形队列：

 

package LoopQueue;

import java.util.Scanner;
class CircleQueue {
		int maxSize;
		int front;
		int rear;
		int [] arr;
		//建立一个构造器实现方法的初始化
			public  CircleQueue(int maxsize)
			{
				maxSize=maxsize;
				arr=new int [maxSize];
				front=0;
				rear=0;
			}
			
			public boolean isFull() {
				
				return (rear+1)% maxSize ==front ;
				
			}
			
			public boolean isEmpty() {
				
				return rear==front;
			}
		public void add(int n)
		{
			if(isFull()) {
			System.out.println("此队列已满");
				return;
			}
			
			arr[rear]=n;//
			rear=(rear+1)% maxSize;//要考虑到数组越界的问题，因为是环形队列。
		}
		
			public int  get()
			{
				if(isEmpty()) {
					throw new RuntimeException("队列为空");
				}else {
				int value=arr[front];//程序运行到return时就结束了，无法再把front后移
				front =(front+1)% maxSize;//要考虑到数组越界的问题，因为是环形队列。
				return value;
				}
			}
		public void show() {
				if(isEmpty()) {
					System.out.println("队列为空");
				}
				//从front开始遍历，遍历的个数为数组中的有效个数
				for (int i = front; i < front+size(); i++) {
					System.out.printf("arr[%d]=%d\n",i % maxSize,arr[i % maxSize]);
				}
			}

		 public int size() {
			 
			 
			 return (rear+maxSize-front)% maxSize;
		 }
		
		
		
	}
	
	public class LoopQueue {
	public static void main(String[] args) {
		Scanner in =new Scanner(System.in);
		CircleQueue q =new CircleQueue(3);
		boolean loop =true;
		String key ;
		while (loop) {
			System.out.println("输入s显示队列");
			System.out.println("输入a增加元素");
			System.out.println("输入g取出元素");
			key=in.next();
			switch (key) {
			case "s":
				q.show();
				break;
			case "a":
				System.out.println("输入一个值");
				int value =in.nextInt();
				q.add(value);
				break;
			case "g":
	
				break;
			default:
				break;
			}
		}
		}
	
}

 

Front指向数组的第一个；初始值为0；

Rear指向数组的最后一个的后一个，初始为0；

判断为空，front==rear；

判断为满，(rear+1)%maxsize=front;

有效个数：（rear+maxsize-front）%maxsize;

 

 

结论：rear指向数组的最后一个的后一个是为了预留空间，这个预留的空间是动态变化的。

 

 

第一天收获总结：for的加强循环，方便了对数组进行遍历。实现了用数组来模拟队列，队列的规则是先进先出。用rear指向队列的尾部，用front指向数组头部的前一个。当rear=front 时数组为空，当rear=maxsize-1时数组为满。完成了二维数组的一个应用，实现了杨辉三角。实现了用数组模拟环形队列，rear指向队列尾部的后一位，是为了预留空间。数组实际可输入的大小为maxsize-1。front指向数组的头部。当rear=front时数组为空，当(rear+1)%maxsize=front时，数组为满。其中的有效个数表示为（rear+maxsize-front）%maxsize。由于是环形队列需要考虑到数组越界的问题所以需要取%。