Java学习 (七)、数组,查找算法,二分查找法,冒泡排序,选择排序,插入排序

一、常用数组查找算法

工作原理:它又称为顺序查找,在一列给定的值中进行搜索,从一端的开始逐一检查每个元素,知道找到所需元素的过程。

例1:查找指定的数在数组中出现的位置,找到返回下标,找不到返回-1

 1 import java.util.Scanner;
 2 public class LinearSearch{
 3     public static void main(String []argas)
 4     {
 5         int [] array={10,100,90,65,80,92};
 6         System.out.println("请输入要获取的数");
 7         Scanner input=new Scanner(System.in);
 8         int number=input.nextInt();
 9         int index=-1;//找到数组中所在数的下标,找不到等于-1
10         for(int i=0;i<array.length;i++)
11         {
12             if(array[i]==number)
13             {
14                 index=i+1;
15                 break;
16             }
17         }
18         if(index!=-1)
19         {
20             System.out.println("找到该数字,在数组中的第"+index+"位置");
21         }
22         else
23         {
24             System.out.println("要查找的数字不存在");
25         }
26     }
27 }

例2:求数组中的最大值,最小值

 1 public class LinearSearch{
 2     public static void main(String []argas)
 3     {
 4         int [] array={10,100,90,65,80,92};
 5         //求数组中的最大值,最小值
 6         int max=array[0];//最大值
 7         int min=array[0];//最小值
 8         for(int i=1;i<array.length;i++)
 9         {
10             if(max<array[i])
11             {
12                 max=array[i];
13             }
14             if(min>array[i])
15             {
16                 min=array[i];
17             }
18         }
19         System.out.println("该数组的最大值为"+max+",最小值为"+min);
20     }
21 }

二、二分查找法

工作原理:它又称为折半查找法,将数组中间位置记录的关键字与查找关键字比较,如果两者相等,则查找成功;否则利用中间位置记录将数组分成前、后两个子数组,如果中间位置记录的关键字大于查找关键字,则进一步查找前一子数组,否则进一步查找后一子数组。重复以上过程,直到找到或找不到为止。

注:针对有序数组

 1 import java.util.Scanner;
 2 public class LinearSearch{
 3     public static void main(String []argas)
 4     {
 5         int[] array2={1,2,3,4,5,10,15,18,19,22};
 6         System.out.println("请输入要获取的数");
 7         Scanner input=new Scanner(System.in);
 8         int number=input.nextInt();
 9         int index=-1;//找到数组中所在数的下标,找不到等于-1
10         int start=0;//起始下标
11         int end=array2.length-1;//终止下标
12         int middle;
13         while(start<=end)
14         {
15             //找到中间下标所对应的元素值
16             middle=(start+end)/2;
17             int number2=array2[middle];
18             //假如要查找的那个数大于中间比较的那个数
19             //去掉左边的数
20             if(number>number2)
21             {
22                 start=middle+1;
23             }
24             //保留左边的数,去掉右边的数
25             else if(number<number2)
26             {
27                 end=middle-1;
28             }
29             else
30             {
31                 index=middle+1;
32                 break;
33             }
34         }
35         if(index!=-1)
36         {
37             System.out.println("找到该数字,在数组中的第"+index+"位置");
38         }
39         else
40         {
41             System.out.println("要查找的数字不存在");
42         }
43
44     }
45 }

三、冒泡排序法

工作原理:比较相邻的元素,如果第一个比第二个大,就交换它们两个。对每一对相邻元素做同样的工作,从开始第一对到结尾的最后一对。最后的元素应该会是最大的数。针对除了最后一个元素以外所有的元素重复以上的步骤。直到没有任何一对数字需要比较。

 1 public class BubbleSort{
 2     public static void main(String []argas)
 3     {
 4         int[] array={80,53,12,90,35,22,65,45,82,33};
 5         //N个数比较的轮数为N-1次
 6         for(int i=0;i<array.length-1;i++)
 7         {
 8             //每一轮比较的次数为N-1-i次
 9             for(int j=0;j<array.length-i-1;j++)
10             {
11                 //比较相邻的2个数,小靠前
12                 if(array[j]>array[j+1])
13                 {
14                     //两个数做交换,通过设置临时变量
15                     int temp=array[j];
16                     array[j]=array[j+1];
17                     array[j+1]=temp;
18                 }
19             }
20         }
21         //把排好序的数组输出
22         for(int i=0;i<array.length;i++)
23         {
24             System.out.print(array[i]+",");
25         }
26     }
27 }

