数据结构和算法基础

巩固基础，砥砺前行 。
只有不断重复，才能做到超越自己。
能坚持把简单的事情做到极致，也是不容易的。

java程序员要学习那些技能 : 作为一名Java程序员，要学习以下技能：

1. Java编程语言：掌握Java编程语言的语法和基本概念，如数据类型、控制流、面向对象编程等。
2. 数据库：了解数据库的基本概念和SQL语言，掌握至少一种数据库管理系统（如MySQL、Oracle、PostgreSQL等）的使用。
3. Web开发：掌握Web开发技术，如HTML、CSS、JavaScript、Servlet、JSP等。
4. 框架：掌握至少一种主流的Java框架，如Spring、Hibernate、Struts等，能够使用框架快速开发Web应用。
5. 版本控制：了解版本控制工具（如Git、SVN等）的基本使用。
6. 设计模式：了解常用的设计模式，如工厂模式、单例模式、观察者模式等，能够应用到实际开发中。
7. 网络编程：掌握Java网络编程技术，如Socket、TCP/IP协议等。
8. 多线程编程：了解多线程编程的基本概念和技术，能够使用Java多线程编程。
9. 数据结构和算法：了解基本的数据结构和算法，如栈、队列、排序、查找等，能够应用到实际开发中。
10. Linux操作系统：了解Linux操作系统的基本概念和命令行操作，能够在Linux环境下进行Java开发。

数据结构和算法

程序= 数据结构+算法
数据结构是算法的基础

Java常用算法有哪些 : Java常用算法包括：

1. 排序算法：冒泡排序、选择排序、插入排序、希尔排序、归并排序、快速排序、堆排序、计数排序、桶排序、基数排序等；2. 查找算法：顺序查找、二分查找、哈希查找等；
2. 图算法：广度优先搜索、深度优先搜索、最短路径算法、最小生成树算法等；
3. 字符串算法：KMP算法、BM算法、Sunday算法等；
4. 动态规划算法：背包问题、最长公共子序列问题、最短路径问题等；
5. 贪心算法：活动安排问题、背包问题等；
6. 分治算法：归并排序、快速排序等；
7. 回溯算法：八皇后问题、迷宫问题等。

Java常用的数据结构都有哪些 : Java常用的数据结构包括：

1. 数组（Array）：一组相同类型的数据元素的集合，可以通过下标访问元素。
2. 链表（Linked List）：由一系列节点组成，每个节点包含数据和指向下一个节点的指针。
3. 栈（Stack）：一种后进先出（LIFO）的数据结构，只允许在栈顶进行插入和删除操作。
4. 队列（Queue）：一种先进先出（FIFO）的数据结构，允许在队尾进行插入操作，在队头进行删除操作。
5. 堆（Heap）：一种特殊的树形数据结构，满足堆序性质，可以用来实现优先队列等数据结构。
6. 树（Tree）：一种非线性的数据结构，由节点和边组成，每个节点可以有多个子节点。
7. 图（Graph）：一种非线性的数据结构，由节点和边组成，可以表示各种复杂的关系。
8. 散列表（Hash Table）：一种利用哈希函数将元素映射到下标的数据结构，可以实现快速的查找和插入操作。
9. 哈希集合（HashSet）：基于散列表实现的集合，可以快速地进行元素的查找和插入操作。
10. 哈希映射（HashMap）：基于散列表实现的映射，可以快速地进行键值对的查找和插入操作。

问题1：字符串匹配问题。str1 是否完全包含 str2

1）暴力匹配
2）KMP算法

问题2：汉诺塔游戏

问题3：8皇后问题

问题4：骑士周游

问题5：写出单链表表示的字符串类以及字符串节点类的定义，并依次实现他的构造函数、以及计算字符串的长度、串赋值、判断两串相等、求子串、两串拼接、求子串在串中的位置等成员函数

问题6：使用二维数组保存棋盘上的数据，如何判断输赢？完成存盘退出和继续上局的功能

