题记1

 1.最坏情况：n+n-1+...+1 = n(n-1)/2

  2.正确答案 ： A 解析 ：【解析】在顺序表中查找，最好情况下第一个元素就是要查找的元素，则比较次数为 1 ；在最坏情况下，
最后一个元素才是要找的元素，则比较次数为 n 。两种情况平均即（ 1+n ） /2 。故本题答案为 A 选项。

  3.二分查找通过左右端数据相加除以2求中点位置mid，数据每次与中点位置比较，小于中点，右端点变为mid-1，否则左端点变为mid+1。
所以要求线性表是顺序存储结构且要有序。查找的平均长度为log以2为底n

  5.顺序表：将元素顺序地存放在一块连续的存储区里，元素间的顺序关系由它们的存储顺序自然表示
链表：将元素存放再通过链接构造起来的一系列存储块中

  8.用堆排序最好，因为堆排序不需要等整个排序结束就可挑出前10个最大元素，
而快速排序和基数排序都需等待整个排序结束才能知道前10个最大元素。

 9. A循环遍历记录一个临时比较量max或者min。
       B平均值要求和的，有序无序都要求和除个数的。
       C 求中间值，如果不排序，中间的值意味着他前面的比他小，后面的比他大，然后多个循环多个遍历先不排序可以。那如果排序了呢？只要通过个数的1/2的值索引，即可以找到。显而易见，先排序更优。
       D次数最多？那就是记录一下一样值的个数，临时量一直保存当前最大的个数。不需要排序，效果一样。

   10. 最小字母为A 最大字母为U,若升序排序完成顺序应该是ADINQU
两趟排序导致QU是有序的,其他四个字母还无序,选择排序则QU应该在后面,冒泡和堆排序两趟也会使元素到达他最终位置,所以排除
选择C

11.平均时间的计算方式如下~
    首先，假定这个数组的长度为n。
目标等概率出现在任意位置，即出现在每个位置的概率均为1/(n+1)，其中，找不到的概率也是1/(n+1)
然后，对于第i个位置，需要i次比较才能找出来，则找到的情况下，共需1+2+...+n次查询，即(n*(n+1))/2。
找不到的情况下，也是n次查询。
故平均时间为总比较数，除以位置数，即((n*(n+1))/2+n)/(n+1)=n/2+n/(n+1)。
如果一开始直接当找到，算出来就是(n+1)/2
两个结果都可以当作是n/2

12.
题目有些歧义对于朴素的冒泡排序（如下）来说，不管是最好还是最坏情况，性能都是O(n^2)：

for i=1  to n-1
     for j=1 to n-i
         if( a[ j ] > a [ j+1 ]   )           
             swap(a[ j ] ,a[ j+1 ] ) ;

改进的冒泡排序，增加一个flag标志，如果某一趟 j=1 to n-i 的比较都未交换元素，说明序列已经有序，不用再比较了，在最好的情况下，也就是序列已经有序的情况下，只要一趟就能完成排序，时间复杂度为O( n )：

for i=1  to n-1
    flag =t rue;
    for j =1 to  n-i
         if( a[  j  ] > a [  j+1 ]   )
             swap(a[  j  ] ,a[  j+1 ] ) ;
             flag=false;
    if( flag )  break;

如果 认为题中所说的冒泡排序是朴素的冒泡排序，那么答案应该选C。

13.基数排序：将所有待比较数值（正整数）统一为同样的数位长度，数位较短的数前面补零。然后，从最低位开始，依次进行一次
排序。这样从最低位排序一直到最高位排序完成以后, 数列就变成一个有序序列。可以同时操作多个元素，从而实现了并行处理。

 14. 首先，稳定性是指如果待排序数据中有多个相同的元素，如果在排序完后相同元素的顺序不发生改变，则为稳定的排序，否则为非稳定的排序。
A.快速排序就是利用切分算法依次确定n个元素的最终位置。所以，我们直接来分析切分算法。举例来说， 有待切分子数组: 5 8 3 7 3 9 7，切分元素为5，从后遍历得到第一个小于切分元素5的数据为3(index = 5)，从前遍历得到第一个大于5的元素为8，交换3和8，这样，元素3的稳定性就被破坏了。

B.冒泡排序为依次从前往后与相邻值比较交换从而将未排序的最大值移至最后。如 9 8 6 9 0 ，当第一个9移至 8 6 9 9 0时，只要我们保证只有当前一个元素大于(而不是大于等于)下一个元素时才交换，就可保证排序的稳定性。

C.选择排序为每一次从第i个元素后面选择一个最小元素放入第i个位置.(i从0 到 n -1)。
举例 4 5 4 3，在第一轮交换中，我们找到最小元素3(index = 3),需要将其与第一个元素 4(indx = 1)。我们发现，当第i个元素和它后面的最小元素中间还存在 元素i 时将破坏元素i的稳定性。  

