二分排序java代码,二分排序js

Java的线性查找，二分查找，冒泡排序，插入排序，快速排序的源代码

C++的，只要把，函数名改下，输出语句改下，就可以了。希望对你有帮助

永年网站制作公司哪家好，找创新互联建站！从网页设计、网站建设、微信开发、APP开发、成都响应式网站建设公司等网站项目制作，到程序开发，运营维护。创新互联建站自2013年起到现在10年的时间，我们拥有了丰富的建站经验和运维经验，来保证我们的工作的顺利进行。专注于网站建设就选创新互联建站。

void Sort :: SelectionSort(int a[],int n)

{

bool sorted=false;

cout"中间过程为："endl;

for(int size=n;!sorted size1;size--){

int pos = 0;

sorted = true;

for(int i=1;isize;i++)

if(a[pos]=a[i])pos=i;

else sorted=false;

Swap(a[pos],a[size-1]);

for(int j=0;j!=n;j++){//显示中间过程

couta[j]" ";

}

coutendl;

}

cout"选择排序结果为："endl;

for(int i=0;i!=n;i++){

couta[i]" ";

}

coutendl;

}

/*

冒泡排序

*/

bool Sort :: Bubble(int a[],int m,int n)

{

bool swapped=false;

for(int i=0;im-1;i++){

if(a[i]a[i+1]){

Swap(a[i],a[i+1]);

swapped=true;

for(int j=0;j!=n;j++){//显示中间过程

couta[j]" ";

}

coutendl;

}

}

return swapped;

}

void Sort :: BubbleSort(int a[],int n)

{

cout"中间过程为："endl;

for(int i=n;i1 Bubble(a,i,n);i--);

coutendl;

cout"冒泡排序结果为："endl;

for(i=0;i!=n;i++){

couta[i]" ";

}

coutendl;

}

/*

插入排序

*/

void Sort :: InsertionSort(int a[],int n)

{

cout"中间过程为："endl;

for (int i=1;in;i++){

int t=a[i];

int j;

for (j=i-1;j=0 ta[j];j--){

a[j+1]=a[j];

}

a[j+1]=t;

for(int k=0;k!=n;k++){//显示中间过程

couta[k]" ";

}

coutendl;

}

cout"插入排序结果为："endl;

for(i=0;i!=n;i++){

couta[i]" ";

}

coutendl;

}

/*

基数排序

*/

void Sort :: RadixSort(int a[],int n)

{

int d=1;

int m=10;

for (int i=0;in;i++){

while(a[i]=m){

m*=10;

++d;

}

}

int *t=new int[n];

int *count=new int [10];

int radix=1,k;

for(i=1;i=d;i++){

for(int j=0;j10;j++){

count[j]=0;//每次分配前清空计数器

}

for(j=0;jn;j++){

k=(a[j]/radix)%10;//统计每个桶中的记录数

count[k]++;

}

cout"分桶显示："endl;

for(j=0;j10;j++){//显示中间xiangxi过程

if(count[j]!=0){

coutj": ";

for(int l=0;ln;l++){

if ((a[l]/radix)%10==j)

couta[l]" ";

}

coutendl;

}

}

coutendl;

for(j=1;j10;j++){

count[j]=count[j-1]+count[j];

}

for(j=n-1;j=0;j--){

k=(a[j]/radix)%10;

count[k]--;

t[count[k]]=a[j];

}

for(j = 0;j n;j++) {

a[j]=t[j];

}

radix=radix*10;

cout"按桶依次排序排序："endl;

for(j=0;j!=n;j++){//显示中间过程

couta[j]" ";

}

coutendl;

}

delete[] t;

delete[] count;

cout"基数排序结果为："endl;

for(i=0;i!=n;i++){

couta[i]" ";

}

coutendl;

}

急求java冒泡排序 快速排序 二分之一查找的代码

//标记法

public class Test {

public static void main(String[] args){

int[] array = {9,7,5,8,7,5,3,8,4,2,6,1,0};

for(int i = 0; iarray.length; i++){

int temp = i;

for(int j=i+1; jarray.length; j++){

if(array[temp]array[j]){

temp=j;

}

}

int buff = array[temp];

array[temp] = array[i];

array[i] = buff;

}

for(int a : array){

System.out.println(a);

}

}

}

//二分之一

public class Test {

public void find(int x){

int[] s = {1,2,3,6,7,8,9,12,13,14,15,16,17,18,19,20,23,25,27,30,32,40,50};

int start = 0;

int end = s.length;

int half = end/2;

while(true){

if(s[half]x){

start = half;

half = half + (end-start)/2;

}else if(s[half]x){

end = half;

half = half - (end-start)/2;

}else{

System.out.println(half+1);

break;

}

}

}

public static void main(String[] args){

new Test().find(20);

}

}

