杰神之JAVA数组常用的函数方法和排序法(冒泡 选择)

原创 2018年01月04日 20:00:15

数组常用的函数方法和排序法(冒泡 选择)

数组常用的函数方法:

  • 1.通过角标 查找对应的元素
    需求:封装一个函数,传入数字1 ,返回一,传入2,返回二
  • 2.通过元素 查找该元素在数组中的位置{角标}
    需求:定义一个数组,分别为3,6,11,22,传入11查找对应的位置
public class Demo01 {
    public static void main(String[] args) {
        System.out.println(findArray(5));
        int[] array = { 3, 6, 11, 22 };
        int a = findIndex(array, 10);
        if (a == -1)
            System.out.println("该数不存在数组中");
        else
            System.out.println(a);
    }
    public static char findArray(int i) {
//      char [] hanzi = new char[]{'一','二','三','四','五'};
//      int [] shuzi = {1,2,3,4,5};
//      int j = 0;
//      for(j = 0;j < 5;j++) {
//          if (shuzi[j] == i) {
//              break;
//          }
//      }
//      return hanzi[j];
        //查表法
        char[] hanzi = new char[] { '一', '二', '三', '四', '五' };
        return hanzi[i - 1];
    }
    public static int findIndex(int [] array,  int a) {
        // 遍历查找 元素对应的角标
        for (int i = 0; i < array.length; i++) {
            // 有可能传入的值不在数组中
            if (array[i] == a) {
                return i;
            }
        }
        // 如果函数执行到这步,就说明 上面没有找到对应的角标,返回-1
        return -1;
    }
}
  • 折半查找
    前提:在有序的数组中查找 查找这个数在数组中的角标
    这里写图片描述
        // 需求:查找22的角标
        //int[] array = new int[]{6,12,15,18,22,25,28,35,46,58,60};
        // 把要用到的变量全部声明一遍
        int[] array = {6,12,15,18,22,25,28,35,46,58,60};
        int min = 0, max = array.length - 1, mid = (min + max) / 2, key = 22;
        //循环查找
        while(key != array[mid]) {
            //如果比中间角标大就挪动小角标
            //如果比中间角标小就挪动大角标
            if (key > array[mid])
                min = mid + 1;
            if (key < array[mid])
                max = mid - 1;
            mid = (max + min)/2;
            if (max < min) {
                mid = -1;
                break;
            }
        }
  • 数组输出的两种方法
    1.Java提供了一些工具包(Arrays.toString)实现了数组输出,在这里就不赘述了
    2.使用for循环,输出数组
        for (int j = 0; j < array.length; j++) {
            System.out.println(array[j]);
        }
  • 数组元素反转的三种方法
    1.Java提供了一些工具包(reverse)实现了数组翻转,这里就不在赘述了
    2.还可以通过倒叙循环,重新new一个数组进行赋值,例如:
private static String[] reverseArray(String[] Array) {    
        String[] new_array = new String[Array.length];    
        for (int i = 0; i < Array.length; i++) {    
            // 反转后数组的第一个元素等于源数组的最后一个元素:    
            new_array[i] = Array[Array.length - i - 1];    
        }    
        return new_array;    
    }    

3.效率更高一些并且在同一个数组上进行数组翻转,例如:

    //传入一个数组
    public static void reverse(int [] array) {
        for (int i = 0; i < array.length/2; i++) {
            int temp = array[i];
            array[i] = array[array.length-1-i];
            array[array.length-1-i] = temp ;
        }
        System.out.println(Arrays.toString(array));
    }

这里写图片描述
例如数组:a,b,c,d,e,f,g
返回结果:g,f,e,d,c,b,a
分析:数组长度为 7
对应数组标记,数组从0开始,也就是0,1,2,3,4,5,6
当长度为单数时,中间位不需要互换,也就是d(4)不需要互换,也就是7/2取整结果3,3+1不需要互换,也就是length/2 +1不需要互换
当长度为双数时,不需要考虑,全部进行互换

总结:需要互换的数据为0~(length/2 -1) 与 length/2 ~ (length -1)
设置循环系统i=0,阈值为lenth/2 - 1,同时倒叙获取后面的参数进行互换。

常用排序法

  • 冒泡排序法
    核心排序思想:相邻两个数进行比较当符合条件交换位置
    冒泡排序法的具体实现方法是这样的,从数组的第一个元素arr[0]开始,两两比较**(arr[n],arr[n+1]),如果前面的数大于后面的数(arr[n]>arr[n+1]),那么交换两个元素的位置,把大的数往后移动。这样依次经过一轮比较以后,最大的数将会被交换到最后的位置(arr[n-1])。
    先一起再来看看冒泡排序法是怎么排序的。
  数组排序前    7    23    12   4    33   21   2    17   13   9          
  第一轮排序    7    12    4    23   21   2    17   13   9    33    
  第二轮排序    7    4     12   21   2    17   13   9    23    
  第三轮排序    4    7     12   2    17   13   9    21                 
  第四轮排序    4    7     2    12   13   9    17    
  第五轮排序    4    2     7    12   9    13        
  第六轮排序    2    4     7    9    12        
  第七轮排序    2    4     7    9    
  第八轮排序    2    4     7   
  第九轮排序    2    4      

