X32专项练习部分07

链表合并

		/*
        将两个长度为 len1 和 len2 的升序链表
        合并为一个长度为 len1+len2 的降序列表
        采用 归并算法，在最坏情况下，比较操作的次数与（ ）最接近 .
        len1+len2
        len1*len2
        min(len1,len2)
        max(len1,len2)
        
        正确答案：A
        首先链表反转的时间复杂度是O(n)和 O(m)
        然后将两个链表连接，（最优情况）当两个链表一个先走完，另一个没有动的时候结果最优
        也就是反转后len2表拼接len1正好符合降序
        最优的时间为min(len1,len2)
        （最坏情况）当两个链表交替进行的时候，
        举个例子
        len1：{1，3，5}
        len2：{2，4，6}
        连接两个链表的时间最长len1+len2。
         */

链表特点

		/*
        不属于链表特点的是（）
        正确答案: C
        适用于频繁插入
        适用与频繁删除
        存取速度快
        方便扩充

        插入和删除操作可能需要对元素进行大量的移动
        链表的另外一个有点是具有可扩展性，相对于数组的固定大小而言
        由于存储空间不连续，它可以做到根据所需动态分配存储空间，因此具有良好的扩展性，方便扩充
        是对比数组来说的
        它的缺点也很明显，相对于元素按固定下标索引的数组而言，链表的索引更慢，存取速度也就更慢
        链表必须从链表头开始，依次向后查找，平均需要0(n)的时间，存取速度慢
         */

折半查找比较次数

		/*
        折半查找
        设有100个元素的有序表，采用折半查找方法，成功时最大的比较次数是（) 。
        正确答案: D
        25
        50
        10
        7

        重点在于理解题意
        折半查找通俗来说就是一次性比较一半
        所以就是算100能被2除多少次
        换句话说，就是2的多少次幂大于100
         */

String，StringBuffer，StringBuilder的区别

        /*
        String
        StringBuffer
        StringBuilder

        三者的区别：
         */

        /*
        String 不可变的
            final关键字修饰 不可继承，更改
            对字符串进行拼接，裁剪都会创建新的字符串对象
            占用大量方法去内存
            造成性能的浪费
            所以频繁操作字符串
            会影响性能

			String string = "hello";
			string += " world";
			就以上两行代码导致在方法区字符串常量池中创建了3个对象
			"hello"
			" world"
			"hello world"
         */

        /*
        StringBuffer
        	默认初始化容量为16
            为解决String拼接操作产生多个中间对象问题的解决
            而提供的一个类
            拼接字符串采用append方法
            中间对象被垃圾回收期释放
            是线程安全的
            线程安全带来了额外的性能开销

			底层实际上是一个byte[]数组
			向StringBuffer里面添加字符串
			实际上是添加到byte[]数组里面了
			数组满了自动扩容
			
			优化：
			最好是指定一个合适的初始化容量
         */

        /*
        StringBuilder
            和StringBuffer没有本质的区别
            去掉了线程安全
            减少了额外开销
            成为了字符串拼接的首选
         */

列圈数表

	// 例1
	public void func5(int n){
   
        int i = n^2;
        while(i != 1){
   
            i = i / 2;
        }
    }
    /*
    第1步：列圈数表
    循环次数(t) 0   1   2   3   4   5   6
    主变量(i)  n^2 n^2/2 ... ... ... n^2/64

    得到i与t的关系：
        i = n^2 / 2^t

    第2步：找上限
        i = 1的时候会结束
    第3步：1，2联立
        1 = n^2 / 2^t
        解得：
        t = log2的n次方
    第4步：得到时间复杂度
        O(log2的n次方)
     */

	// 例2
	public void func6(int n){
   
        int x = 0;
        while(n >= (x + 1)*(x + 1)){
   
            x = x + 1;
        }
    }

    /*
    第1步：列圈数表
        t   0   1   2   3   4   5   6
        x   0   1   2   3   4   5   6
    第2步：找上限(这里没有具体的上限，只能找范围限制)
        范围限制：n = (x + 1)^2
    第3步：1，2联立，得到t和n的关系
        n = (t + 1)^2
        t = 根号n - 1
    第4步：得到时间复杂度：
        O(根号n)
     */

程序设计题：空格转换为%20

package du;

public class d746 {
   
    public static void main(String[] args) {
   
        String string = "hello world";
        String newString = replaceSpaceToChar(string);
        System.out.println(newString);
    }

    /**
     * 字符串中的空格替换成%20
     * @param string 传入的字符串
     * @return 替换过空格的字符串
     */
    public static String replaceSpaceToChar(String string){
   
        if (string == null){
   
            return null;
        }
        StringBuilder stringBuilder = new StringBuilder();

        for