1. 几个景点算法：
1. 修路问题：最小生成树（加权值）+ 普利姆
2. 最短路径：图+弗洛伊德算法
3. 汉诺塔： 分支的算法
4. 八皇后：回朔法、
5. 丢手帕 ： 约瑟夫问题
2. 线性结构 与非线性结构
1.线性结构 ：数据元素之间存在一对一的线性关系
顺序存储结构 , 链式存储结构
(数组，队列，链表和栈)
2 . 非线性结构：（二维数组，多维数组，广义表，树结构，图结构）
3. 稀疏数组
因为该数组中记录了很多值是默认值0，记录了很多没有意义的数据 -》 稀疏数组
代码实现原始二维数组与稀疏数组之间的转化
import org.junit.Test; public class XiShuJuZhen { //创建一个原始的二维数组 11*11 @Test public void testArray() { int[][] charArray = new int[11][11]; //0表示没有棋子，1 表示黑子 2表示蓝子 charArray[1][2] = 1; charArray[2][3] = 2; charArray[4][5] = 2; System.out.println("输出原始的二维数组"); for (int[] is : charArray) { for (int is2 : is) { System.out.print(" "+is2); } System.out.println(); } /* * 将二维数组转为稀疏数组的思路 * （1）.先遍历二维数组，得到非0整数的个数 */ int sum = 0; for(int i=0;i<11;i++) { for(int j=0;j<11;j++) { if(charArray[i][j]!=0) { sum++; } } } System.out.println("sum = "+sum); //2 .创建对应的稀疏数组 int sparseArr[][] = new int[sum+1][3] ; //给稀疏数组赋值 sparseArr[0][0] = 11; //有11行 sparseArr[0][1] = 11; //有11列 sparseArr[0][2] = sum; //有多少个值 int count= 0; //count 用于记录是第几个非0数据 for(int i=0;i<11;i++) { for(int j=0;j<11;j++) { if(charArray[i][j]!=0) { count++; sparseArr[count][0] = i; //第0 列,第count行 sparseArr[count][1] = j; //第1列，第count行 sparseArr[count][2] =charArray[i][j];//第2列 存入的是二维数组不为0的值 } } } System.out.println("输出稀疏数组的形式"); for (int[] is : sparseArr) { for (int is2 : is) { System.out.print(" "+is2); } System.out.println(); } //恢复成二维数组 //先读取稀疏数组的第一行将新创建的数组进行赋值确定数组大小 int[][] charArray1 = new int[sparseArr[0][0]][sparseArr[0][0]]; //再读取稀疏数组的后几行，从第二行开始，并赋给原始的二维数组 for(int i=1;i<sparseArr.length;i++) { //为原始数组进行赋值 charArray1[sparseArr[i][0]][sparseArr[i][1]] = sparseArr[i][2]; } System.out.println("恢复后的原始二维数组"); for (int[] is : charArray1) { for (int is2 : is) { System.out.print(" "+is2); } System.out.println(); } } }
使用IO流将数据保存起来 其实我没有明白是什么意思，然后我就写了一个IO流将数据以文本的方式保存起来了
public static void main(String[] args) throws IOException { //创建一个字节流输出流 FileOutputStream fileOutputStream = new FileOutputStream("D:/lucenezhulina/a.txt"); //将字节流转化为字符流 OutputStreamWriter outputStreamWriter = new OutputStreamWriter(fileOutputStream); //使用缓冲区进行缓冲 BufferedWriter bufferedWriter = new BufferedWriter(outputStreamWriter); // bufferedWriter.write("朱李纳"); //0表示没有棋子，1 表示黑子 2表示蓝子 String str1 = "int[][] charArray = new int[11][11];"; String str2 = "charArray[1][2] = 1;"; String str3 = "charArray[2][3] = 2;"; String str4 = "charArray[4][5] = 2;"; bufferedWriter.write(str1); bufferedWriter.write(str2); bufferedWriter.write(str3); bufferedWriter.write(str4); bufferedWriter.close(); //创建 一个字节输入流 FileInputStream fileInputStream = new FileInputStream("D:/lucenezhulina/a.txt"); //将字节流转化为字符流 InputStreamReader inputStreamReader = new InputStreamReader(fileInputStream); //使用缓冲流 BufferedReader bufferedReader = new BufferedReader(inputStreamReader); String readLine = bufferedReader.readLine(); System.out.println(readLine); //读取数据 /* while(true) { String readLine = bufferedReader.readLine(); if(readLine==null) { break; } System.out.println(readLine); }*/ bufferedReader.close(); }
改进后的代码
import java.awt.event.FocusAdapter; import java.util.Scanner; import javax.management.RuntimeErrorException; import org.junit.Test; public class CircleQueue { private int maxSize;//表示数组的最大容量 private int front;//front指向队列的第一个元素 private int rear;//队列尾 private int arr[];//该数组用于存放数据，模拟队列 //定义一个构造器给与数组初始大小 public CircleQueue(int arrMaxSize) { maxSize = arrMaxSize; arr = new int[maxSize]; } //判断队列是否满 public boolean isFull() { return (rear+1) % maxSize == front; //rear+1 最大和maxSize相同 } //添加数据到队列 public void addQueue(int n) { //判断队列是否满 if(isFull()) { System.out.println("队列已满,不能加入"); return; } arr[rear] = n; rear = (rear+1)%maxSize; //rear不可能比maxSize大因此余数就是rear+1,也就是rear向后移动一个值 } //判断队列是否为空 public boolean isEmpty() { return rear==front; } //获取队列的数据出队列 public int getQueue() { if (isEmpty()) { throw new RuntimeException("队列空，不能取数据"); } int value = arr[front]; front = (front+1)%maxSize; //front最大是与rear相同比maxSize小1 return value; } //显示队列的所有数据 public void showQueue() { //遍历 if(isEmpty()) { System.out.println("队列是空的，没有数据"); return; } for(int i=front;i<front+size();i++) { System.out.printf("arr[%d]=%d ",i%maxSize,arr[i%maxSize]); } } //求出当前列有效数据个数 public int size() { return (rear+maxSize -front)%maxSize; } //显示头信息 public int headQueue() { //判断 if(isEmpty()) { System.out.println("队列为空，没有投数据"); throw new RuntimeException("队列空的没有数据"); } return arr[front]; } } public class TestCircleQueue { @Test public void test01() { //创建一个队列对象 CircleQueue arrayQueue = new CircleQueue(4); //接收用户输入 char key = ' '; Scanner sc = new Scanner(System.in); boolean loop = true; //输出一个菜单 while(loop) { System.out.println("s(show): 显示队列"); System.out.println("e(exit): 退出程序"); System.out.println("a(add): 添加数据到队列"); System.out.println("g(get): 从队列取出数据"); System.out.println("h(head): 查看队列头的数据"); key = sc.next().charAt(0);//接收一个字符 switch (key) { case 's': arrayQueue.showQueue(); break; case 'e': //退出程序 sc.close(); loop = false; break; case 'h': //查看队列头的数据 try { int res = arrayQueue.headQueue(); System.out.println("队列头的数据是: "+res); } catch (Exception e) { System.out.println(e.getMessage()); } break; case 'a': System.out.println("输入一个数"); int value = sc.nextInt(); arrayQueue.addQueue(value); break; case 'g': //取出数据 try { int res = arrayQueue.getQueue(); System.out.println("取出的数据是:"+res); }catch (Exception e) { System.out.println(e.getMessage()); } break; default: break; } } System.out.println("程序退出"); } }
使用循环链表，这种方式不能进行排序，如果插入的顺序不一样，不能自动的进行排序
class SingleLinkedListDemo { public static void main(String[] args) { //进行测试 //先创建节点 HeroNode heroNode1 = new HeroNode(1, "宋江" , "及时雨"); HeroNode heroNode2 = new HeroNode(2, "卢俊义" , "玉麒麟"); HeroNode heroNode3 = new HeroNode(3, "吴用" , "智多星"); HeroNode heroNode4 = new HeroNode(4, "林冲" , "豹子头"); //创建链表 SingleLinkedList singleLinkedList = new SingleLinkedList(); //加入 /* singleLinkedList.add(heroNode1); singleLinkedList.add(heroNode2); singleLinkedList.add(heroNode3); singleLinkedList.add(heroNode4);*/ //加入按照编号的顺序 singleLinkedList.addByOrder(heroNode1); singleLinkedList.addByOrder(heroNode4); singleLinkedList.addByOrder(heroNode2); singleLinkedList.addByOrder(heroNode3); //遍历 singleLinkedList.list(); } } //定义SingleLinkedList 管理我们的英雄 class SingleLinkedList{ //先初始化一个头节点，头节点不要动，不存放具体的数据 private HeroNode head = new HeroNode(0,"",""); //添加节点到单向链表 /** * 思路：当不考虑编号顺序时 * 1.找到当前链表的最后节点 * 2.将最后节点的这个next指向新的节点 */ public void add(HeroNode heroNode) { //因为head节点不能动，因此我们需要一个辅助遍历temp HeroNode temp = head; //遍历链表,找到最后 while(true) { //找到链表的最后 if (temp.next==null) { break; } //如果没有找到就将temp后移 temp=temp.next; } //当退出while循环时，temp就指向了链表的最后 //将最后节点的这个next指向新的节点 temp.next = heroNode; } //第二种方式在添加英雄时，根据排名将英雄添加到指定位置 //如果有这个排名，择添加失败并给出提示 public void addByOrder(HeroNode heroNode) { //应为头结点不能动，我们通过一个辅助变量帮助找到添加的位置 HeroNode temp = head; boolean flag = false; //标识添加的这个编号是否存在默认是false while (true) { if(temp.next==null) {//说明temp节点已经在链表的最后 break; } if (temp.next.no>heroNode.no) {//位置找到，就在temp的后面插入 break; }else if(temp.next.no == heroNode.no) {//说明希望添加的heroNode的编号已然存在 flag = true;//说明编号存在 break; } temp = temp.next; //后移，遍历当前的链表 } //判断flag的值 if (flag) { //不能添加，说明编号存在 System.out.printf("准备插入的英雄的编号 %d 已经存在了,不能加入 ",heroNode.no); }else { //插入到链表中,temp的后面 heroNode.next = temp.next; temp.next = heroNode; } } //显示链表 遍历 public void list() { //判断链表是否为空 if(head.next == null) { System.out.println("链表为空"); return; } //因为头结点不能动，需要一个辅助变量来遍历 HeroNode temp = head.next; while(true) { //判断是否到链表最后 if (temp==null) { break; } //输出这个节点的信息 System.out.println(temp); //将这个temp后移 temp = temp.next; } } } //定义HeroNode ,每一个HeroNode对象就是一个节点 class HeroNode{ public int no; public String name; public String nickname; //昵称 public HeroNode next; //指向下一个节点 //构造器 传入三个参数一个编号，姓名，昵称 public HeroNode(int hNo,String hName,String hNickName) { this.no = hNo; this.name = hName; this.nickname = hNickName; } @Override public String toString() { return "HeroNode [no=" + no + ", name=" + name + ", nickname=" + nickname + ", next=" + next + "]"; } }
单链表的修改操作
//修改节点的信息，根据no编号来修改，即no不能改 public void update(HeroNode newHeroNode) { //判断是否为空 if (head.next==null) { System.out.println("链表为空"); return; } //找到需要修改的节点,根据no编号 //定义一个辅助变量 HeroNode temp = head.next; boolean flag = false; //表示是否找到该节点 while(true) { if(temp==null) { break;//已经遍历完链表 在遍历的过程中temp一直在向后走到达最后一个next为null }if (temp.no == newHeroNode.no) { //找到 flag = true; break; } temp = temp.next; } //根据flag判断是否找到要修改的节点 if(flag==true) { temp.name = newHeroNode.name; temp.nickname = newHeroNode.nickname; }else { //没有找到 System.out.printf("没有找到编号为 %d 的节点,不能修改 ",newHeroNode.no); } }
//测试修改节点的代码 HeroNode heroNode = new HeroNode(2, "小卢", "玉麒麟"); singleLinkedList.update(heroNode); System.out.println("修改后"); singleLinkedList.list();
删除节点
//删除节点 public void delete(int no) { HeroNode temp = head; boolean flag = false; //标志是否找到待删除节点的前一个节点 while(true) { if (temp.next==null) { //已经遍历到了链表尾 break; } if (temp.next.no ==no) { //找打了待删除节点的前一个节点 flag = true; break; } //若没有找到temp后移继续遍历 temp = temp.next; } //判断flag if (flag ==true) { //找到 temp.next = temp.next.next; }else { System.out.printf("要删除的 %d 节点不存在 ",no); } }
//删除一个节点 singleLinkedList.delete(1); System.out.println("删除后链表结构"); singleLinkedList.list();
几个经典面试题：
将单链表进行翻转
//将单链表进行翻转 public static void reverseLinked(HeroNode heroNode) { //如果当前链表为空，或者只有一个节点就无需翻转 直接返回 if (heroNode.next==null|| heroNode.next.next==null) { return ; } //定义一个辅助的指针，帮我们遍历原来的链表 HeroNode current =heroNode.next; HeroNode next = null; //指向当前节点current的下一个节点 相当一next代替current向后移动 HeroNode reverseHead = new HeroNode(0, "", ""); //遍历原来的链表每遍历一个节点就将其取出，并放在新的链表reverseHead的最前端 while(current !=null) { next = current.next; //先暂时保留current的下一个节点 current.next = reverseHead.next; //将当前节点的下一个节点置为空 目的是使 // 当前current 称为新链表的第一个节点 reverseHead.next = current; //当前节点称为了新链表的第一个节点 current = next; //现在current指向了原来链表的下一个节点，也就是让current后移 } //最后将head.next指向reverseHead.next，实现单链表的反转 heroNode.next = reverseHead.next; }
测试：
//测试单链表的反转 System.out.println("反转后链表的情况"); reverseLinked(singleLinkedList.getHead()); singleLinkedList.list();
查找单链表中的倒数第k个节点 新浪面试题
//查找单链表中的倒数第k个节点 新浪面试题 /* * 思路：编写一个方法，接收head节点同时接收一个index,index 表示倒数第index个节点 * 先把链表从头到尾遍历，然后减去index就是我需要遍历的长度 */ public static HeroNode returnSignIndexNode(HeroNode heroNode,int index) { //如果链表尾空就返回null if (heroNode.next==null) { return null; } //第一次遍历获取链表的长度 int size = getLength(heroNode); //第二次遍历 size-index位置就是我们倒数的第k的节点 //先做一个index的校验 if(index<=0||index>size) { return null; } //定义辅助变量，for循环定位到倒数的index HeroNode current = heroNode.next; for(int i=0;i<size-index;i++) { current = current.next; } return current; }
测试：
//测试是否得到了倒数第k个节点 HeroNode res = returnSignIndexNode(singleLinkedList.getHead(), 1); System.out.println("倒数第1 res = "+res);
查找单链表有效节点的个数不统计头结点
//查找单链表有效节点的个数不统计头结点 public static int getLength(HeroNode heroNode) { if(heroNode.next ==null) { //空链表 return 0; } int count = 0; HeroNode current; current = heroNode.next; while(current!=null) { count++; current = current.next; } return count; }
测试：
//测试一下 求单链表中有效节点的个数 System.out.println("有效的节点个数："+getLength(singleLinkedList.getHead()));
从尾到头打印单链表
/* * 从尾到头打印单链表 * 思路：方式一：先将单链表进行翻转操作，然后再遍历即可，这样做的问题是会破坏原来的单链表的结构 * 不建议。 * 方式二：可以利用栈这个数据结构，将个个节点压入栈中，然后利用栈的先进后出的特点，就实现了 * 逆序打印的效果。 */ public static void reversePrint(HeroNode heroNode) { if(heroNode.next==null) { return; //空链表，不能打印 } //创建一个栈，将各个节点压入栈中 Stack<HeroNode> stack = new Stack<HeroNode>(); HeroNode current = heroNode.next; //将链表的所有的节点压入栈中 while(current!=null) { stack.push(current); current = current.next; //current后移 } //将栈中的节点进行打印，pop 出栈 while(stack.size()>0) { System.out.println(stack.pop());//先进后出 出栈 } }
测试
System.out.println("测试逆序打印单链表,没有改变原来链表的结构"); reversePrint(singleLinkedList.getHead());