可以看到,每一轮的排序,在这一轮中参与比较的元素中最大的数将会浮到最后。而冒泡排序的名字也是从这里来的 。
冒泡排序法的实现:

    public static void maoPao(int[]a) {
        //内循环-1防止数组越界,外循环-1少比一轮,内循环-i控制每一趟都少比一次
        for (int i = 0; i < a.length-1; i++) {
            for (int j = 0; j < a.length - 1 - i; j++) {
                if (a[j + 1] > a[j]) {
                    int temp = 0;//temp用以交换
                    temp = a[j];
                    a[j] = a[j + 1];
                    a[j + 1] = temp;
                }
            }
        }
    }
  • 选择排序法
    排序核心思想:每一趟从待排序的记录中选出最小的元素,顺序放在已排好序的序列最后,直到全部记录排序完毕
    所谓的选择是什么意思呢,选择就是于万千花丛中择其一,在选择排序法中说的就是,每一次循环过程中,通过比较选择出你需要的最值。
    选择排序法的过程是,通过比较,选择出每一轮中最值元素,然后把他和这一轮中最最前面的元素交换,所以这个算法关键是要记录每次比较的结果,即每次比较后最值位置(下标)。
    先来看看选择排序的过程:
数组排序前    7    23    12    4    33    21    2    17    13    9      
第一轮循环    2    23    12    4    33    21    7    17    13    9          
第二轮循环          4    12    23   33    21    7    17    13    9    
第三轮循环               7     23   33    21    12   17    13    9    
第四轮循环                     9    33    21    12   17    13    23         
第五轮循环                          12    21    33   17    13    23    
第六轮循环                                13    33   17    21    23   
第七轮循环                                      17   33    21    23    
第八轮循环                                           21    33    22   
第九轮循环                                                 22    33

通过这个过程,我们可以看到,每轮循环过程中,都会找出这个最值元素,下一轮排序时就不用再考虑这个元素了。
选择排序法的实现:

    public static void maoPao(int[]a) {
        //内循环从i+1开始,防止重复对比,外循环-1少比一轮
        for (int i = 0; i < a.length-1; i++) {
            for (int j = i+1; j < a.length ; j++) {
                if (a[i] > a[j]) {
                    int temp = 0;//temp用以交换
                    temp = a[j];
                    a[j] = a[i];
                    a[i] = temp;
                }
            }
        }
    }
版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/lyj243719866/article/details/78974749

[排序算法]--冒泡排序的三种实现(Java)

冒泡排序是非常好理解的,以从小到大排序为例,每一轮排序就找出未排序序列中最大值放在最后。 设数组的长度为N: (1)比较前后相邻的二个数据,如果前面数据大于后面的数据,就将这二个数据交换。(2)这样...
  • u010853261
  • u010853261
  • 2017-02-06 12:53:44
  • 31679

Java实现冒泡排序算法

一、类和对象使用技巧 1、尽量少用new生成新对象         用new创建类的实例时,构造雨数链中所有构造函数都会被自动调用,操作速度较慢。在某些时候可复用现有对象。比如在进行大量S...
  • xingxiupaioxue
  • xingxiupaioxue
  • 2016-03-07 13:49:08
  • 886

杰神之JAVA数组常用的函数方法和排序法(冒泡 选择)

数组常用的函数方法和排序法(冒泡 选择)数组常用的函数方法: 1.通过角标 查找对应的元素 需求:封装一个函数,传入数字1 ,返回一,传入2,返回二 2.通过元素 查找该元素在数组中的位置{角标} ...
  • lyj243719866
  • lyj243719866
  • 2018-01-04 20:00:15
  • 197

java简单冒泡排序

java的冒泡排序:分两层循环,第一层通过i来控制第二层循环的次数,第二层循环就是单纯的比较,如果后边一个小于前面一个,就交换位置。package ch02;public class BubbleSo...
  • Handsome2013
  • Handsome2013
  • 2018-04-17 16:09:16
  • 4

打擂台排序与冒泡排序(未完)

打擂台排序与冒泡排序 C code: #include #include void print_array(int *array, int n) { int i; ...
  • test1280
  • test1280
  • 2017-04-14 13:08:42
  • 508

Java冒泡排序法和选择排序法

冒泡排序法和选择排序法冒泡排序法概念: 从前向后(或从后向前)依次比较相邻的元素,若发现逆顺序,则交换。小的向前换,大的向后换,像水底的气泡逐渐向上冒,顾名思义冒泡排序法。 通俗一...
  • sinat_34394641
  • sinat_34394641
  • 2017-06-03 02:18:31
  • 1754

Java编写 函数数组(键盘输入n个数) 冒泡排序

Java编写 函数数组(键盘输入n个数) 冒泡排序 //键盘输入n个数,冒泡排序大到小, import java.util.Scanner; public class Maopao{ pu...
  • u013239665
  • u013239665
  • 2014-06-20 16:14:03
  • 4366

<em>函数</em>模板,<em>冒泡</em>排序

7-S1 <em>函数</em>模板<em>冒泡</em>排序 综合评分:0 收藏评论举报 所需: 3积分/C币 下载个...C# ,<em>冒泡</em>排序,<em>JAVA</em> 立即下载 上传者: 钱袋 时间: 2008-11-13 综合评分: ...
  • 2018年04月16日 00:00

js数组排序两种写法(冒泡)

js实现数组的排序方法(sort方法) var arrObj = new Array (1,8,7,6); arrObj.sort(); console.log(arrObj.join(&quot;,...
  • qq_20353887
  • qq_20353887
  • 2017-02-15 14:15:26
  • 1615

【C语言】冒泡法排序的三种实现方法

冒泡法排序的三种实现方法,数组,函数,指针!
  • yaotengjian
  • yaotengjian
  • 2017-05-30 23:32:39
  • 571
收藏助手
不良信息举报
您举报文章:杰神之JAVA数组常用的函数方法和排序法(冒泡 选择)
举报原因:
原因补充:

(最多只允许输入30个字)