选择、冒泡排序,二分查找法以及一些for循环的灵活运用

import java.util.Arrays;//冒泡排序
public class Test {

    public static void main(String[] args) {
        int[] array = { 31, 22, 15, 77, 52, 32, 18, 25, 16, 7 };
        // 冒泡 --> 两两比较  -->  提取出最大的数  在最后一位       //拿第一位和它后面的一位进行 两两比较        System.out.println(Arrays.toString(array));
        for (int j = 0; j < array.length; j++) {
            for (int i = 0; i < array.length - 1 - j; i++) {
                // 如果前面的数大于后面的数 交换位置
                if (array[i] < array[i + 1]) {
                    int temp = array[i];
                    array[i] = array[i + 1];
                    array[i + 1] = temp;
                }
            }
        }
        System.out.println(Arrays.toString(array));
    }
}
import java.util.Arrays;
//选择排序
public class Test {

    public static void main(String[] args) {
        int[] array = { 31, 22, 15, 77, 52, 32, 18, 25, 16, 7 };
        // 选择 --> 第一位与后面所有的数字进行比较
        System.out.println(Arrays.toString(array));
        for (int i = 0; i < array.length; i++) {
            for (int j = i + 1; j < array.length; j++) {
                if (array[i] < array[j]) {
                    // 如果 array[0]比array[1]大,交换位置
                    // 第三方变量temp
                    int temp = array[i];
                    array[i] = array[j];
                    array[j] = temp;
                }
            }
        }
        System.out.println(Arrays.toString(array));
    }
}
import java.util.Arrays;
import java.util.Scanner;

//  二分查找  折半查找法    从中间斩断,比较值。继续比较
public class Test11 {

    public static void main(String[] args) {
        // 二分查找法 插入排序
        int[] array = { 3, 10, 15, 22, 33, 51, 77, 88 };
        System.out.println(Arrays.toString(array));
        Scanner input = new Scanner(System.in);
        do {

            System.out.print("输入需要插入的数据:");
            int number = input.nextInt();       // 每次获取最左边的数和最右边的数
            int left = 0;
            int right = array.length - 1;
            int result = recursion(array, left, right, number);
            System.out.println(result);
            int[] newArray = new int[array.length + 1];
            for (int i = 0; i < newArray.length; i++) {
                if (i < result) {
                    newArray[i] = array[i];
                } else if (i == result) {
                    newArray[i] = number;
                } else {
                    newArray[i] = array[i - 1];
                }
            }
            array = newArray;
            System.out.println(Arrays.toString(array));
        } while (true);
    }

        //递归
    public static int recursion(int[] array, int left, int right, int number) {
        // 如果大于右边,或者小于左边
        if (array[0] > number)
            return 0;
        else if (array[array.length - 1] < number)
            return array.length;
      
        int center = (left + right) / 2;
        if (left == right - 1)
            return right;
        if (array[center] > number) {
            return recursion(array, left, center, number);
        } else {
            return recursion(array, center, right, number);
        }
    }

}
//for循环打印矩形
public class Rect {

    public void show(int width, int height) {

        for (int i = 0; i < width; i++) {
            for (int j = 0; j < height; j++) {
                if (i == 0 || j == 0 || i == width - 1 || j == height - 1)
                    System.out.print("*");
                else
                    System.out.print(" ");
            }
            System.out.println();
        }
    }
}
//for循环打印菱形
public class Rhombus {

    public void show(int height) {
        int half = height / 2;
        for (int i = 1; i <= half; i++) {
            // 先打空格
            for (int j = half - i + 1; j > 0; j--) {
                System.out.print(" ");
            }
            for (int j = 0; j < 2 * i - 1; j++) {
                System.out.print("*");
            }
            System.out.println();
        }

        for (int i = 0; i < 2 * half + 1; i++) {
            System.out.print("*");
        }
        System.out.println();

        for (int i = 1; i <= half; i++) {
            // 先打空格
            for (int j = i; j > 0; j--) {
                System.out.print(" ");
            }
            for (int j = 0; j < 2 * (half - i) + 1; j++) {
                System.out.print("*");
            }
            System.out.println();
        }
    }

}
//for循环打印等腰三角形
public class Isosceles {

    public void show(int height) {
        for (int i = 1; i <= height; i++) {
            // 先打空格
            for (int j = height - i; j > 0; j--) {
                System.out.print(" ");
            }
            for (int j = 0; j < 2 * i - 1; j++) {
                System.out.print("*");
            }
            System.out.println();
        }
    }
}
//for循环打印之间三角形
public class Triangle {

