数组的一些简单算法

最新推荐文章于 2022-10-28 21:53:44 发布

「已注销」

最新推荐文章于 2022-10-28 21:53:44 发布

阅读量284

点赞数

分类专栏： Java基础知识文章标签：基础知识

本文链接：https://blog.csdn.net/YouLing_0809/article/details/85113200

版权

Java基础知识专栏收录该内容

1 篇文章 0 订阅

订阅专栏

题目分析：
通过观察发现，本题目要实现原数组元素倒序存放操作。即原数组存储元素为{11,22,33,44}，逆序后为原数组存储元素变为{44,33,22,11}。
1、通过图解发现，想完成数组元素逆序，其实就是把数组中索引为start与end的元素进行互换。
2、每次互换后，start索引位置后移，end索引位置前移，再进行互换
3、直到start位置超越了end位置，互换结束，此时，数组元素逆序完成。
解题步骤：
1、定义两个索引变量start值为0，变量end值为数组长度减去1（即数组最后一个元素索引）
2、使用循环，完成数组索引start位置元素与end位置元素值互换。
3、在循环换过程中，每次互换结束后，start位置后移1，end位置前移1
4、在循环换过程中，最先判断start位置是否超越了end位置，若已超越，则跳出循环
代码如下：

 public  void receive(int[] arr){                               
 	for (int start = 0, end = arr.length-1; start < end; start++,end--) { 
 		int temp = arr[start];                               
 		arr[start] = arr[end];                               
 		arr[end] = temp;                                     
 	}                                                         
 }

2、选择排序

分析图：

题目分析：
通过观察发现，本题目要实现把数组元素{13,46,22,65,3}进行排序
1、提到数组排序，就要进行元素值大小的比较，通过上图发现，我们想完成排序要经过若干次的比较才能够完成。
2、上图中用每圈要比较的第一个元素与该元素后面的数组元素依次比较到数组的最后一个元素，把小的值放在第一个数组元素中，数组循环一圈后，则把最小元素值互换到了第一个元素中。
3、数组再循环一圈后，把第二小的元素值互换到了第二个元素中。按照这种方式，数组循环多圈以后，就完成了数组元素的排序。这种排序方式我们称为选择排序。
解题步骤：
1、使用for循环（外层循环），指定数组要循环的圈数（通过图解可知，数组循环的圈数为数组长度 - 1）
2、在每一圈中，通过for循环（内层循环）完成数组要比较的第一个元素与该元素后面的数组元素依次比较到数组的最后一个元素，把小的值放在第一个数组元素中
3、在每一圈中，要参与比较的第一个元素由第几圈循环来决定。如上图所示
a) 进行第一圈元素比较时，要比较的第一个元素为数组第一个元素，即索引为0的元素
b) 进行第二圈元素比较时，要比较的第一个元素为数组第二个元素，即索引为1的元素
c) 依次类推，得出结论：进行第n圈元素比较时，要比较的第一个元素为数组第n个元素，即数组索引为n-1的元素
具体代码：

System.out.println("start:" + System.currentTimeMillis());
                                                          
int[] sortArray = {100,98,140,34,25,120,130};             
                                                          
/*                                                        
*选择排序                                                     
*/                                                        
for (int i =0;i <sortArray.length-1;i++){                 
    for (int j = i+1;j <sortArray.length;j++){            
        if (sortArray[i] > sortArray[j]){                 
            int temp = sortArray[i];                      
            sortArray[i] = sortArray[j];                  
            sortArray[j] = temp;                          
        }                                                 
    }                                                     
}                                                         
/*

3、冒泡排序

分析图：

题目分析：
通过观察发现，本题目要实现把数组元素{13,46,22,65,3}进行排序
1、提到数组排序，就要进行元素值大小的比较，通过上图发现，我们想完成排序要经过若干次的比较才能够完成。
2、上图中相邻的元素值依次比较，把大的值放后面的元素中，数组循环一圈后，则把最大元素值互换到了最后一个元素中。数组再循环一圈后，把第二大的元素值互换到了倒数第二个元素中。按照这种方式，数组循环多圈以后，就完成了数组元素的排序。这种排序方式我们称为冒泡排序。

解题步骤：
1、使用for循环（外层循环），指定数组要循环的圈数（通过图解可知，数组循环的圈数为数组长度 - 1）
2、在每一圈中，通过for循环（内层循环）完成相邻的元素值依次比较，把大的值放后面的元素中
3、每圈内层循环的次数，由第几圈循环来决定。如上图所示
a) 进行第一圈元素比较时，内层循环次数为数组长度 - 1
b) 进行第二圈元素比较时，内层循环次数为数组长度 - 2
c) 依次类推，得出结论：进行第n圈元素比较时，内层循环次数为数组长度 - n

具体代码

System.out.println("start:" + System.currentTimeMillis()); 
                                                           
int[] sortArray = {100,98,140,34,25,120,130};              
                                                           
/*                                                         
*冒泡排序      072-079                                         
*/                                                         
for (int i  = 0;i< sortArray.length-1;i++){                
    for (int j = 0;j < sortArray.length-i-1  ;j++){        
        if (sortArray[j+1] > sortArray[j]){                
            int temp = sortArray[j+1];                     
           sortArray[j+1] = sortArray[j];                  
           sortArray[j]  = temp;                           
        }                                                  
    }                                                      
}

4、二分查找

分析图：

