数组排序、递归——（Java学习笔记二）

升序： 

    选择排序：

        选定一个元素，一次和后面的元素相比较，如果选定的元素大雨后面的比较元素，就交换位置

        先出现最小值，最后出现最大值。

 public static void main(String[] args) {
  int[] arr = {5,8,9,12,55,565,421,12,2512,-5,-56};
  sortMethod(arr);
  p(arr);
 }
   //排序核心代码
 private static void sortMethod(int arr[]) {
  for(int i = 0 ;i<arr.length - 1;i++){
   for(int j = i + 1;j<arr.length;j++){
    if(arr[i] > arr[j]){
     int temp = arr[j];
      arr[j] = arr[i];
      arr[i] = temp;
    }
   }
  }
 }

//打印数组元素
 static void p(int[] arr) {
  String ret = "[";
  for(int i = 0;i<arr.length;i++){
   ret += arr[i];
   if(i == arr.length - 1){
    ret += "]";
   }else{
    ret += ",";
   }
  }
  System.out.println("---------->"+ret);

　　

 冒泡排序：

        相邻两个元素依次相比较

        先出现最大值，最后出现最小值。

public static void main(String[] args) {
  int arr[] = {6,9,4589,442,458,5232,-788,7,545,-44,55,-11};
  sortMethod(arr);
  p(arr);
 }
 private static void p(int[] arr) {
  String ret = "[";
  for(int i = 0; i < arr.length; i ++){
   ret += arr[i];
   if( i == arr.length - 1){
    ret += "]";
   }else{
    ret += ",";
   }
  }
  System.out.println("---------->" + ret);
 }
 private static void sortMethod(int[] arr) {
  for(int j = 1;j<arr.length;j++){
   for(int i = 0; i <arr.length - j;i++){
    if(arr[i] > arr[i + 1]){
     int temp = arr[i];
     arr[i] = arr[i + 1];
     arr[i + 1] = temp;
    }
   }
  }
 }

二分查找法：

    先对代码进行排序，再取中间值，再拿指定值跟中间值进行比较，如果小于中间值，查找范围就变成最小的索引值到中间值索引减1，如果指定值大于中间值，则查找范围变成中间值索引加1到最大的索引值。

优点：缩小查找范围，提高性能

 //查找指定数组指定元素的索引值。
 public static void main(String[] args) {
   int[] arr = {5,4,231,45,75,45,11,-11,-21,-45};
   int key = 45;
   sortMethod(arr);
   printSort(arr);
   int index = binarySeach(arr,key,0,arr.length - 1);
   System.out.println("----------->所求索引值："+index);
  }
 //二分查找法核心代码
  private static int binarySeach(int[] arr, int key,int fromIndex,int toInedx) {
   //最小索引与最大索引
   //fromIndex 表示从哪个位置开始查找，toIndex表示到那个位置结束
   int minIndex = fromIndex,maxIndex = toInedx;
   while(maxIndex >= minIndex){
    //中间索引
    int midIndex = (maxIndex + minIndex)/2;
    //中间索引的值
    int midIndexVal = arr[midIndex];
    if(key > midIndexVal){
     minIndex = midIndex + 1;
    }else if(key < midIndexVal){
     maxIndex = midIndex - 1;
    }else{
     return midIndex;
    }
   }
   return -1;
  }
 //打印排序后的代码
  private static void printSort(int[] arr) {
   String ret = "[";
   for(int i = 0;i<arr.length;i++){
    ret +=arr[i];
    if(i == arr.length - 1){
     ret += "]";
    }else{
     ret += ",";
    }
   }
   System.out.println("----------->排序：" + ret);
  }
 //对代码进行排序
  private static void sortMethod(int[] arr) {
   for(int j = 0;j<arr.length - 1;j++){
    for(int i = 0;i<arr.length - j - 1;i++){
     if(arr[i] > arr[i + 1]){
      int temp = arr[i];
       arr[i] = arr[i+1];
       arr[i+1] = temp;
     }
    }
   }
  }

数组的拷贝：

     /**
  *
  * @author Essence
  *arraycopy(Object src, int srcPos, Object dest,int destPos, int length)
  *该方法接收四个参数
  *object src :原数组，即被拷贝的数组
  *int srcPos: 原数组的目标位置 即从哪个位置开始拷贝起
  *Object dest:目标数组 即用来存储被拷贝的数组
  *int destPos：目标数组中的起始位置，即向目标数组中插入数据的起始位置
  *int length:要复制的元素数量
  */
     public static void main(String[] args) {
   String[] arr = {"A","B","C","D"};
   String[] arr1 = new String[5];
   System.out.println(Arrays.toString(arr1)); // 拷贝之前 ： [null, null, null, null, null]
   System.arraycopy(arr, 1, arr1,2, 3);
   System.out.println(Arrays.toString(arr1)); //拷贝之后： [null, null, B, C, D]

  }

可变参数：

 /**
  * Java5 出现的新特性 参数可变
  * 可变参数必须作为参数的最后一个参数 ，参数可以直接传递0到n个
  *其本质上就是数组
  * method（int ... arr）
  * @author Essence
  *
  */
     public static void main(String[] args) {
   int[] arr = {1,2,347,7,78,9};
   System.out.println(getSum(arr));
   /**
    * 可变参数调用特点：
    * getSum(1,2,34,5)
    */
   System.out.println(getSum(1,2,34,5));

  }
  private static int getSum(int ... arr) {
   int sum = 0;
   for(int i = 0;i<arr.length;i++){
    sum += arr[i];
   }
   return sum;
  }
  }