四、选择排序法

工作原理:首先在未排序序列中找到最小元素,存放到排序序列的起始位置,然后,再从剩余未排序元素中继续寻找最小元素,然后放到排序序列末尾。以此类推,直到所有元素均排序完毕。

 1 public class SelectSort{
 2     public static void main(String []argas)
 3     {
 4         int[] array={80,53,12,90,35,22,65,45,82,33};
 5         int min=0;//保存最小元素值的下标
 6         //N个数比较的轮数为N-1次
 7         for(int i=0;i<array.length-1;i++)
 8         {
 9             min=i;
10             //查找最小数在数组中的下标
11             for(int j=i+1;j<array.length;j++)
12             {
13                 if(array[min]>array[j])
14                 {
15                     min=j;//保存最小数的下标
16                 }
17             }
18             //如果第i个数位置不在i上,则进行交换
19             if(i!=min)
20             {
21                 int temp=array[i];
22                 array[i]=array[min];
23                 array[min]=temp;
24             }
25         }
26
27         for(int i=0;i<array.length;i++)
28         {
29             System.out.print(array[i]+",");
30         }
31     }
32 }

五、插入排序法

工作原理:它是通过构建有序序列,对于为排序数据,在已排序序列中从后向前扫描,找到相应位置并插入。从后向前扫描过程中,需要反复把已排序元素逐步向后挪位,为最新元素提供插入空间。

 1 public class InsertSort{
 2     public static void main(String []argas)
 3     {
 4         int[] array={80,53,12,90,35,22,65,45,82,33};
 5         for(int i=1;i<array.length;i++)
 6         {
 7             int temp=array[i];
 8             //把下标保存起来
 9             int j=i;
10             while(j>0&&temp<array[j-1])
11             {
12                 //上面的数覆盖其下面的数
13                 array[j]=array[j-1];
14                 j--;
15             }
16             array[j]=temp;//插入数据
17         }
18
19         for(int i=0;i<array.length;i++)
20         {
21             System.out.print(array[i]+",");
22         }
23     }
24 }

时间: 2024-10-05 11:33:09

Java学习 (七)、数组,查找算法,二分查找法,冒泡排序,选择排序,插入排序的相关文章

查找算法-二分查找

查找算法-二分查找 标题 二分查找也称折半查找(Binary Search),它是一种效率较高的查找方法.但是,折半查找要求线性表必须采用顺序存储结构,而且表中元素按关键字有序排列. 过程 首先,假设表中元素是按升序排列,将表中间位置记录的关键字与查找关键字比较,如果两者相等,则查找成功:否则利用中间位置记录将表分成前.后两个子表,如果中间位置记录的关键字大于查找关键字,则进一步查找前一子表,否则进一步查找后一子表.重复以上过程,直到找到满足条件的记录,使查找成功,或直到子表不存在为止,此时查找

查找算法——二分查找

