二分排序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);

}

}

}

}

}

文章標題：二分排序java代碼,二分排序js
URL網址：http://m.kartarina.com/article48/heighp.html

成都網站建設公司_創新互聯，為您提供關鍵詞優化、企業建站、營銷型網站建設、建站公司、ChatGPT、網站策劃

廣告

聲明：本網站發布的內容（圖片、視頻和文字）以用戶投稿、用戶轉載內容為主，如果涉及侵權請盡快告知，我們將會在第一時間刪除。文章觀點不代表本網站立場，如需處理請聯系客服。電話：028-86922220；郵箱：631063699@qq.com。內容未經允許不得轉載，或轉載時需注明來源： 創新互聯