可变参数可以当做一位数组来调用：getSum(new int[] {1,2,3,4,5});

也可以直接写参数，个数任意，但是类型必须一致：getSum(1,2,34,5)

递归：

    基本思想：自己调用自己

    结构：

        递归头：定义递归结束的时候，什么时候不调用自身方法。如果没有定义头，将会陷入死循环

        递归体：什么时候需要调用自身方法

利用递归解决阶乘问题：

   public class Demo{
             public static void main(String[] args) {
   long sum = factorial(10);
   System.out.println(sum);
  }
  static long factorial(int n){
   if(n==1){
    return 1;
   }else{
    return n*factorial(n-1);
   }
  }
 }

Java编程思想上的两个题斐波那契数列与吸血鬼数字

斐波那契数列：　　

/*
* 1,1,2,3,5,8,13,21,34
* 起那两个数是第三个数的和
* 斐波那契数列
* F(n) = F(n-1)+F(n-2)
*/
  方法一：
 private static void fibonacci(int n) {
      int arr[] = new int[n],sum = 0;
      arr[0] = arr[1] = 1;
  for(int i = 2;i<arr.length;i++){
           arr[i] = arr[i - 1] + arr[i-2];
           System.out.println("arr["+i+"] "+arr[i]);
           sum += arr[i];
      }
      System.out.println("斐波那契数列之和：" +sum);
 }
    方法二：
private static int sumFibonacci(int n) {
  if(n<1){
   return 1;
  }else{
   return sumFibonacci(n - 1) + sumFibonacci(n - 2);
  }
 }
 private static void getFibonacci(int n) {
  for(int i = 0;i <= n;i++){
   int f = sumFibonacci(i);
   System.out.print(f + "\t");
   if(i%3 == 0){
    System.out.println();
   }
  }
 }
方法三：
 private static void fibbonacci1(int n){
  int a = 1,b = 1,c = 0 , sum = 0;
  System.out.println(a+"\t"+b+"\t");
  for(int i = 1;i<=n;i++){
   c =a +b;
   a = b;
   b = c;
   sum += c;
   System.out.print(c+"\t");
   if(i%3==0){
    System.out.println();
   }
  }
  System.out.println("斐波那契数列之和：" +sum);
 }

吸血鬼数字：

/*
*1260=21*60
*1827=21*87
*2187=27*81
*/
 1   private static void vampireNumber1() {
   for(int i = 1;i<100;i++){
    for(int j = 1;j<100;j++){
     if(i*j>1000){
      String a = i+""+j;
      String b = i*j+"";
      if(equals(a,b)){
       System.out.println(i+"\t"+j+"\t"+i*j);
      }
     }
    }
   }
  }
  private static boolean equals(String a, String b) {
   // TODO Auto-generated method stub
   char[] aArrays ,bArrays;
   aArrays = a.toCharArray();
   bArrays = b.toCharArray();
   Arrays.sort(aArrays);
   Arrays.sort(bArrays);
   if(Arrays.equals(aArrays,bArrays)){
    return true;
   }
   return false;
  }