Java冒泡，快速，插入，选择排序^

这段时间在学Java，期间学到了一些排序和查找方法。特此写来和大家交流，也方便自己的日后查看与复习。

1.下边是Java的主类：

public class Get
{public static void main(String[] args){    int len=10;int[] a=new int[len];for(int i=0;i<len;i++){int t=(int)(Math.random()*10);a[i]=t;}//静态初始化数组//int[] b=new int[]{1,2};
//        动态初始化数组：由下面看出动态初始化就是只指定数组的长度，由系统为数组分配初始值。int[] b=new int[10];//        int a[]={2,45,34,1,3,6,5,67,867,76};
//        int a[]={4,2,45,34,1,3,6,5,67,867,76};Insert is=new Insert();is.sort(a);
//        Bubble bub=new Bubble();
//        bub.bubblesort(a);Select sl=new Select();sl.sort(a);
//        Quick qc=new Quick();
//        qc.sort(a, 0, a.length-1);for(int i=0;i<a.length;i++){b[i]=a[i];System.out.print(b[i]+"  ");}BinaryFind bf=new BinaryFind();/*System.out.println("Hello World!");Fun f=new Fun(23,"李四");System.out.println("我的名字叫"+f.name);System.out.println("我的年龄为"+f.age);*/}
}

其中，以下代码将定义一个数组，并且将产生一组随机数，存放在数组a[]中：

int len=10;int[] a=new int[len];for(int i=0;i<len;i++){int t=(int)(Math.random()*10);a[i]=t;}

数组的初始化方式有静态和动态俩种，不能够混合使用，如

int[] b=new int[2]{1,2};将会报一个经典的错误。

2.二分算法查找。

二分算法的主要思想是：递归。一次没找到，将会不停的调用该函数，直到不满足条件或者找到该函数为止。

代码如下：

//二分算法！！！
class BinaryFind
{public void find(int left,int right,int a[],int val){//找到中间的数midValint midIndex=(left+right)/2;int midVal=a[midIndex];if(left<=right){       //当左边小于右边时执行以下操作：if(midVal>val){//递归调用find(left,midIndex-1,a,val);}else if(midVal<val){find(midIndex+1,right,a,val);}else{System.out.println("已经找到该数,下标为："+midIndex);}}else{System.out.println("找不到该数");}}
}

3.插入排序

插入排序的基本操作就是将一个数据插入到已经排好序的有序数据中，从而得到一个新的、个数加一的有序数据，算法适用于少量数据的排序，时间复杂度为O(n^2)

//插入排序！！！
class Insert
{public void sort(int a[]){for(int i=1;i<a.length;i++){int insertVal=a[i];//将insertVal与前一个数比较int index=i-1;while(index>=0&&insertVal<a[index]){//将a[index]向后移动a[index+1]=a[index];//让index向前移动index--;}//否则将insertVal插入到适当位置a[index+1]=insertVal;}}
}

谨记如果此判断条件index>=0的等号忘记加，则，数组中的第一个元素将不会参与排序！！！

while(index>=0&&insertVal<a[index])

4.快速排序！！！
//* 快速排序。
//* 思想：选定一个元素作为枢纽元素，将小于该元素的元素放到左边，大于该元素的放到右边。不断重复此过程。
//* 直到最终形成一个有序的列表。
//* 下面的参数low,high就是可以支持一个数组的一个子区间进行排序。
//* 如果是整个数组进行排序，则low=0,high=数组.length-1。
//* @param data:要排序的数组。
//* @param low:排序的起始位置
//* @param high:排序的结束位置。

class Quick
{public void sort(int a[], int low, int high){int i=low;int j=high;int key=a[low];if (low < high) {// 枢纽元素System.out.println("枢纽元素是：" + key + ",low:" + low + ",high:" + high);while(i<j){while(i<j&&key<=a[j])    {j--;}a[i]=a[j];
//            int temp=a[j];这三行可以与前面一行互换，实现的功能相同。
//            a[j]=a[i];
//            a[i]=temp;</span>while(i<j&&key>=a[i]){i++;}a[j]=a[i];
//下面标红三行与上面一行功能相同
//            int temp1=a[j];//            a[j]=a[i];
//            a[i]=temp1;</span>a[i]=key; } sort(a,low,i-1);sort(a,i+1,high);}}}

快速排序值得注意的地方为，在主函数中调用方法要注意数组越界的问题。

即 Quick qc=new Quick(); qc.sort(a, 0, a.length-1);在传递实参的时候是a.length-1而不是a.length

5.选择排序

选择排序（Selection sort）是一种简单直观的排序算法。它的工作原理是每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。

//选择排序！！！
class Select
{    int temp;public void sort(int a[]){for(int i=0;i<a.length-1;i++){for(intj=i+1;j<a.length;j++){将俩个元素进行比较if(a[i]>a[j]){temp=a[j];a[j]=a[i];a[i]=temp;}}}        }
}

6.冒泡排序

冒泡排序重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。

//冒泡排序！！！
class Bubble
{    int temp;public void bubblesort(int a[]){    for(int i=0;i<a.length-1;i++){    for(int j=0;j<a.length-1-i;j++){  //a.length-1-i是因为最后的i个元素已经有序。if (a[j]>a[j+1]){temp=a[j];a[j]=a[j+1];a[j+1]=temp;}}}}
}

7.二维数组
这是自己先前用来练手的二维数组的使用方法，一起来看看吧。

//将一个矩阵倒置输出！！！
class Array
{//int num[][];int  num[][]={{1,2,3},{4,5,6},{7,8,9}};public  void get(){System.out.println("原数组为：");for(int i=0;i<=2;i++){for(int j=0;j<=2;j++){System.out.print(num[i][j]+"\t");}System.out.println("\n");}System.out.println("倒置后的数组为：");for(int i=0;i<=2;i++){for(int j=0;j<=2;j++){System.out.print(num[j][i]+"\t");}System.out.println("\n");}}}

8.99乘法表
先前学习的俩层循环，99乘法表 ^_^

//输出99乘法表！！！
class Table
{public static void get(){for(int i=1;i<=9;i++){for(int j=1;j<=i;j++){System.out.print(i+"*"+j+"="+i*j+"\t");}System.out.print("\n");}}
}

Java冒泡，快速，插入，选择排序^_^+二分算法查找相关推荐

c++Cocktail Selection Sort鸡尾酒选择排序的实现算法(附完整源码)
C++Cocktail Selection Sort鸡尾酒选择排序的实现算法 C++Cocktail Selection Sort鸡尾酒选择排序的实现算法完整源码(定义,实现,main函数测试) C+ ...
c++Selection Sort选择排序的实现算法(附完整源码)
C++Selection Sort选择排序的实现算法 C++Selection Sort选择排序的实现算法完整源码(定义,实现,main函数测试) C++Selection Sort选择排序的实现算法 ...
C语言选择排序Selection sort算法(附完整源码)
选择排序Selection sort算法选择排序Selection sort算法的完整源码(定义,实现,main函数测试) 选择排序Selection sort算法的完整源码(定义,实现,main函 ...
php冒泡插入选择排序,说说PHP数组的三种排序(冒泡/选择/插入)方法
说说PHP数组的三种排序(冒泡/选择/插入)方法 PHP #数组 #排序 #冒泡 #选择 #插入2012-05-30 10:17 一.冒泡排序法说明:找到最大的数,排列到最后面,然后继续找例: $ ...
使用java实现冒泡排序和选择排序
冒泡排序原理假设有10个数,第一轮循环,第一个数和第二个数比较,如果第一个数大,第一个数和第二个数交换位置,否则不动:接着第二个数和第三个数比较,如果第二个数大,第二个数和第三个数交换位置,否则不动 ...
选择排序java代码_JAVA简单选择排序算法原理及实现
简单选择排序:(选出最小值,放在第一位,然后第一位向后推移,如此循环)第一位与后面每一个逐个比较,每次都使最小的置顶,第一位向后推进(即刚选定的第一位是最小值,不再参与比较,比较次数减1) 复杂度: ...
Python快速实现选择排序
选择排序是一种简单直观的排序算法,它的时间复杂度是O(n²),不占用额外的空间,适合于数少时的排序图片来源:选择排序 - Bing images def select_sort(li):# rang ...
Java实现冒泡排序和选择排序
冒泡排序:依次比较两个相邻的元素,如果他们的顺序(如从大到小.首字母从A到Z)错误就把他们交换过来.走访元素的工作是重复地进行直到没有相邻元素需要交换,也就是说该元素已经排序完成. 冒牌排序是稳定排序 ...
冒泡排序,插入排序,选择排序三种算法的优劣
https://www.jianshu.com/p/9f724c880124 最近听了王争老师的数据结构与算法之美,大有获益,特写此博客与大家分享. 排序算法太多了,但大体可以归结于三类,冒泡排序,插 ...

Java冒泡，快速，插入，选择排序^_^+二分算法查找

Java冒泡，快速，插入，选择排序^_^+二分算法查找相关推荐

最新文章

热门文章