D.归并排序同样是分治并合并两个有序子数组的过程。因此，和快速排序一样，我们只需要考察合并有序子数组的算法即可。 当合并有序子数组时，我们会利用辅助数组，每一次都将两个子数组中较小的元素放入即可辅助数组，直至全部放入。
只要我们保证当遍历到当前两个子数组值相同时，先将第一个元素放入即可保证排序后的稳定性。所以，归并排序是稳定性。

 16.快速排序的平均时间为Tavg(n)=knln(n),其中n为待排序记录中记录的个数，k为某个常数，
经验证明，在所有同数量级的此类（先进的）排序方法中，快速排序的常数因子k最小。

 17. 思想类似于两端向中间扫描
1、设定两个指针P1、P2，分别指向数组开始和结尾，即P1指向最小值，P2指向最大值；
2、计算 *P1+*P2 的值为 SUM，与 sum 比较，记录它们的差值 DIF 和 SUM，若 SUM<sum，P1++，若SUM>sum，P2--;
3、重复以上过程直到DIF最小

18.从上面代码可以看出套了两次循环，基本的复杂度n的平方，最差的情况：复杂度不变：刚好和你的排序成逆序，时间复杂度为n的平方,
第一次循环要做元素交换的次数为n-1，第二次循环要做的次数为n-1,如此推下去要做元素交换的次数为：
(n-1) + (n-2) + (n-3) + ... + 2 + 1 ,计算下来结果为：C=n(n-1)/2;这个为交换次数次数。最好的情况已排好序，没有进行交换操作。

按流程分析就可以了

先排序，在从大往小找，两个数字互相判断

二维数组遍历，判断大小

思路：首先创建一个数组，用来存放两个数字的下标；遍历数组中的元素，看数组当中是否存在两个元素的和等于target；

题中有选择排序的思想，记录元素的下标，放入数组当中

思路：首先创建一个新数组用来存放nums1和nums2；两个数组当中的元素应依次放入数组当中；然后求中位数

思路：题的重点渗透到了连续相等，只需要把后面的不相等元素往前移，覆盖前面相等的元素

思路：当前题目的思想和上面的题是一样的，连续相等

思路：先判断是否存在，存在的话直接用String中的indexOf访问第一个元素的下标；不存在就return -1；

思路：这个题简单，遍历数组查找元素

思路：找到与目标值相等的元素后，进行计数；直到没有相等的元素，用当前的下标i-right+1是第一个出现的下标，i是最后一个元素出现的下标

当查找表中元素个数为1个或2个时，二分法和顺序法速度相等；当元素个数大于2个时，二分法更快。（前提是有序表）

程序执行的效率主要和CPU速度，程序的循环逻辑和选择逻辑的关系，程序的数据结构，数据量的使用

二分查找需要满足两点要求：序列有序；可以随机访问；

对于冒泡排序和选择排序，每一趟都能确定一个元素的最终位置，而题目中，
前 2 个元素和后 2 个元素均不是最小或最大的 2 个元素并按序排列。选项 D 中的 2 路归并排序，
第一趟排序结束都可以得到若干个有序子序列，而此时的序列中并没有两两元素有序排列。
插入排序在每趟排序后能确定前面的若干元素是有序的，而此时第二趟排序后，序列的前三个元素是有序的，符合其特征。

float一般为4个字节，以0做下标，计算第15个则不包括第15个，所以只有15个
15*4+200=260；

非线性时间比较类排序：通过比较来决定元素间的相对次序，由于其时间复杂度不能突破O(nlogn)，
因此称为非线性时间比较类排序。
线性时间非比较类排序：不通过比较来决定元素间的相对次序，它可以突破基于比较排序的时间下界，
以线性时间运行，因此称为线性时间非比较类排序。

排序方法按照排序过程中所涉及的存储器可分为内排序和外排序两种，其中，
待排序记录全部存放在计算机内存中进行排序的过程，
称为内排序；而由于待排序记录的数量很大使得排序过程中也需要对外存设备进行访问的排序过程，称为外排序。
内、外排序强调的是所涉及的存储器的不同，而下面的排序算法，
都可以看做内排序，非线性时间比较类排序是基于关键字比较的，而线性时间非比较类排序是不基于关键字排序的。

A[i][j] = 起始位置+i*5+j => 1000+5i+j

676-644=32=2*Len+2，可以知道Len=15。 因此，答案 [3][3]=[0][0]+3*Len+3=644+48=692

这题简单，但是也要注意语言之间的差距，整数的拆分你不用考虑前面的负号

