蓝蓝站点

博客

发表于 分类于 ， ， Waline： 本文字数： 308 阅读时长 ≈ 1 分钟

JS

变量命名规则

弹出对话框

alert()
confirm()
prompt()

JS事件

js事件很重要

AJAX

AJAX相当于一个HTTP客户端

  1. Ajax创建对象
  2. open()
  3. 设置回调函数
  4. send

image-20210804101829879

前后端分离的时候一定要看前端有没有请求发送到后端。

同步和异步的问题。

前后端分离 登录示例

分离示例：注册的时候，判断是否可以注册

位运算

与
或
非
亦或

移位运算

算术移位

>>,<<
低位-高位，补零
高位->低位，补符号位

逻辑移位

都补零
只有右移：>>>

按位右移补零操作符

题目

从键盘中输入两个整形数，问在存储的二进制中，有多少位是相等的。

输出一个数，输出它的补码

要先把JSP版本的和前后端分离版本的先弄懂

发表于 分类于 ， ， Waline： 本文字数： 376 阅读时长 ≈ 1 分钟

上午

  • 过滤器
  • 监听器

过滤器

先做用的少
用的比较多的是用来做编码转换
最对请求体进行转换，不会对请求头做改变。
所以对get请求，不做转换。

过滤器是不响应的。

注解
web.xml中配置过滤器

监听器

引例，显示一个网站的在线人数目。
游客数目。

使用session,创建Session时，在线人数加一。
登录的时候创建保存用户的Session时，会员人数加一，
在线人数减去会员数，即可得到游客数目。

监听器是服务端的事件触发的，所以监听器不会配置URL。

有哪几类监听器

image-20210803093926168

编程示例

统计在线人数

线程不安全的

使用线程线程安全的数据类型。

image-20210803094801574

整理web知识点

一个URL只能给一个servlet

一个servlet可以监听多个URL

把学生登录的项目

把增删改查做出来

JSON

编程题

编程题：给定单个对象，写一个工具，把该对象专户转换成JSON字符串。

image-20210803104029739

JSON转对象

image-20210803104432858

image-20210803104438270

如何判断数组,检查字符串中是否有[]

发表于 分类于 ， ， Waline： 本文字数： 1.1k 阅读时长 ≈ 1 分钟
  • 树
  • 基数排序
  • 快速排序和归并排序的非递归实现

哈希

顺序
链式
哈希（散列）
索引（）

前三种用在内存中，索引可以用来内存也可以用在外存中。

HashTable就是使用链接地法解决冲突。

自己写一个HashMap,使用拉链法进行存储。

1
2
add(int key,T value);
T get(int key);

代码示例

链地址法实现哈希存储
快速排序非递归实现。

讲解
2G内存，如何对8G大的内容排序

讲解2
从N个有序大的数组中，从这批数组中，找到m个最小的数字。

定义一个长度为m的数组，第0个元素，存放第1个数组的第1个值，第1个元素存放地2个数组的值。

讲解2
判断链表尾环
使用两个指针X,Y，一个X每次走一步，一个Y每次走两步，当两个指针相遇的时候就表示有尾环
求出环的入口：
相遇的时候走一步的指针X不变，每次X走一步，再使用一个指针Z从链表的头开始，每次Z走一步
当
当两者相遇的时候，就是入口点。

web应用赶紧做。
下次讲二叉树的遍历
前序遍历
中序遍历
后续遍历

二叉树的遍历

面试要问

递归方式
非递归方式

概念详解

练习题

image-20210803090047554

非递归遍历实现

前序非递归实现

编程题，实现：八个方法

前序，中序，后序，递归和非递归实现，6
层次遍历，1
判断是否是完全二叉树。1

递归的，使用非递归实现，
使用栈来解决

stack.push(t)
while(栈非空){
t=pop();
打印t.data
if(t.rChirld!=null)
入栈
if(t.lChirld!=null)
入栈
}

