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<
ba5e
;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] == 元素 就找到了  否则返回一个负数