这个题和上面的差不多，只需要判断正整数，题中的定义得知负数肯定不是回文数

~需求： 模拟 宠物使用背包中的物品

宠物类  属性 HP 血量 MP 魔法 ATC 攻击力 DEF 防御力  SPEED速度  Money 钱
方法  攻击(宠物) 算法 (攻击方 ---防御方)
      伤害= (攻击力 -防御力) 2
     下一次攻击  防御方会变成攻击方  攻击方变成防御方
     如果两个宠物是同一个宠物 不能进行攻击

当某一方的宠物的血量为0时 则战斗结束

 

public class Playgame{
    public static void main(String []args){
        //提示用户进入游戏
        System.out.println("----------------------欢迎你进入游戏--------------------");
        //打印游戏界面的选项
        print();
        Petplay challege=new Petplay();
        System.out.println(challege.winner());
    }
    public static void print(){
        System.out.println("----------------游戏界面----------------");
        System.out.println("---宠物对战---");
        System.out.println("---游戏商店---");
        System.out.println("---人物背包---");
    }
}

/**
 * @auther 黄秀升
 * h1850190437@163.com
 * 提示用户选择人物的性别、设置人物的昵称
*/
import java.util.Scanner;
public class Person extends Pet{
    //人物的名称
    private  String personname;
    //人物的性别
    private  String personsex;
    //创建一个宠物对象
    //public Pet goodperson=new Pet();
    public Person(){}
    //用户初始化人物名称和性别
    public void personstart(){
        System.out.println("请输入人物的昵称和性别：");
        Scanner scanner=new Scanner(System.in);
        this.personname=scanner.nextLine();
        this.personsex=scanner.nextLine();
        System.out.println();
    }
    //返回宠物的特征
    public String persons(){
        petstart();
        return toString(personname,personsex);
    } 
    //返回人物的名称
    public String getperson(){
        return personname;
    }
}