方式2 前序：
while(t!=null)
{
打印t.data
pusu(t)
t=t.lchirld
}
while(栈非空){
t=pop()
if(t.rchild!=null){
t=t.rchild;
while(t!=null)
{
打印t.data
pusu(t)
t=t.lchirld
}
}
}

中序：

while(t!=null)
{
//打印t.data
pusu(t)
t=t.lchirld
}
while(栈非空){
t=pop()
打印t.data
if(t.rchild!=null){
t=t.rchild;
while(t!=null)
{
打印t.data
pusu(t)
t=t.lchirld
}
}
}

层次遍历：
（队列实现）

入队(t)
while(队列非空){
t=出队
打印
if(左非空)
入队
if(右非空)
入队
}

判断完全二叉树
（队列实现）

发表于 分类于 ， ， Waline： 本文字数： 2.7k 阅读时长 ≈ 2 分钟

递归实现

快速排序方式1

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
/**
 * 快速排序入口。
 * @param array 待排序的数组
 */
public static void quickSort(int[] array) {
	quickSort(array, 0, array.length - 1);
}

/**
 * 对数组中从left到right的区域进行快速排序
 * @param array 待排序的数组
 * @param left 本次待排序序列的起始位置
 * @param right 本次待排序序列的结束位置
 */
private static void quickSort(int[] array, int left, int right) {
	if (left < right) {
		int index = quickSortOne(array, left, right);
		quickSort(array, left, index - 1);
		quickSort(array, index + 1, right);
	}
}

/**
 * 进行一趟快速排序
 * @param array 待排序的数组
 * @param left 待排序的序列的起始位置
 * @param right 待排序序列的结束位置
 * @return 分割的位置
 */
private static int quickSortOne(int[] array, int left, int right) {
	int pivot = array[left];
	int start = left;
	int end = right;
	while (start < end) {
		// 从右向左查找查找第一个比基准数小的元素
		// 如果a[j]大于等于基准数，继续查找
		while (array[end] >= pivot && start < end) {
			end--;
		}
		// 从左向右查找第一个比基准数大的元素
		// 也就是当a[i]小于等于基准数的时候，还得继续查找
		while (array[start] <= pivot && start < end) {
			start++;
		}
		// 交换大于基准数的元素和小于基准数的元素的位置
		swap(array, start, end);
	}
	// 把基准数放到中间
	swap(array, left, start);
	// 返回分割点的下标
	return start;
}

/**
 * 交换数字中的两个元素的位置
 * @param array 数组
 * @param left 数字前面的元素
 * @param right 数组后面的元素
 */
private static void swap(int[] array, int left, int right) {
	int temp = array[left];
	array[left] = array[right];
	array[right] = temp;
}

快速排序改进型：省略swap函数的情况

上面的算法为：

  • 使用一个变量，记录下基准数的值，从后向前查找比基准数小的数，
  • 然后从前向后查找大的数，
  • 然后把比基准数小的和比基准数大的进行交换。这样需要使用一个交换方法来实现。

那么这个方法能不能省略掉呢？
是可以的，

  • 使用一个变量，记录下基准数的值，从后向前查找比基准数小的数，
  • 找到以后直接把这个小的数，放到原来基准数的位置上。(因为我们已经记下了基准数的位置，所以不用担心这个数被覆盖掉)
  • 然后从前往后查找比基准数大的数，然后把这个数放到上一步找到的比基准数小的数的位置上。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
/**
 * 对整个数组执行快速排序。
 * @param array 待排序的数组
 */
public static void quickSort(int array[]) {
    // 合法性判断
    if (array == null)
        return;
    // 对从第一个元素到最后一个元素的数组序列执行快速排序
    quickSort(array, 0, array.length - 1);
}

/**
 * 对数组中的一段连续的序列执行快速排序。
 * @param array 待排序的数组
 * @param left 数组中被分割的序列的开始位置
 * @param right 数组中被分割的序列的结束位置
 */
private static void quickSort(int array[], int left, int right) {
    // 执行一趟快速排序，并返回分割点
    int mid = quickOne(array, left, right);
    if (left < mid - 1) {
        // 对分割点左侧的序列执行快速排序
        quickSort(array, left, mid - 1);
    }
    if (mid + 1 < right) {
        // 对分割点右侧的序列执行快速排序
        quickSort(array, mid + 1, right);
    }
}