java二分法查找的递归算法怎么实现

什么是二分查找？

二分查找也称折半查找（Binary Search），它是一种效率较高的查找方法。但是，折半查找要求线性表必须采用顺序存储结构，而且表中元素按关键字有序排列。

二分查找优缺点

优点是比较次数少，查找速度快，平均性能好；

其缺点是要求待查表为有序表，且插入删除困难。

因此，折半查找方法适用于不经常变动而查找频繁的有序列表。

使用条件：查找序列是顺序结构，有序。

过程

首先，假设表中元素是按升序排列，将表中间位置记录的关键字与查找关键字比较，如果两者相等，则查找成功；否则利用中间位置记录将表分成前、后两个子表，如果中间位置记录的关键字大于查找关键字，则进一步查找前一子表，否则进一步查找后一子表。重复以上过程，直到找到满足条件的记录，使查找成功，或直到子表不存在为止，此时查找不成功。

利用循环的方式实现二分法查找

public class BinarySearch {

public static void main(String[] args) {

// 生成一个随机数组        int[] array = suiji();

// 对随机数组排序        Arrays.sort(array);

System.out.println("产生的随机数组为： " + Arrays.toString(array));

System.out.println("要进行查找的值： ");

Scanner input = new Scanner(System.in);

// 进行查找的目标值        int aim = input.nextInt();

// 使用二分法查找        int index = binarySearch(array, aim);

System.out.println("查找的值的索引位置： " + index);

}

/**     * 生成一个随机数组     *

* @return 返回值，返回一个随机数组     */

private static int[] suiji() {

// random.nextInt(n)+m  返回m到m+n-1之间的随机数        int n = new Random().nextInt(6) + 5;

int[] array = new int[n];

// 循环遍历为数组赋值        for (int i = 0; i array.length; i++) {

array[i] = new Random().nextInt(100);

}

return array;

}

/**     * 二分法查找  ---循环的方式实现     *

* @param array 要查找的数组     * @param aim 要查找的值     * @return 返回值，成功返回索引，失败返回-1     */

private static int binarySearch(int[] array, int aim) {

// 数组最小索引值        int left = 0;

// 数组最大索引值        int right = array.length - 1;

int mid;

while (left = right) {

mid = (left + right) / 2;

// 若查找数值比中间值小，则以整个查找范围的前半部分作为新的查找范围            if (aim array[mid]) {

right = mid - 1;

// 若查找数值比中间值大，则以整个查找范围的后半部分作为新的查找范围            } else if (aim array[mid]) {

left = mid + 1;

// 若查找数据与中间元素值正好相等，则放回中间元素值的索引            } else {

return mid;

}

}

return -1;

}}

运行结果演示：

由以上运行结果我们得知，如果要查找的数据在数组中存在，则输出该数据在数组中的索引；如果不存在则输出 -1 ，也就是打印 -1 则该数在数组中不存在，反之则存在。

四、利用递归的方式实现二分法查找

public class BinarySearch2 {

public static void main(String[] args) {

// 生成一个随机数组        int[] array = suiji();

// 对随机数组排序        Arrays.sort(array);

System.out.println("产生的随机数组为： " + Arrays.toString(array));

System.out.println("要进行查找的值： ");

Scanner input = new Scanner(System.in);

// 进行查找的目标值        int aim = input.nextInt();

// 使用二分法查找        int index = binarySearch(array, aim, 0, array.length - 1);

System.out.println("查找的值的索引位置： " + index);

}

/**     * 生成一个随机数组     *     * @return 返回值，返回一个随机数组     */

private static int[] suiji() {

// Random.nextInt(n)+m  返回m到m+n-1之间的随机数        int n = new Random().nextInt(6) + 5;

int[] array = new int[n];

// 循环遍历为数组赋值        for (int i = 0; i array.length; i++) {

array[i] = new Random().nextInt(100);

}

return array;

}

/**     * 二分法查找 ---递归的方式     *     * @param array 要查找的数组     * @param aim   要查找的值     * @param left  左边最小值     * @param right 右边最大值     * @return 返回值，成功返回索引，失败返回-1     */

private static int binarySearch(int[] array, int aim, int left, int right) {

if (aim array[left] || aim array[right]) {

return -1;

}

// 找中间值        int mid = (left + right) / 2;

if (array[mid] == aim) {

return mid;

} else if (array[mid] aim) {

//如果中间值大于要找的值则从左边一半继续递归            return binarySearch(array, aim, left, mid - 1);

} else {

//如果中间值小于要找的值则从右边一半继续递归            return binarySearch(array, aim, mid + 1, array.length-1);

}

}}

