07-26

杨辉三角

package com.atguigu.exer;

public class YangHuiTest {

  /**

   * @param args

   */

  public static void main(String[] args) {

     //声明二维数组

     int [][] yangHui = new int[10][];

    

     //数组元素赋值

     for(int i = 0;i < yangHui.length;i++){

       yangHui[i] = new int[i + 1];

    

    

       yangHui[i][0] = 1;

       yangHui[i][i] = 1;

      

       if(i>1){

         for(int j = 1;j < yangHui[i].length - 1;j++){

            yangHui[i][j] = yangHui[i-1][j-1] + yangHui[i-1][j];

         }

        

       }

    

     }

    

     //遍历二位数组

     for(int i = 0;i< yangHui.length;i++){

       for( int j = 0;j< yangHui[i].length;j++){

         System.out.print(yangHui[i][j]+"  ");

       }

       System.out.println();

     }

    

    

  }

}

二分法查找

package com.atguigu.exer;

import org.omg.CORBA.IdentifierHelper;

/*

 * 二分法查找

 *

 * */

public class ArrayExer2 {

  public static void main(String[] args) {

     int[] arr1 = new int[] { -94, -43, -2, 23, 43, 54, 203, 555 };

     int dest1 = -43;

     int head = 0;

     int end = arr1.length - 1;

     boolean isFlag = true;

     while (head <= end) {

       int middle = (head + end) / 2;

       if (dest1 == arr1[middle]) {

         System.out.println("找到了指定元素位置约为" + middle);

         isFlag = false;

         break;

       } else if (arr1[middle] > dest1) {

         end = middle - 1;

       } else {

         head = middle + 1;

       }

     }

     if (isFlag) {

       System.out.println("很遗憾没有找到");

     }

  }

}

排序算法

排序：假设含有n个记录的序列{R1,R2….Rn}，其相应的关键字序列为{K1,K2….Kn}

.将这些记录重新排列为{Ri1,Ri2…Rin},是的相应的关键字满足条Ki1<=Ki2<=…Kin,这样的一种操作成为排序。

通常来说，排序的目的是快速查找。

衡量排序的算法的优劣：

1、时间复杂度：分析关键字的比较次数和记录的移动次数。

2、空间复杂度：分析排序算法中需要多少辅助内存。

3、稳定性若A和B的关键字值相等，但排序后A、B的先后顺序保持不变、则称这种排序算法是稳定的     

排序算法的分类：内部排序和外部排序。

内部排序：整个排序过程不需要借助外部存储器，所有排序操作都在内存中完成。

外部排序：参与排序的数据非常多，数据量非常大，计算机无法把整个排序过程放在内存中完成，必须借助外部存储器。外部排序最常见的是多路归并排序。可以认为外部排序是由多次内部排序组成。

十大内部排序算法

*冒泡排序

package com.atguigu.exer;

public class BubbleSortTest {

  public static void main(String[] args) {

     int[] arr1 = new int[]{-456,46,48,-7,-66,549,6,48,4,6,2,644,1,-66};

    

     //冒泡排序

    

     for(int i = 0 ;i< arr1.length-1;i++){

       for(int j = 0;j < arr1.length-i-1;j++){

         if(arr1[j] > arr1[j+1]){

            int temp = arr1[j];

            arr1[j] = arr1[j+1];

            arr1[j+1] = temp;

         }

       }

      

     }

     for(int i =0;i < arr1.length;i++){

       System.out.print(arr1[i] + "\t");

     }

  }

}

*快速排序

堆排序

归并排序

算法的五大特征

输入（input）

输出（output）

有穷性（有限性）

确定性（明确性）

可行性（有效性）

Arrays工具

package com.atguigu.exer;

import java.util.Arrays;

import javax.swing.plaf.synth.SynthSpinnerUI;

public class ArrayTest {

  public static void main(String[] args) {

    

     //1.boolean equals(int[] a,int[] b)比较两数组是否相等

     int []arr1 = new int[]{1,2,3,4};

     int []arr2 = new int[]{1,2,3,4};

     boolean isEquels = Arrays.equals(arr1, arr2);

     System.out.println(isEquels);

    

     //2.String toString(int[] a)输出数组信息

     System.out.println(Arrays.toString(arr1));

    

     //3.void fill(int[] a,int val) 将指定值填充到数组之中

     //Arrays.fill(arr1, 100);

     System.out.println(Arrays.toString(arr1));

    

     //4.void sort(int[] a)对数组进行排序

    

     Arrays.sort(arr1);

     System.err.println(Arrays.toString(arr1));

    

     //5.int binarySearch(int[] a,int key)

     int[] arr3 = new int[]{-456,46,48,-7,-66,549,6,48,4,6,2,644,1,-66};

     int index = Arrays.binarySearch(arr3,898);

     if(index >=0){

       System.out.println(index);

     }else{

       System.out.println("没找到");

     }

    

    

    

  }

}