棋盘 二维数组->稀疏数组->写入文件
读取文件->稀疏数组->棋盘

问题7：约瑟夫问题（丢手帕），编号为 1，2，3，4……n的人围成一圈，约定编号为K（1<=K<=n）的人从1开始报数,数到m的那个人出列，然后从m的下一位又开始报数，数到m的那个人又出列，依次类推，直到所有人都出列为止，由此产生的一个出队的编号的序列

问题8：修路问题

问题9：最短路劲

稀疏数组和队列

将棋盘上的数据存储下来，可以使用二维数组来存储，没有棋子的可以使用默认的0，因此记录了很多没有意义的数据
–>优化：可以使用稀疏数组来存储

稀疏数组
记录数组有多少行 多少列;
把具体的有数据的行列以及数据记录下来，缩小程序的规模

棋盘数据存储和恢复：
使用稀疏数组来保留二维数组中有效的数据;
将稀疏数组存盘,同时将稀疏数组恢复为二维数组;

代码实现

package com.ttzz.a3;

public class SparseArray {
	// 这是一个10*10的棋盘
	private static final int ROW_COL = 10;
	private static final int BLACK = 1;
	private static final int WHITE = 2;
	public static void main(String[] args) {
		int[][] aa = new int[ROW_COL][ROW_COL];
//		 System.out.println("棋盘：");
//		 printArray(aa);
		// 棋盘填充数据
		aa[3][4] = BLACK;
		aa[7][5] = BLACK;
		aa[3][2] = BLACK;
		aa[5][1] = BLACK;
		aa[6][6] = WHITE;
		aa[8][3] = WHITE;
		aa[1][1] = WHITE;
		aa[4][0] = WHITE;
//		 printArray(aa);
		int size = 0;// 有效数据
		for (int i = 0; i < ROW_COL; i++) {
			for (int j = 0; j < ROW_COL; j++) {
				if(aa[i][j]!=0) {
					size++;
//					System.out.println(aa[i][j]);
				}
			}
		}
//		System.out.println("size="+size);
		int bb[][] = new int[size+1][3];
		bb[0][0] = ROW_COL;
		bb[0][1] = ROW_COL;
		bb[0][2] = size;
		int count = 0;
		for (int i = 0; i < ROW_COL; i++) {
			for (int j = 0; j < ROW_COL; j++) {
				if(aa[i][j]!=0) {
					count++;
//					System.out.println(count+","+i+","+j+","+aa[i][j]);
					bb[count][0] = i;
					bb[count][1] = j;
					bb[count][2] = aa[i][j];
				}
			}
		 }
//		printArray(bb);
		//将稀疏数组转为数组
		int cc[][] = new int[bb[0][0]][bb[0][1]];
//		printArray(cc);
		for (int i = 1; i < bb.length; i++) {
			for (int j = 0; j < bb[i].length; j++) {
				System.out.println(i+","+j+","+bb[i][j]); 
				cc[bb[i][0]][bb[i][1]] = bb[i][2];
			}
		}
		printArray(cc);
	}
	public static void printArray(int[][] item) {
		for (int i = 0; i < item.length; i++) {
			for (int j = 0; j < item[i].length; j++) {
				System.out.printf("%d\t", item[i][j]);
			}
			System.out.println();
		}
	}

}

数据结构和算法-(排序算法-冒泡排序)

1.概念：什么是稳定排序和非稳定性排序？

相同元素排序中之后，顺序和之前的顺序一样，则为稳定排序，否则为非稳定性排序。道听途说，不足为惧。都是抄的，天下文章一大抄，先抄了再说。

2. 冒泡排序代码实现

2.1 普通版本

​
	public static void sort1(int arr[]) {
		for (int i = 0; i < arr.length; i++) {
			for (int j = 0; j < arr.length-i-1; j++) {
				int item = 0;
				if(arr[j]>arr[j+1]) {
					item = arr[j];
					arr[j] = arr[j+1];
					arr[j+1] = item;
				}
			}
		}
	}

​

2.2 优化版本 某一步之后，后面的代码有序了，后面的代码就不排序了。