    public void show(String str, int height) {
        for (int i = 0; i < height; i++) {
            for (int j = 0; j < i + 1; j++) {
                System.out.print(str);
            }
            System.out.println();
        }
    }

}
时间: 2024-10-12 20:57:13

选择、冒泡排序,二分查找法以及一些for循环的灵活运用的相关文章

【基础算法】冒泡排序+二分查找法

1.思考题 (1)有12颗球,1颗是9克,其余的都是10克,怎样在天平上称三次找出9克的那颗质量小的球? 答:第一次:把12颗球分成两半,一半6颗,在天平上称,取质量小的一边: 第二次:把6颗球分成两半,一半三颗,也取质量小的一边: 第三次:取三颗球中任一两颗去称,如果质量相等,那么没有称的那一颗就是质量最小的一颗(9克),如果两颗质量不想等,取质量小的一颗也可以取到. (2)有1024个人,有一个人血液有病毒,而999个人没有病毒,化验一个人的血液需要10分钟,怎么用最短的时间找出有血液病毒的

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.o

冒泡排序法与二分查找法

冒泡排序(Bubble Sort) 是一种计算机科学领域的较简单的排序算法. 它重复地走访过要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来.走访数列的工作是重复地进行直到没有再需要交换,也就是说该数列已经排序完成. 这个算法的名字由来是因为越大的元素会经由交换慢慢“浮”到数列的顶端,故名. 算法原理 冒泡排序算法的运作如下:(从后往前) 比较相邻的元素.如果第一个比第二个大,就交换他们两个. 对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对.在这一点,最后的元素应该

冒泡排序、二分查找法

冒泡排序的基本思想是对比相邻的元素值,如果满足条件就交换元素值,把较小的元素移动到数组前面,把大的元素移动到数组后面(也就是交换两个元素的位置),这样数组元素就像气泡一样从底部上升到顶部. 1 package com.hanqi; 2 3 public class maopao { 4 5 public static void main(String[] args) { 6 int[]array=new int[]{63,4,24,1,3,13}; 7 System.out.println("冒

二分查找法 冒泡排序法

二分查找又称折半查找,优点是比较次数少,查找速度快,平均性能好; 其缺点是要求待查表为有序表,且插入删除困难.因此,折半查找方法适用于不经常变动而查找频繁的有序列表. 首先,假设表中元素是按升序排列,将表中间位置记录的关键字与查找关键字比较,如果两者相等,则查找成功; 否则利用中间位置记录将表分成前.后两个子表,如果中间位置记录的关键字大于查找关键字,则进一步查找前一子表,否则进一步查找后一子表. 重复以上过程,直到找到满足条件的记录,使查找成功,或直到子表不存在为止,此时查找不成功. 二分查找

利用选择排序排序数组,用二分查找法查找

#include <stdio.h> #include <iostream> using namespace std; int main() { int a[] ={1,8,45,12,75,466,25,65,14,56,53}; int t; int length; length =sizeof(a)/sizeof(a[0]); for(int i=0;i<length;i++) { for(int j=i+1;j<length;j++) { if(a[i]>

C语言数组之冒泡排序+折半查找法(二分查找)

冒泡排序算法 1 int num[5]; 2 int i; 3 //循环接收用户输入的元素 4 for(i=0;i<5;i++){ 5 printf("请输入第%d个元素\n",i+1); 6 scanf("%d",&num[i]); 7 } 8 for(i=0;i<4;i++){ //外层循环,控制排序的轮数 9 int j; 10 for(j=0;j<4-i;j++){ //内层循环,控制冒牌排序每轮的次数 11 if(num[j]&g

冒泡排序,递归二分查找法,二分查找法

#冒泡排序list1=[2,4,5,6,7,8,9,11,30,35,38,41,42] def bubble_sort(list): for i in range(len(list)-1): for j in range(len(list)-1-i): if list[j]>list[j+1]: list[j],list[j+1]=list[j+1],list[j] print(list) list1=[2,4,55,6,78,38,95,11,30,35,38,41,42] bubble_s

二分查找法

今年是大年初四,晚上闲的没事儿干,在手机上随手写了二分查找法,对有序数组或者循环有序数组都挺管用! public int binarySearch(int []nums,int key){ return binarySearch(nums,key,0,nums.length); } public int binarySearch(int []nums,int key,int left,int right){ int mid = (left + right) / 2; if(left <= rig