/**
 * 执行一趟快速排序
 * @param array 待排序的数组
 * @param left 被分割的序列的开始位置
 * @param right 被分割的序列的结束位置
 * @return 当前序列的分割点的位置
 */
private static int quickOne(int[] array, int left, int right) {
    // 保存基准数
    int pivot = array[left];
    while (left < right) {
        // 从右向左移动右指针，查找比基准数小的数
        while (left < right && array[right] >= pivot) {
            right--;
        }
        // 把比基准数小的放到基准数的位置
        array[left] = array[right];
        // 从左向右移动左指针，查找比基准数大的数
        while (left < right && array[left] <= pivot) {
            left++;
        }
        // 把基准数大的数放到后面
        array[right] = array[left];
    }
    // 基准数放到分割点的位置
    array[left] = pivot;
    // 返回分割点的下标
    return left;
}

发表于 分类于 ， ， Waline： 本文字数： 409 阅读时长 ≈ 1 分钟

回顾

请求转发

1
request.getRequestDispatcher().forwart(request,response);

完成上面的删除功能

web.xml中配置servlet

给servlet配置URL：

image-20210731093611337

servlet的url只能使用一种方式配置，不要同时使用注解形式和web.xml形式。

排序

一定要快速写出来

内部排序 外部排序

内部排序的算法

建议写快速排序

插入排序

直接插入排序

image-20210731103043891

image-20210731103113174

折半查找

image-20210731103149232

image-20210731104215832

折半查找+直接插入排序

希尔排序

交换排序

冒泡排序

选择排序

课堂作业

  • 写出希尔
  • 冒泡排序
  • 选择排序

下午讲

  • 快速排序
  • 归并排序
  • 堆排序

快速排序

递归实现
非递归实现

基排序

树

有三个节点的二叉树有多少种形态。
五种

完全二叉树中如果有1000节点，请问它有多少个叶子节点。

堆

堆其实是二叉树

大根堆
小根堆

题目

  • 一个8G个数量的整形数，但是你的电脑的内存只有2G，你如何找出这8个G的数的中位数
  • 有n个有序的一维数组（小到大）
    • 从这批数组中，取出最小的m个数。
    • 提示：使用堆排序

发表于 分类于 ， ， Waline： 本文字数： 451 阅读时长 ≈ 1 分钟

JSP

eclipse创建jsp

image-20210730141500520

image-20210730141510156

image-20210730141515238

image-20210730141722652

jsp解析转换成servlet,输出成html的过程

hello.jsp

1
2
3
4
5
Hello_JSP extends HttpServlet{
​    sevice(requst,response){
​        PrintWriter out=
​    }
}

JSP执行过程（重要）

问题：jsp页面如何转成成html

转换成servlet
扫描jsp的文本文件，

  • 遇到html代码，就out.write(html代码)直接输出
  • 遇到java代码，就执行，out.write(执行结果)

JSP声明周期

JSP内置对象(重要)

image-20210730143515903

Session

网页中右上角的用户信息不管在哪个页面都可以显示。

但是http协议是无状态的，http不会保存已经返回的数据，

当跳转到其他页面时，用户的信息是否还要再次从数据库中去查询？

不需要，使用Session机制。

Session是一个Map,当客户端第一次请求数据库的时候，

服务器会常见可以

删除和修改的流程

今天和明天上午任务：
根据老师给的项目，完成增删改查

发表于 分类于 ， ， Waline： 本文字数： 604 阅读时长 ≈ 1 分钟

HTTP协议

工作在应用层

看发的PPT

OSI/RM模型

image-20210730090710203

在浏览器中输入网址，到显示出界面，经过哪些过程。