​
public static void sort2(int arr[]) {
		for (int i = 0; i < arr.length; i++) {
			boolean iscontinue = true; 
			for (int j = 0; j < arr.length-i-1; j++) {
				int item = 0;
				if(arr[j]>arr[j+1]) {
					item = arr[j];
					arr[j] = arr[j+1];
					arr[j+1] = item;
					iscontinue = false;
				}
			}
			if(iscontinue) {
				break;
			}
		}
	}

​

2.3 优化版2

​
public static void sort3(int arr[]) {
		int sortborder = arr.length-1;//表示比较的边界
		int lastcomindex = 0; //最后一次比较的位置
		for (int i = 0; i < arr.length; i++) {
			boolean iscontinue = true; 
			for (int j = 0; j < sortborder; j++) {
				int item = 0;
				if(arr[j]>arr[j+1]) {
					item = arr[j];
					arr[j] = arr[j+1];
					arr[j+1] = item;
					iscontinue = false;
					lastcomindex = j;
				}
			}
			sortborder = lastcomindex;
			if(iscontinue) {
				break;
			}
		}
	}

​

使用Java实现的栈

package aa.datastructure;

import java.util.Arrays;

/**
 *  栈
 */
public class MyStack<E> {
	private Object[] data = null;
	private int length = 0; // 栈的容量
	private int top = -1; // 栈顶的指针
	
	MyStack() {
		
	}
	MyStack(int initSize){
		if(initSize>=0) {
			this.length = initSize;
			data = new Object[initSize];
			top = -1;
		}else {
			throw new RuntimeException("初始容量不能小于0"+initSize);
		}
	}
	
	public boolean push(E e) {
		if(top == length-1) {
			throw new RuntimeException("栈已经达到最大值");
		}else {
			data[++top] = e;
			return true;
		}
	}
	
	public E pop() {
		if(top == -1) {
			throw new RuntimeException("空栈");
		}else {
			return (E) data[top--];
		}
	}
	
	public E peek() {
		if(top == -1) {
			throw new RuntimeException("空栈");
		}else {
			return (E) data[top];
		}
	}
	public static void main(String[] args) {
		MyStack sm = new MyStack(3);
		for (int i = 0; i < 3; i++) {
			sm.push(i);
		}
		System.out.println(Arrays.toString(sm.data));
		for (int i = 0; i < 3; i++) {
			System.out.println(sm.peek());
		}
		for (int i = 0; i < 3; i++) {
			System.out.println(sm.pop());
		}
	}
	
}

使用Java实现的队列

package aa.datastructure;

import java.util.Arrays;

/*
 * 队列
 */
public class MyQueue<E> {
	private int length;//容量
	private Object[] data;
	private int front;//头
	private int rear;
	
	MyQueue(){
		
	}
	
	MyQueue(int initSize){
		if(initSize>=0) {
			length = initSize;
			data = new Object[initSize];
			front = rear = 0;
		}else {
			throw new RuntimeException("队列初始化大小不能小于0");
		}
	}
	
	public boolean add(E e) {
		if(rear == length) {
			throw new RuntimeException("队列满了");
		}else {
			data[rear++] = e;
			return true;
		}
	}
	public E pool() {
		if(front == rear) {
			throw new RuntimeException("空队列");
		}else {
			E value = (E) data[front];
			data[front++] = null;
			return value;
		}
	}
	public E peek() {
		if(front == rear) {
			throw new RuntimeException("空队列");
		}else {
			E value = (E) data[front];
			return value;
		}
	}
	public static void main(String[] args) {
		MyQueue mq = new MyQueue(10);
		for (int i = 0; i < 5; i++) {
			mq.add(i);
		}
		System.out.println(Arrays.toString(mq.data));
		for(int i = 0; i < 5; i++) {
			System.out.println(mq.pool());
		}
		for(int i = 0; i < 5; i++) {
			System.out.println(mq.peek());
		}
	}
	
}

【临渊羡鱼不如退而结网】