1.算法介绍 (1)序列必须是有序的 (2)取序列的中间元素与查找值比较,相等返回元素下标 (3)根据序列升序或降序,中间元素小于或大于查找值的具体情况,选择中间元素右边或左边的序列重复步骤(2)(3), 未找到返回-1. 2.代码实现 2.1.golang package main import ( "fmt" ) func main() { slice := []int{1, 2, 3, 4, 5, 6} //升序序列 key := 4 index := SearchBinary(

算法 排序lowB三人组 冒泡排序 选择排序 插入排序

参考博客:基于python的七种经典排序算法   [经典排序算法][集锦]     经典排序算法及python实现 首先明确,算法的实质 是 列表排序.具体就是操作的列表,将无序列表变成有序列表! 一.排序的基本概念和分类 所谓排序,就是使一串记录,按照其中的某个或某些关键字的大小,递增或递减的排列起来的操作.排序算法,就是如何使得记录按照要求排列的方法. 排序的稳定性: 经过某种排序后,如果两个记录序号同等,且两者在原无序记录中的先后秩序依然保持不变,则称所使用的排序方法是稳定的,反之是不稳定

简单排序算法 冒泡排序 选择排序 插入排序

冒泡排序: 总体思路:对未排序的各个元素,依次比较两个元素,如果这两个元素为逆序(与想要的顺序相反),则交换这两个元素. 这样可以有两种排序的思路: 思路一: 固定位置排序:比如有一个未排序队列,下标依次为0,1,2,.....N-1, 第一轮排序:首先固定位置0,将下标为0的元素依次和下标为1.下标为2.....下标为N-1的元素相比较,若相比较的两个元素为逆序,则交换这两个元素,这样第一轮排序完之后,位置为0的元素,就是最大的(最小的). 第二轮排序:首先固定位置1,将下标为1的元素依次和下

算法_基本排序算法之冒泡排序,选择排序,插入排序和希尔排序

排序的元素实现了Comparable接口,以达到对于通用性. 最基础的排序是冒泡排序,下面是其思路: 比较相邻的元素.如果第一个比第二个大,就交换他们两个. 对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对.在这一点,最后的元素应该会是最大的数. 针对所有的元素重复以上的步骤,除了最后一个. 持续每次对越来越少的元素重复上面的步骤,直到没有任何一对数字需要比较. 下面是其实现代码: public class Maopao { public void sort(Comparable[]

过三关 Java冒泡排序选择排序插入排序小练习

材料:猴子排序,按照身高来从小到大来排序. 第一关: 老猴子带领小猴子队伍按大小逐一比较,交换,开始高矮排列队伍.(冒泡排序) 第二关: 太慢了,给第一关增加难度,进行选择排序 第三关: 最后,尝试选择用插入排序法,来进行排序. 测试类: import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; //功能:猴子排序 public class MonkeySelect {

基本排序算法(冒泡排序 选择排序 插入排序 快速排序 归并排序 基数排序 希尔排序)

冒泡排序 public static void bubbleSort(int[] arr){ int lgn = arr.length; for (int i = 0; i < lgn - 1; i++) { for (int j = 0; j < lgn - 1 - i; j++) { if(arr[j] > arr[j + 1]){ int temp = arr[j + 1]; arr[j + 1] = arr[j]; arr[j] = temp; } } } } 选择排序 publ

算法 查找算法--二分查找

二分査找也称折半査找,其优点是查找速度快,缺点是要求所要査找的数据必须是有序序列.该算法的基本思想是将所要査找的序列的中间位置的数据与所要査找的元素进行比较,如果相等,则表示査找成功,否则将以该位置为基准将所要査找的序列分为左右两部分.接下来根据所要査找序列的升降序规律及中间元素与所查找元素的大小关系,来选择所要査找元素可能存在的那部分序列,对其采用同样的方法进行査找,直至能够确定所要查找的元素是否存在,具体的使用方法可通过下面的代码具体了解. 1 #include <stdio.h> 2 b

冒泡排序 选择排序 插入排序 java

双向冒泡 1 package com.huang; 2 3 public class _014_bubb_sort { 4 5 int[] b={1,2}; 6 static int a[]={12,4,35,65,43,63,2,6,9,544,43543}; 7 public static void main(String[] args) { 8 display(); 9 10 //冒泡 11 for(int i=0;i<a.length/2;i++) 12 { 13 for(int j=0

java数据结构学习(一)之二分查找

  二分查找法与我们在孩童时期玩过的猜数的游戏一样,这个游戏里一个朋友会让你猜他正想的一个1至100的数,当你猜了一个数后,他会告诉你三种选择的一个:你猜的比她想的大,或小,或猜中了.为了能用最少的次数猜中,必须从50开始猜,如果她说你猜的太小,则推出那个数在51-100之间,所以下一次猜75((51+100)/2),如果她说有些大,那你就会在51-74之间才,下一次猜(51+74)/2=62.直到猜中她所给的数. 下面给出我们猜1-100的数,key为33的过程: 只需7次就可以猜中答案.下面