http://www.njupt.edu.cn

  1. dns解析获取IP
    1. 先查询本地的host
    2. 查询DNS服务器
  2. IP+端口号发起TCP连接
  3. 客户端（浏览器）发起http请求报文，请求默认首页
  4. 服务端回送html文件
  5. 浏览器边解释边执行，在这个过程中会发起多次的http请求，但都是公用同一个tcp连接
  6. 显示完毕。

image-20210730091415331

通信是两个电脑上的程序在相互通信，而不是电脑之间在通信。

HTTP协议的主要特点

请求报文

一个HTTP请求报文由4部分组成：

待补全

请求相应对象

请求报文示例

在浏览器地址栏中输入的都是get请求。

相应报文

  1. 状态行(status line)
  2. 相应消息头(Headers)
  3. 空行(blank line)
  4. 响应体(response body)

后续要看HTTP协议详解PPT

请求重定向

实现方式

response.sendRedirect(“success.html”);

  • 实现原理
    • 通过302状态码和location头来实现

请求转发

请求转发比较好

Request常用方法

Web项目

HelloWorld

修改工作区间的设置？

image-20210730101549799

image-20210730101602854

创建项目是，创建web.xml

image-20210730101708154

image-20210730101913906

image-20210730101947643

image-20210730102037236

修改项目的编码为utf-8

image-20210730102353825

image-20210730102408132

创建html文件，设置html模板的默认编码为utf-8。

image-20210730102609328

image-20210730102749477

image-20210730102759574

image-20210730102816016

创建servlet

image-20210730110122164

image-20210730110054528

image-20210730110146880

Web项目如何引入jar

复制粘贴到WEB-INF/lib目录下

发布到Tomcat中

发表于 分类于 ， ， Waline： 本文字数： 531 阅读时长 ≈ 1 分钟

思想

  • 定义两个指针a和b,
  • 指针b指向顺数第N个节点的位置
  • 然后指针a指向顺序第1个节点的位置
  • 同时把指针b和指针a向后平移
  • 当指针b指向最后一个节点时，此时的指针a指向的就是倒数第n个节点。

java代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
/**
 * 求链表中的倒数第N个节点
 * 
 * @param head 链表的尾节点
 * @param n 要求倒数第几个节点
 * @return 倒数第n个节点的引用变量。
 */
public static Node findNFromLast(Node head, int n) {
    Node nthFromFirst = head;
    // 先求顺数第n个节点的
    for (int i = 0; i < n - 1; i++) {
        nthFromFirst = nthFromFirst.next;
    }
    // 顺数第一个节点
    Node first = head;
    // 把顺数第n个节点向后移动到尾节点，那么
    // 顺数第1个节点就是倒数的第n个节点
    while (nthFromFirst.next != null) {
        nthFromFirst = nthFromFirst.next;
        first = first.next;
    }
    return first;
}

发表于 分类于 ， ， Waline： 本文字数： 789 阅读时长 ≈ 1 分钟

合并有序数组 java代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
/**
 * 合并两个有序的数组
 * 
 * @param a 有序数组
 * @param b 另一个有序数组
 * @return 合并后的有序数组。
 */
private static int[] mergeOrderedArray(int[] a, int[] b) {
    int[] c = new int[a.length + b.length];
    int i = 0, j = 0, k = 0;
    //
    while (i < a.length && j < b.length) {
        //
        if (a[i] <= b[j]) {
            // 先放小的数
            c[k++] = a[i++];
        } else {
            c[k++] = b[j++];
        }
    }
    while (i < a.length) {
        c[k++] = a[i++];
    }
    while (j < b.length) {
        c[k++] = b[j++];
    }
    return c;
}

测试

1
2
3
4
5
6
7
8
public static void main(String[] args) {
    int[] a = { 1, 4, 5, 8, 9 };
    int[] b = { 2, 3, 6, 7, 10, 11, 12 };
    ArrayTools.printArray(a);
    ArrayTools.printArray(b);
    int[] c = mergeOrderedArray(a, b);
    ArrayTools.printArray(c);
}

运行结果：

1
2
3
{1,4,5,8,9}
{2,3,6,7,10,11,12}
{1,2,3,4,5,6,7,8,9,10,11,12}