数据结构 图 简单入门 最小生成树 深度优先搜索 广度优先搜索

 早上上班路上，看到一则新闻，广州的。新闻说的是一个辅警在路边查过往路人的身份证，其中有一个记者，就询问，根据哪条法律要查询他的身份证。辅警当然不知道（事后据说，就是闲着无聊，查着玩的！），也肯定不会认错，就强行把记者带到当地的派出所，以妨碍公务为由进行拘留。记者被放出来后，就写了一篇关于这件事情的文章，引起了极大的关注。

这件事情的结局是好的，事件并没有恶化。有网友就感叹，记者命好。没有对比就没有伤害，网友就贴出了2013年3月份的一起

类似事件，该事件当时轰动全国，即大学毕业生孙志刚因在广州未随身携带身份证暂住证等证件，被辅警带入派出所，随后遣送到收容所，又被送到救治所，最终在救治所被杀害。

看完，我也是非常震惊，更感觉到恐惧。朗朗乾坤，竟然还有这样的事情在我们不知道的黑暗角落发生。我也非常难以理解，施暴者是以什么样的心里，对一个和自己无冤无仇的人下如此重手，取人性命！

我想到曾经看过的一件事情，美国的一家为空军生产降落伞的公司，每批产品总有几个不合格的，这也导致了每次都有士兵不是死在了敌人的手里，死在了自家的降落伞手里。美国人很珍惜生命的。有个将军，我忘记叫什么了，可能是麦克阿瑟啥的，就对这个问题提出了解决方案。在检验降落伞的质量时，随机的从这家降落伞公司的员工中抽几个人，再随机抽几个降落伞，让这些员工试用。从此以后，美国再也没有发生过降落伞不合格的问题。

人性是有缺点的，比如人是自私的，人是趋利避害的，人都有惰性等等。

小到公司，组织，大到政府，国家，我觉得制度最重要。相信制度，按制度办事，而不是相信某个人，按人情办事。

 

package eight21one;

import org.junit.Test;

/**
 * 我的栈
 * 郭胜
 * 栈的特点是：先进后出
 * @author 180719-2
 *
 */
public class MyStack {

	private int[] stack;
	
	private int pointer;
	
	public MyStack(){
		stack = new int[10];
	}
	
	/**
	 * 压栈
	 * 郭胜
	 */
	public void push(int val){
		if(pointer >= stack.length){
			throw new IndexOutOfBoundsException();
		}
		stack[pointer++] = val;
	}
	
	/**
	 * 查看栈顶部的数据，但不移除
	 * 郭胜
	 */
	public int peek(){
		if(isEmpty()){
			return -1;
		}
		return stack[pointer - 1];
	}
	
	/**
	 * 弹出栈顶部数据，并移除
	 * 郭胜
	 * @return
	 */
	public int pop(){
		if(pointer <= 0){
			throw new IndexOutOfBoundsException();
		}
		int tmp = stack[--pointer];
		return tmp;
	}
	
	/**
	 * 判断栈是否为空
	 * @return
	 */
	public boolean isEmpty(){
		if(pointer == 0){
			return true;
		}
		return false;
	}
	@Test
	public void test(){
		MyStack ms = new MyStack();
		for(int i =0;i<10;i++){
			ms.push(i);
		}
		System.out.println(ms.pointer);
		for(int i=0;i<10;i++){
			System.out.println(ms.pop());
		}
		System.out.println(ms.pointer);
		System.out.println(ms.isEmpty());
		System.out.println(ms.peek());
		System.out.println(ms.pointer);
		
	}
	 
}

package eight21one;

import org.junit.Test;

/**
 * 我的队列
 * 队列的特点：先进先出
 * 郭胜
 * @author 180719-2
 *
 */
public class MyQueue {

	private int[] queue;
	
	private int insertPointer;
	
	private int fetchPointer;
	
	public MyQueue(){
		queue = new int[10];
	}
	
	/**
	 * 插入方法
	 * 郭胜
	 * @param val
	 */
	public void insert(int val){
		if(insertPointer >= queue.length){
			throw new IndexOutOfBoundsException();
		}
		queue[insertPointer++] = val;
	}
	
	/**
	 * 取出数据，并将取出的数据移除
	 * 郭胜
	 * @return
	 */
	public int fetch(){
		if(fetchPointer > insertPointer){
			throw new IndexOutOfBoundsException();
		}
		return queue[fetchPointer++];
	}
	
	/**
	 * 判断队列是否为空
	 * 郭胜
	 * @return
	 */
	public boolean isEmpty(){
		if(fetchPointer >= insertPointer){
			return true;
		}
		return false;
	}
	
	@Test
	public void test(){
		MyQueue mq = new MyQueue();
		for(int i=0;i<10;i++){
			mq.insert(i);
		}
		System.out.println(mq.insertPointer);
		
		for(int i=0;i<10;i++){
			System.out.println(mq.fetch());
		}
		
		System.out.println(mq.isEmpty());
	}
}