通过观察发现，本题目要实现查找指定数值在元素有序的数组中存储的位置（索引），返回该位置（索引）。
1、我们使用数组最中间位置的元素值与要查找的指定数值进行比较，若相等，返回中间元素值的索引
2、最中间位置的元素值与要查找的指定数值进行比较，若不相等，则根据比较的结果，缩小查询范围为上次数组查询范围的一半；
再根据新的查询范围，更新最中间元素位置，然后使用中间元素值与要查找的指定数值进行比较
A、比较结果相等，返回中间元素值的索引
B、比较结果不相等，继续缩小查询范围为上次数组查询范围的一半，更新最中间元素位置，继续比较，依次类推。
3、当查询范围缩小到小于0个元素时，则指定数值没有查询到，返回索引值-1。
解题步骤：
1、定义3个用来记录索引值的变量，变量min记录当前范围最小索引值，初始值为0；变量max记录当前范围最大索引值，初始值为数组长度-1；变量mid记录当前当前范围最中间元素的索引值，初始值为(min+max) / 2
2、使用循环，判断当前范围下，最中间元素值与指定查找的数值是否相若相等，结束循环，返回当前范围最中间元素的索引值mid。若不相等，根据比较结果，缩小查询范围为上一次查询范围的一般。中间元素值比要查询的数值大，说明要查询的数值在当前范围的最小索引位置与中间索引位置之间，此时，更新查询范围为:
范围最大索引值 = 上一次中间索引位置 -1；中间元素值比要查询的数值小，说明要查询的数值在当前范围的最大索引位置与中间索引位置之间，此时，更新查询范围为:范围最小索引值 =上一次中间索引位置+1；在新的查询范围中，更新中间元素值的位置，再次使用最中间元素值与指定查找的数值是否相等。中间索引值 = (范围最小索引值 +范围最大索引值) / 2;
3、每次查询范围缩小一半后，使用if语句判断，查询范围是否小于0个元素，若小于0个元素，则说明指定数值没有查询到，返回索引值-1。

具体代码实现：

public static int halfSearch(int[] arr, int number) {
	//定义3个变量，用来记录min, max, mid的位置
	int min = 0;
	int max = arr.length-1;
	int mid = 0;
		while (min <= max) {
           mid = (min+max)/2;
		//没找了， 更新范围，继续比较
		//更新范围
		if (arr[mid] > number) {
			//在左边
			max = mid-1;
		} else if(arr[i] < number){
			//在右边
			min = mid+1;
		}
		else{
              return mid ;
          }
	 
	return -1;
}

5、几种算法的代码

package com.smartdot.Basics;

public class MainBasics {




    public static  void main(String[] args){

        int[] arrayS = {19,8,7,89,80,97,96,34,35,32,31,2,64,3,22,343,422};
        quickSort(0,arrayS.length-1,arrayS);
        for (int num : arrayS){
            System.out.print(num + "   ");
        }
        System.out.println(find(31,arrayS));


    }
    //冒泡排序
    public static void bubblingSort(int[] arrays){

        for (int i  = 0;i < arrays.length-1;i++){
            for (int j = 0;j<arrays.length- 1 - i;j++){
                if (arrays[j] > arrays[j+1]){
                    arrays[j] = arrays[j]^arrays[j+1];
                    arrays[j+1] = arrays[j]^arrays[j+1];
                    arrays[j] = arrays[j]^arrays[j+1];
                }
            }
        }

    }
    //选择排序
    public  static  void selectSort(int[] arrays){
        for (int i = 0;i < arrays.length -1;i++){
            for (int j = i+1;j <arrays.length;j++){

                if (arrays[j] > arrays[i]){
                    arrays[j] = arrays[j]^arrays[i];
                    arrays[i] = arrays[j]^arrays[i];
                    arrays[j] = arrays[j]^arrays[i];
                }
            }
        }
    }
    //快速排序
    public static  void quickSort(int beginIndex,int endIndex,int[] arrays){


        if (beginIndex >= endIndex){
            return;
        }

        int i = beginIndex;

        int j = endIndex;

        int orValue = arrays[beginIndex];

        while(i < j){
            while (j > i){
                if (arrays[j] > orValue){
                    break;
                }
                else {
                    j--;
                }
            }
            while (j > i){
                if (arrays[i] < orValue){
                    break;
                }
                else {
                    i++;
                }
            }
            if (j>i){
               int tempValue  =  arrays[i];
               arrays[i] = arrays[j];
               arrays[j] = tempValue;
            }
            else {
                break;
            }

        }
        arrays[beginIndex] = arrays[i];
        arrays[i] = orValue;
        quickSort(beginIndex,i -1,arrays);
        quickSort(i+1,endIndex,arrays);

    }
    //二分查找
    public static  int  find(int findNum,int[]  arrays){
        //快速排序
        quickSort(0,arrays.length -1,arrays);

        int start = 0;
        int end = arrays.length-1;

        int middle = (start + end)/2;
        int tth = -1;
        while (start <=end){
            if (arrays[middle] > findNum){
                start = middle;
                middle = (middle + end)/2;
            }
            else if (arrays[middle] < findNum){
                end = middle;
                middle = (start+end)/2;
            }
            else{
                tth = middle;
                break;
            }
        }
        return  middle;
    }





}

「已注销」

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
数组的一些简单算法

目录1、数组的逆序2、选择排序3、冒泡排序4、二分查找5、几种算法的代码1、数组的逆序将数组进行逆序：题目分析：通过观察发现，本题目要实现原数组元素倒序存放操作。即原数组存储元素为{11,22,33,44}，逆序后为原数组存储元素变为{44,33,22,11}。1、通过图解发现，想完成数组元素逆序，其实就是把数组中索引为start与end的元素进行互换。...
复制链接

扫一扫