Java中选择，冒泡，快排原理代码 阶层 数组的排序 数组的排序 以及代码大全

一、方法的重载
     概念：在同一个类中，方法名相同，参数列表不同，与返回值无关
     优点：设计重载的目的是减少方法名的个数，便于程序员掌握，
           程序在运行的过程中通过传递不同的参数，动态去调用与之最匹配的方法去执行


     参数列表不同：顺序不同，类型不同
二、递归
    阶层
      5!=5*4*3*2*1


class Demo5 
{
public static void main(String[] args) 
{
int jc = jieCheng(3);
System.out.println(jc);
int jc2 = method(3);
System.out.println(jc2);
}
public static int jieCheng(int n){
int result = 1;
for(int i = n;i>0;i--){

result*=i;  
}
return result;
}
//求阶乘 用递归的方式 -->自己调自己 
public static int method(int i){
if(i == 1){
return 1;
}else{
return i*method(i-1);
}
}
}


      递归：由此及彼，由此类推  自己调用自己
      步骤：1.给程序一个出口 当满足这一条件的时候  循环结束
            2.在符号条件的情况下  简化同性质的问题  调用自己  得到问题的答案
       


三、数组
     什么是数组：
         就是用来存储同一种数据类型，定长的容器
     类型：引用数据类型----数组类型
     优点：1
         .可以存储多个同类型数据
         .可以给这些数据从.开始编号。方便操作这些数组；
     格式：
     动态初始化
         int[] x=new int[5];
//数据元素类型 []  数组名=new  数据元素类型[数组中元素个数]
     静态初始化
         int x={10,20,30};
          //数据元素类型 []  数组名={1,2,3};
确定数组元素内容（就用静态）
确定数组长度，不确定元素（用动态）
内存分析：
       Java程序在运行时，需要在内存中分配空间，为了提高运算效率，又对空间进行不同区域的划分，
           因为每一篇区域都有特定的处理数据方式和内存管理方式
 
栈内存（Java特色，垃圾回收机制）
   用于存储局部变量(方法里的，形式参数列表，定义在for循环)  当数据使用完  自动释放
        堆内存
  用于存储数组和对象  通过new 建立的实例都放在堆内存中
  每一个实体都有一个内存地址值
  实体中的变量都有默认初始值
     byte,short,int---->0
     long----->0L
     float---->0.0F
     double----->0.00
     boolean----->false
     char------>\u0000----->表示空
     引用数据类型---->null
     
遍历数组的两种方式
   1.普通for循环
      for (int i=0; i<z.length; i++)
{
System.out.println(z[i]);
}
        
   2.增强for循环
       for (int i:z )
{
System.out.print(i);
}


区别：普通for   循环变量代表角标  再循环体中  可以获取角标/元素  可以进行复杂的操作
      增强for   不存在角标  不能进行复杂的运算


数组的排序：从小到大   从大到小
         1.选择排序：(从小到大)
  选择一个位置,那这个位置的值不断的和其他位置的值比较
class Dome9 
{
public static void main(String[] args) 
{
int [] arr={11,5,8,6,3};
         printArray(arr);
}
public static void printArray(int[] arr){
for (int i=0; i<arr.length;i++)
{
for (int j=i+1; j<arr.length; j++)
{
if (arr[i]>arr[j])
{
int temp=arr[i];
arr[i]=arr[j];
arr[j]=temp;
}
}
}
for (int i=0;i<arr.length ;i++ )
{
System.out.print(arr[i]+",");
}
    }
}






2.冒泡排序：
             相邻两个元素进行比较


3.快速排序：
class Demo3 
{
public static void main(String[] args) 
{
//冒泡 相邻两个元素之间进行比较
int[] arr = {3,4,1,5};

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

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

                                 int temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}
printArray(arr);
}
public static void printArray(int[] arr){
for(int i=0;i<arr.length;i++){
System.out.print(arr[i]+",");
}
}
}

//快速排序
    class Dome11 
       {
public static void main(String[] args) 
{
int [] arr={5,8,9,6,3,4,2,1};
        quickSort(arr,0,arr.length-1);
        printArray(arr);


}
public static void quickSort(int arr[],int x,int y){
int i=x;
int j=y;
int p=arr[(x+y)/2];
while(i<=j){
  while(arr[i]<p){
    i++;
  }
  while(arr[j]>p){
  j--;
  }
  if(i<=j){
  int temp=arr[i];
  arr[i]=arr[j];
  arr[j]=temp;
  i++;
  j--;
  }
  if(x<j){
  quickSort(arr,x,j);
  }
  if(i<y){
  quickSort(arr,i,y);
  }
}
}
public static void printArray(int[] arr){
  for (int i=0;i<arr.length ;i++ )
{
System.out.print(arr[i]+",");
}

}
}


     1.设置起点/结束点 和一个基准值


              2.将比基准值小的移动到左边  大的移动到右边
             起始点  循环  右移
     结束点  循环  左移
     3.比比基准值  小的范围扩大  让比 基准值  大的范围扩大
        当起点和结束点 错开了 证明第一轮循环结束
数组角标的查找：
        1.顺序查找 
2.二分查找/折半查找
前提:必须是有序数列 升序/降序都可以
通过将待查找的元素与中间索引值对应的元素进行比较,
若小于中间元素,去左边 end = middle-1
若大于中间元素,去右边 start = middle+1
继续折半 直到当arr[middle] == 元素 就找到了  否则返回一个负数