package eight21one;

/**
 * 数据结构：图
 * 顶点
 * 郭胜
 * @author 180719-2
 *
 */
public class Vertex {

	public char label;//图的顶点标记
	public boolean flag = false;//标记是否已查找，false为未查找，true为已查找
	
	
	public Vertex(char label){
		this.label = label;
	}
}

package eight21one;

/**
 * 数据结构
 * 图
 * 郭胜
 * @author 180719-2
 *
 */
public class Graph {

	private Vertex[] vertexs;//顶点的集合
	
	private int[][] matrix;//图中顶点的边  二维数组 标记从一个顶点到另一个顶点是否能走通
	
	private int maxSize = 10;//最大顶点数
	
	private int current;//当前节点
	
	public Graph(){
		vertexs = new Vertex[maxSize];
		matrix = new int[maxSize][maxSize];
		for(int i=0;i<maxSize;i++){//初始化二维数组
			for(int j=0;j<maxSize;j++){
				matrix[i][j] = 0;
			}
		}
	}
	
	/**
	 * 添加顶点
	 * 郭胜
	 * @param v
	 */
	public void addVertexs(char v){
		if(current >= vertexs.length){
			throw new IndexOutOfBoundsException();
		}
		vertexs[current++] = new Vertex(v);
	}
	
	/**
	 * 添加边
	 * 郭胜
	 */
	public void addEdge(int v1,int v2){
		matrix[v1][v2] = 1;
		matrix[v2][v1] = 1;
	}
	
	/**
	 * 图的搜索之一：深度优先搜索
	 * 规则：
	 * 1.如果可能，访问一个邻接的未访问过的顶点，标记它，并把它放入栈中；
	 * 2.当不能执行规则1时，如果栈不为空，就从栈中弹出一个顶点；
	 * 3.当不能执行规则1和规则2时，就完成了整个搜索。
	 */
	public void dfs(){
		MyStack ms = new MyStack();
		ms.push(0);
		vertexs[0].flag = true;
		while(!ms.isEmpty()){
			int i = getAdjoinVertex(ms.peek());
			if(i == -1){ 
				System.out.println(vertexs[ms.peek()].label);
				ms.pop();
			}else{
				ms.push(i);
			} 
		}
		for(int i=0;i<current;i++){
			vertexs[i].flag = false;
		}
	}
	
	/**
	 * 图的搜索之一：广度优先搜索
	 * 规则：
	 * 1.访问下一个邻接的未访问过的顶点，这个顶点必须是当前节点的邻接点，标记它，并把它插入到队列中;
	 * 2.如果无法执行规则1，那么就从队列头取出一个顶点，并使其作为当前顶点；
	 * 3.当队列为空不能执行规则2时，就完成了整个搜索过程。
	 */
	public void bfs(){
		MyQueue mq = new MyQueue();
		mq.insert(0);
		vertexs[0].flag = true;
		while(!mq.isEmpty()){
			int i = mq.fetch();
			while(true){
				int j = getAdjoinVertex(i);
				if(j != -1){
					mq.insert(j);
				}else{
					break;
				}
			}
			System.out.println(vertexs[i].label);
		}
	}
	
	/**
	 * 最小生成树
	 * 郭胜
	 */
	public void mst(){
		MyStack ms = new MyStack();
		ms.push(0);
		vertexs[0].flag = true;
		while(!ms.isEmpty()){
			int i = getAdjoinVertex(ms.peek());
			if(i == -1){ 
				ms.pop();
			}else{
				System.out.println();
				System.out.print(vertexs[ms.peek()].label);
				System.out.print("-");
				System.out.print(vertexs[i].label);
				System.out.println();
				ms.push(i);
			} 
		}
		for(int i=0;i<current;i++){
			vertexs[i].flag = false;
		}
	}
	
	/**
	 * 根据一个顶点找到与它相邻的顶点，并返回
	 * 郭胜
	 * @param v
	 * @return
	 */
	public int getAdjoinVertex(int v){
		for(int i=0;i<maxSize;i++){
			if(matrix[v][i] == 1 && !vertexs[i].flag){
				vertexs[i].flag = true;
				return i;
			}
		}
		return -1;
	}
	
}

package eight21one;

import org.junit.Test;

public class GraphTest {

	@Test
	public void test(){
		Graph g = new Graph();
		g.addVertexs('a');
		g.addVertexs('b');
		g.addVertexs('c');
		g.addVertexs('d');
		g.addVertexs('e');
		g.addVertexs('f');
		g.addEdge(0, 1);
		g.addEdge(0, 2);
		g.addEdge(1, 3);
		g.addEdge(2, 3);
		g.addEdge(2, 4);
		g.addEdge(3, 4);
		g.addEdge(3, 5);
		
		//g.dfs();
		//g.bfs();
		g.mst();
		
	}
}