/**
 * 野怪的创建 在Pet类中随机选取
*/
import java.util.Scanner;
public class Badanimal extends Pet{
    //人物的名称
    private String badman;
    //人物的性别
    private String badmansex;
    public Badanimal(){}
    //创建一个Pet类 
    //public Pet badanimal=new Pet();
    //另一个人物的用户初始化
    public void badanimalstart(){
        System.out.println("请输入另一个人物的昵称和性别：");
        Scanner scanner=new Scanner(System.in);
        this.badman=scanner.nextLine();
        this.badmansex=scanner.nextLine();
        System.out.println();
    }
    //返回宠物的特征
    public String badanimals(){
        petstart();
        return toString(badman,badmansex);
    } 
    //返回人物的名称
    public String getbadman(){
        return badman;
    }
}
/**
 * 实现宠物的打架，及时更新；
 * 剩余的血量=血量-(int)((攻击力-防御力)*2)/speed；
 * 剩余的蓝量=蓝量-攻击回合数；
*/
public class Petplay {
    private int petplayhp;
    private int petplaymp;
    //创建两个人物的对象，及宠物的对象，以及对抗的类
    public Pet animal=new Pet();
    public Person person=new Person();
    public Badanimal badanimal=new Badanimal();
    public Petplay(){
    //调用类中的方法进行初始化
    person.personstart(); 
    badanimal.badanimalstart();
    //输出两个人物宠物的特征
    System.out.println(person.persons());
    System.out.println("-----------------------");
    System.out.println(badanimal.badanimals());
    System.out.println("-----------------------");
    System.out.println(person.getperson()+"的伤害："+(person.getatc()-badanimal.getdef()));
    System.out.println(badanimal.getbadman()+"的伤害："+(badanimal.getatc()-person.getdef()));
    }
    //判断输赢
    public String winner(){
        boolean flag=true;
        int cout=0;
        while(true){
            minbadpet();
            bigpersonpet();
            cout++;
            if(badanimal.gethp()<=0){
                flag=false;
                break;
            }
            if(person.gethp()<=0){
                break;
            }
        }
        if(flag){
            return "赢家是："+badanimal.getbadman()+",经过了"+cout+"回合";
        }else{
            return "赢家是："+person.getperson()+",经过了"+cout+"回合";
        }
    }
    //准备开始play
    public void bigpersonpet(){
        petplayhp=person.gethp()-(badanimal.getatc()-person.getdef());
        person.sethp(petplayhp);
    }
    //准备开始play
    public void minbadpet(){
        petplayhp=badanimal.gethp()-(person.getatc()-badanimal.getdef());
        badanimal.sethp(petplayhp);
    }
}
/**
 * 实现宠物的选择
 * 需求： 模拟 宠物使用背包中的物品

 宠物类  属性 HP 血量 MP 魔法 ATC 攻击力 DEF 防御力  SPEED速度  Money 钱
方法  攻击(宠物) 算法 (攻击方 ---防御方)
      伤害= (攻击力 -防御力) 2
     下一次攻击  防御方会变成攻击方  攻击方变成防御方
     如果两个宠物是同一个宠物 不能进行攻击

当某一方的宠物的血量为0时 则战斗结束

方法 使用物品
使用 绿箭 +血量10（补血+提高血量上限）
     红箭 + ATC 10
     
背包类  背包里面放物品 
物品类  物品的名称  物品的价格  物品的数量 (以及物品的作用)
*/
import java.util.Random;
public class Pet{
    private String name;//宠物的名字
    private String stype;//属性
    private int hp;//血量
    private int mp;//魔法
    private int atc;//攻击力
    private int def;//防御力
    private int speed;//速度
    private int money;//金钱数
    //创建一个Petstypes类，用于调用宠物的名称和属性
    public Petstypes stypeanimals=new Petstypes();
    public Pet(){}
    //宠物特征的初始化
    public void petstart(){
        Random random=new Random();
        name=stypeanimals.getpetname();
        stype=stypeanimals.getpetstype();
        hp=100;
        mp=100;
        atc=random.nextInt(50)+70;//攻击力[70,120)
        def=random.nextInt(30)+20;//防御力[20,50)
        speed=random.nextInt(30)+1;//移速[1,31)
        money=random.nextInt(201);//价格随机取[0,201)
    }
    //返回宠物特征的字符串拼接
    public String toString(String personname,String personsex){
        return "人物名称："+personname+"\n"+
               "人物性别："+personsex+"\n"+
               "宠物名称："+name+"\n"+
               "宠物属性："+stype+"\n"+
               "宠物血量："+hp+"\n"+
               "宠物蓝量："+mp+"\n"+
               "宠物攻击力："+atc+"\n"+
               "宠物防御力："+def+"\n"+
               "宠物速度："+speed+"\n"+
               "宠物价格："+money;
    }
    public void setname(String name){
        this.name=name;
    }
    public String getname(){
        return name;
    } 
    public void  sethp(int hp){
        this.hp=hp;
    }
    public int  gethp(){
        return hp;
    } 
    public void  setmp(int mp){
        this.mp=mp;
    }
    public int  getmp(){
        return mp;
    } 
    public void setatc(int atc){
        this.atc=atc;
    }
    public int  getatc(){
        return atc;
    } 
    public void setdef(int def){
        this.def=def;
    }
    public int  getdef(){
        return def;
    } 
    public void setspeed(int speed){
        this.speed=speed;
    }
    public int  getspeed(){
        return speed;
    } 
}
/** 
public Pet(String name,String stype,int hp,int mp,int atc,int def,int speed,int money){
        this.name=name;
        this.stype=stype;
        this.hp=hp;
        this.mp=mp;
        this.atc=atc;
        this.def=def;
        this.speed=speed;
        this.money=money;
    }
    public void setname(String name){
        this.name=name;
    }
    public String getname(){
        return name;
    } 
    public void setstype(String stype){
        this.stype=stype;
    }
    public String getstype(){
        return stype;
    } 
    public void sethp(int hp){
        this.hp=hp;
    }
    public int  gethp(){
        return hp;
    } 
    public void setmp(int mp){
        this.mp=mp;
    }
    public int  getmp(){
        return mp;
    } 
    public void setatc(int atc){
        this.atc=atc;
    }
    public int  getatc(){
        return atc;
    } 
    public void setdef(int def){
        this.def=def;
    }
    public int  getdef(){
        return def;
    } 
    public void setspeed(int speed){
        this.speed=speed;
    }
    public int  getspeed(){
        return speed;
    } 
    public void setmoney(int money){
        this.money=money;
    }
    public int  getmoney(){
        return money;
    } 
*/

/**
 * 宠物的分类,以及返回名字和属性
 * 宠物的属性
*/
import java.util.Random;
public class Petstypes{
    //创建一个数
    private int number;
    //创建宠物名称和属性的字符串数组
    private String[] arrpet;
    private String[] arrpetstype;
    //宠物名称和属性的字符串数组的初始化
    public Petstypes(){
        arrpet=new String[]{"护主犬","灵石侯","水蓝蓝","黄金独角兽","火花","魔力猫"};
        arrpetstype=new String[]{"火","石","水","金","火","草"};
        Random random=new Random();
        number=random.nextInt(arrpet.length);
    }
    //返回宠物的名字
    public String getpetname(){
        return arrpet[number];
    }
    //返回宠物的属性
    public String getpetstype(){
        return arrpetstype[number];
    }
}