运行结果演示：

总结：

递归相较于循环，代码比较简洁，但是时间和空间消耗比较大，效率低。在实际的学习与工作中，根据情况选择使用。通常我们如果使用循环实现代码只要不是太繁琐都选择循环的方式实现~

用java写二分搜索，要求数组是由用户输入，再输入时，数组是无序的，要对数组进行从小到大的排序

二分查找又称折半查找，它是一种效率较高的查找方法。

【二分查找要求】：1.必须采用顺序存储结构 2.必须按关键字大小有序排列。

/**

* 二分查找又称折半查找，它是一种效率较高的查找方法。

【二分查找要求】：1.必须采用顺序存储结构 2.必须按关键字大小有序排列。

* @author Administrator

*

*/

public class BinarySearch {

public static void main(String[] args) {

int[] src = new int[] {1, 3, 5, 7, 8, 9};

System.out.println(binarySearch(src, 3));

System.out.println(binarySearch(src,3,0,src.length-1));

}

/**

* * 二分查找算法 * *

*

* @param srcArray

* 有序数组 *

* @param des

* 查找元素 *

* @return des的数组下标，没找到返回-1

*/

public static int binarySearch(int[] srcArray, int des){

int low = 0;

int high = srcArray.length-1;

while(low = high) {

int middle = (low + high)/2;

if(des == srcArray[middle]) {

return middle;

}else if(des srcArray[middle]) {

high = middle - 1;

}else {

low = middle + 1;

}

}

return -1;

}

/**

*二分查找特定整数在整型数组中的位置(递归)

*@paramdataset

*@paramdata

*@parambeginIndex

*@paramendIndex

*@returnindex

*/

public static int binarySearch(int[] dataset,int data,int beginIndex,int endIndex){

int midIndex = (beginIndex+endIndex)/2;

if(data dataset[beginIndex]||datadataset[endIndex]||beginIndexendIndex){

return -1;

}

if(data dataset[midIndex]){

return binarySearch(dataset,data,beginIndex,midIndex-1);

}else if(datadataset[midIndex]){

return binarySearch(dataset,data,midIndex+1,endIndex);

}else {

return midIndex;

}

}

}

java 二分排序疑问

原理，就是拆半，两边分别排序。再拆半、再分别找；…………

谁能帮忙写一个java的合并排序和二分查找的程序？

10万个数统计时间太短，我多写个循环给你吧

public class Testchazhao{

public static void main(String[] args){

int[] array = new int[100000];

int i = 0;

int j = 0;

int[] count = {0};

for(i = 0;i 100000;i++){

array[i] = (int)(Math.random()*100000000);

}

int test = (int)(Math.random()*100000);

long start = System.currentTimeMillis();

for(j = 0;j 100000;j++){

for(i = 0;i 100000;i++){

if(array[i] == test){

break;

}

}

}

long end = System.currentTimeMillis();

long time1 = end-start;

System.out.println(time1);

fen(array,0,100000);

start = System.currentTimeMillis();

for(j = 0;j 100000;j++){

erfen(array,0,99999,test,count);

}

end = System.currentTimeMillis();

long time2 = end - start;

System.out.println(time2);

}

public static void fen(int[] array,int p,int r){

if(p r){

int q = (p+r)/2;

fen(array,p,q);

fen(array,q+1,r);

he(array,p,q,r);

}

}

public static void he(int[] array,int p,int q,int r){

int i = 0;

int j = 0;

int k = 0;

int lenthleft = q-p;

int lenthright = r-q;

int[] arrayleft = new int[lenthleft+1];

int[] arrayright = new int[lenthright+1];

for(i = 0;i lenthleft;i++){

arrayleft[i] = array[p+i];

}

for(j = 0;j lenthright;j++){

arrayright[j] = array[q+j];

}

arrayleft[lenthleft] = arrayright[lenthright] = 2000000000;

i = j = 0;

for(k = p;k r;k++){

if(arrayleft[i] = arrayright[j]){

array[k] = arrayleft[i];

i++;

}

else{

array[k] = arrayright[j];

j++;

}

}

}

public static void erfen(int[] array,int qian,int hou,int key,int[] count){

int temp = 0;

if(key = array[qian]key = array[hou] count[0] != 1){

if(qian hou){

temp = (qian+hou)/2;

if(key == array[temp]||key == array[qian]||key == array[hou]){

count[0] = 1;

}

else if(key array[temp]){

erfen(array,qian,temp,key,count);

}

else{

erfen(array,temp,hou,key,count);

}

}

}

}

}