国产三线在线,老司机2019福利精品视频导航,日本一区二区不卡视频

二分查找旉��复杂度的计算(�?

abin — Thu, 26 Mar 2015 08:30:00 GMT

二分查找的基本思想是将n个元素分成大致相�{�的两部分，去a[n/2]与x做比较，如果x=a[n/2],则找到x,��法中止�Q�如果xa[n/2],则只要在数组a的右半部搜烦x.

旉��复杂度无非就是while循环的次敎ͼ�

��d��有n个元素，

渐渐跟下��d��是n,n/2,n/4,....n/2^k�Q�其中k��是循环的次�?/span>

�׃��你n/2^k取整�?gt;=1

即��on/2^k=1

可得k=log2n,�Q�是�?为底�Q�n的对敎ͼ�

所以时间复杂度可以表示O()=O(logn)

abin 2015-03-26 16:30 发表评论

abin — Mon, 17 Nov 2014 13:47:00 GMT

设x[1…n],y[1…n]��Z��个数�l�，每个包含n个已知的排好序的敎ͼ��l�出一个数�l�x和y中所�?n个元素的中位敎ͼ�要求旉��复杂度�ؓO(lgN)

�q�是��法��D��上面的一道题目：

public class FindMedianTwoSortedArray {

public static int median(int[] arr1, int l1, int h1, int[] arr2, int l2, int h2)

{

System.out.println("-----------");

int mid1 = (h1 + l1 ) / 2;

int mid2 = (h2 + l2 ) / 2;

if (h1 - l1 == 1)

return (Math.max(arr1[l1] , arr2[l2]) + Math.min(arr1[h1] , arr2[h2]))/2;

else if (arr1[mid1] > arr2[mid2])

return median(arr1, l1, mid1 , arr2, mid2 , h2);

else

return median(arr1, mid1 , h1, arr2, l2 , mid2 );

}

public static void main(String[] args) {

int[] a = new int[]{0,1,2};

int[] b = new int[]{1,2,3};

int result = median(a, 0, a.length-1,b,0,b.length-1);

System.out.println(result);

}

abin 2014-11-17 21:47 发表评论

插入排序(java)

abin — Sat, 18 Oct 2014 17:20:00 GMT

package com.abin.lee.algorithm.insert;

import java.util.Arrays;

public class InsertSort {

public static void main(String[] args) {

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

input = InsertSort.sort(input);

System.out.println(Arrays.toString(input));

}

public static int[] sort(int[] input){

int temp = 0;

for(int i=0;i

temp = input[i];

int j=i-1;

for(;j>=0&&temp

input[j+1] = input[j];

}

input[j+1] = temp;

}

return input;

}

abin 2014-10-19 01:20 发表评论

归�ƈ排序(java)

abin — Fri, 17 Oct 2014 10:31:00 GMT

package com.abin.lee.algorithm.merge;

import java.util.Arrays;

/**

* 归�ƈ排序

public class MergeSort {

public static void main(String[] args) {

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

MergeSort.sort(input, 0, input.length-1);

System.out.println("input="+Arrays.toString(input));

}

//首先分而自�?/div>

/**

* 归�ƈ排序

* ��?��两个（或两个以上）有序表合�q�成一个新的有序表 ��x��待排序序列分��q�个子序列，每个子序列是有序的。然后再把有序子序列合�ƈ为整体有序序�?nbsp;

* 旉��复杂度�ؓO(nlogn)

* �E�_��排序方式

* @param nums 待排序数�l?nbsp;

* @return 输出有序数组

public static int[] sort(int[] input,int low,int high){

int middle = (low+high)/2;

if(low

//左边

sort(input,low,middle);

//双��

sort(input,middle+1,high);

//左右归�ƈ

merge(input,low,high,middle);

}

return input;

}

public static void merge(int[] input,int low,int high,int middle){

int[] temp = new int[high-low+1];

int i = low;//左指�?/div>

int j = middle+1;//��x��?/div>

int k=0;

// 把较��的数先�U�d��新数�l�中

while(i<=middle&&j<=high){

if(input[i]

temp[k++] = input[i++];

}else{

temp[k++] = input[j++];

}

// 把左边剩余的数移入数�l?

while(i<=middle){

temp[k++] = input[i++];

}

// 把右边边剩余的数�U�d��数组

while(j<=high){

temp[k++] = input[j++];

}

// 把新数组中的数覆盖input数组

for(int m=0;m

input[m+low] = temp[m];

}

abin 2014-10-17 18:31 发表评论

二分查找�?java)

abin — Fri, 10 Oct 2014 16:03:00 GMT

//递归�?br />package com.abin.lee.algorithm.binary;

public class BinarySearch {

public static void main(String[] args) {

int[] input = new int[]{2,3,4,5,6,7,8,9};

int result = search(input, 5, 0, input.length-1);

System.out.println("result="+result);

}

public static int search(int[] input,int data,int low,int high){

int middle = (low+high)/2;

if(data == input[middle]){

return middle;

}else if(data > input[middle]){

return search(input, data, middle+1, high);

}else if(data < input[middle]){

return search(input, data, low, middle-1);

}else{

return -1;

}

}

//while循环�?br />

public static int binary(int[] input,int low,int high,int target){

while(low <= high){

int middle = (low+high)/2;

if(input[middle]>target){

high = middle-1;

}else if(input[middle]

low = middle+1;

}else{

return middle;

}

return -1;

}

abin 2014-10-11 00:03 发表评论

快速排�?java)

abin — Fri, 10 Oct 2014 15:43:00 GMT

package com.abin.lee.algorithm.fast;

public class SpeedSort {

public static void main(String[] args) {

int[] input = new int[]{1,6,3,5,2,4};

quickSort(input, 0, input.length-1);

for(int i=0;i

System.out.println("input["+i+"]="+input[i]);

}

//分�ؓ参照物的大小两组

public static int getMiddle(int[] input,int low,int high){

int temp = input[low];

while(low

while(lowtemp){

high--;

}

input[low]=input[high];

while(low

low++;

}

input[high]=input[low];

}

input[low]=temp;

return low;

}

//分而自�?/div>

public static void quickSort(int[] input,int low,int high){

if(low

int middle = getMiddle(input, low, high);

quickSort(input,low,middle-1);

quickSort(input,middle+1,high);

}

快速排�?nbsp;对冒泡排序的一�U�改�q�，若初始记录序列按关键字有序或基本有序�Q�蜕化�ؓ冒��排序。��用的是递归原理�Q�在所有同数量�U�O(n longn) 的排序方法中�Q�其�q�_��性能最好。就�q�_��旉��而言�Q�是目前被认为最好的一�U?u>内部排序�Ҏ��
基本思想是：通过一�w�排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小�Q�然后再按此�Ҏ��对这两部分数据分别进行快速排序，整个排序�q�程可以递归�q�行�Q�以此达到整个数据变成有序序列�?br /> 三个指针: �W�一个指针称为pivotkey指针�Q�枢��_��Q�第二个指针和第三个指针分别为left指针和right指针�Q�分别指向最左边的值和最双��的倹{��left指针和right指针从两边同时向中间��D��Q�在��D��的过�E�中不停的与枢��u比较�Q�将比枢轴小的元素移��C��端，��比枢��u大的元素�U�d��高端�Q�枢轴选定后永�q�不变，最�l�在中间�Q�前��后大�?br />

需要两个函敎ͼ�

① 递归函数 public static void quickSort(int[]n ,int left,int right)
② 分割函数�Q�一��快速排序函敎ͼ� public static int partition(int[]n ,int left,int right)

JAVA源代码（成功�q�行�Q?/span>�Q?br />

package testSortAlgorithm;

public class QuickSort {

public static void main(String[] args) {

int [] array = {49,38,65,97,76,13,27};

quickSort(array, 0, array.length - 1);

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

System.out.println(array[i]);

}

/*先按照数�l��ؓ数据原型写出��法�Q�再写出扩展性算法。数�l�{49,38,65,97,76,13,27}

* */

public static void quickSort(int[]n ,int left,int right){

int pivot;

if (left < right) {

//pivot作�ؓ枢��u�Q�较之小的元素在左，较之大的元素在右

pivot = partition(n, left, right);

//对左��x��l�递归调用快速排序，直到��序完全正确

quickSort(n, left, pivot - 1);

quickSort(n, pivot + 1, right);

}

public static int partition(int[]n ,int left,int right){

int pivotkey = n[left];

//枢��u选定后永�q�不变，最�l�在中间�Q�前��后�?/div>

while (left < right) {

while (left < right && n[right] >= pivotkey) --right;

//��比枢��u��的元素�U�d��低端�Q�此时right位相当于�I�，�{�待低位比pivotkey大的数补�?/div>

n[left] = n[right];

while (left < right && n[left] <= pivotkey) ++left;

//��比枢��u大的元素�U�d��高端�Q�此时left位相当于�I�，�{�待高位比pivotkey��的数补�?/div>

n[right] = n[left];

}

//当left == right�Q�完成一��快速排序，此时left位相当于�I�，�{�待pivotkey补上

n[left] = pivotkey;

return left;

}

abin 2014-10-10 23:43 发表评论

单链表的实现(java)

abin — Fri, 10 Oct 2014 14:46:00 GMT

package com.abin.lee.list.test;

public class SingleList {

private Object obj;

private transient SingleList singleList;

private SingleList next;

private SingleList pre;

private transient int size;

public SingleList() {

singleList = new SingleList(null,null,null);

singleList.next = singleList.pre = singleList;

size=0;

}

public SingleList(Object obj,SingleList next,SingleList pre) {

this.obj=obj;

this.next=next;

this.pre=pre;

}

public void add(Object obj){

SingleList current = new SingleList(obj,singleList,singleList.pre);

current.next.pre = current;

current.pre.next = current;

size++;

singleList = current;

}

public int size(){

return size;

}

public Object get(int index){

SingleList current = singleList.next;

for(int i=0;i

current = current.next;

}

return current.obj;

}

public static void main(String[] args) {

SingleList single = new SingleList();

for(int i=0;i<5;i++){

single.add("abin"+i);

}

System.out.println("single="+single);

int size = single.size();

System.out.println("size="+size);

Object element = single.get(0);

System.out.println("element="+element);

}

abin 2014-10-10 22:46 发表评论

Java 常常被问到的��法

abin — Tue, 24 Sep 2013 00:50:00 GMT

二叉树相关的问的比较�?br />二分查找
treemap和某些数据库索引的的底层是红黑树
链表的相交和闭环

针对二叉树，比如分层遍历�Q�找最�q�父节点
在字�W�串中找回文�Ԍ��数组中寻��N��复的数字或相��M��和的最大串

�U�黑树不��是B树么

如果没有遇到专业考算法的公司�Q�只能说�q�没面试�q�牛公司�Q�就相当于编�E�感觉不到数据结构，相当于编�E�还没入�?/div>

是对�U�C��叉B�?br />�q�是有点不一��P��是其子集�Q�误��g��?/div>

abin 2013-09-24 08:50 发表评论

java 排序��法有多��种

abin — Thu, 05 Sep 2013 11:49:00 GMT

语言只是把具体的��法实现出来而已。据我了解的排序��法11-13�U�。排序算法嘛主要��是个思想而已。不同的��法旉��复杂度不一��P��I�间复杂度也不一��P��当然执行的效率也不一栗��当焉��用哪�U�算法还取决于你要实��C��么样的功能。就好比��_��要同时尽快的扑և�最大最��，或者尽快的扑և�最值的位置�{�等�?br />冒��排序�Q�bubble sort�Q?— O(n2)
鸡尾酒排�?(Cocktail sort, 双向的冒泡排�? — O(n2)
插入排序 �Q�insertion sort�Q?#8212; O(n2)
桶排�?�Q�bucket sort�Q?#8212; O(n); 需�?O(k) 额外记忆�?
计数排序 (counting sort) — O(n+k); 需�?O(n+k) 额外记忆�?
归�ƈ排序 �Q�merge sort�Q?#8212; O(n log n); 需�?O(n) 额外记忆�?
原地归�ƈ排序 — O(n2)
二叉树排�?�Q�Binary tree sort�Q?— O(n log n); 需�?O(n) 额外记忆�?
鸽�l排序 (Pigeonhole sort) — O(n+k); 需�?O(k) 额外记忆�?
基数排序 �Q�radix sort�Q?#8212; O(n·k); 需�?O(n) 额外记忆�?
Gnome sort — O(n2)
Library sort — O(n log n) with high probability, 需�?(1+ε)n 额外记忆体不�E�_��
选择排序 �Q�selection sort�Q?#8212; O(n2)
希尔排序 �Q�shell sort�Q?#8212; O(n log n) 如果使用最佳的现在版本
Comb sort — O(n log n)
堆排�?�Q�heapsort�Q?#8212; O(n log n)
Smoothsort — O(n log n)
快速排�?�Q�quicksort�Q?#8212; O(n log n) 期望旉��, O(n2) 最坏情�? �Ҏ��大的、�ؕ��C��列一般相信是最快的已知排序

abin 2013-09-05 19:49 发表评论

Java 常用��法

abin — Thu, 05 Sep 2013 08:27:00 GMT

1、冒泡排序：
冒��排序�Q�BubbleSort�Q�的基本概念是：依次比较盔R��的两个数�Q�将��数攑֜�前面�Q�大数放在后面。即在第一��：首先比较�W?个和�W?个数�Q�将��数攑։��Q�大数放后。然后比较第2个数和第3个数�Q�将��数攑։��Q�大数放后，如此�l�箋�Q�直��x��较最后两个数�Q�将��数攑։��Q�大数放后。至此第一��结束，��最大的数放��C��最后。在�W�二��：仍从�W�一�Ҏ��开始比较（因�ؓ可能�׃��W?个数和第3个数的交换，使得�W?个数不再��于�W?个数�Q�，��小数放前，大数攑֐��Q�一直比较到倒数�W�二个数�Q�倒数�W�一的位�|�上已经是最大的�Q�，�W�二��结束，在倒数�W�二的位�|�上得到一个新的最大数�Q�其实在整个数列中是�W�二大的敎ͼ�。如此下去，重复以上�q�程�Q�直��x��l�完成排序�?

具体代码例一�Q?br />

package com.abin.lee.algorithm.bubble;

public class BubbleSort {
public static void main(String[] args) {
  int[] start={5,2,1,3,6,4};
  int[] end=sort(start);
  for(int i=0;i   System.out.println("end["+i+"]="+end[i]);
  }
}

public static int[] sort(int[] input){
  int temp=0;

//最多做n-1��排�?/div>  for(int i=0;i   //对当前无序区间score[0......length-i-1]�q�行排序(j的范围很关键�Q�这个范围是在逐步�~�小�?
   for(int j=0;j   //把大的��g��换到后面
    if(input[j]>input[j+1]){
     temp=input[j];
     input[j]=input[j+1];
     input[j+1]=temp;
    }
    StringBuffer stb=new StringBuffer();
    for(int k=0;k     stb.append("input["+k+"]="+input[k]+" ");
    }
    System.out.println("i="+i+",j="+j+" = "+stb.toString());
   }
  }
  return input;
}

}

2、选择排序�Q?br />选择排序(Straight Select Sorting) 也是一�U�简单的排序�Ҏ��Q�它的基本思想是：�W�一�ơ从R[0]~R[n-1]中选取最��|��与R[0]交换�Q�第二次从R{1}~R[n-1]中选取最��|��与R[1]交换�Q?...�Q?nbsp; �W�i�ơ从R[i-1]~R[n-1]中选取最��|��与R[i-1]交换�Q?....�Q�第n-1�ơ从R[n-2]~R[n-1]中选取最��|��与R[n-2]交换,��d��通过n-1��?得到一个按排序码从��到大排列的有序序列.
具体代码�Q?br />

package com.abin.lee.algorithm.select;

public class SelectSort {
public static void main(String[] args) {
  int[] start={5,2,3,1,6,4};
  start=sort(start);
  for(int i=0;i   System.out.println("start["+i+"]="+start[i]);
  }
}
public static int[] sort(int[] input){
  int temp=0;
  for(int i=0;i   for(int j=i+1;j    if(input[i]>input[j]){
     temp=input[i];
     input[i]=input[j];
     input[j]=temp;
    }
    StringBuffer stb=new StringBuffer();
    for(int k=0;k     stb.append("input["+k+"]="+input[k]+" ");
    }
    System.out.println("i="+i+",j="+j+" = "+stb.toString());
   }
  }
  return input;
}
}

3、请输入一个数字，比如4�Q�输��Zؓ�Q?br />1
2 3
4 5 6
7 8 9 10

代码如下�Q?br />

package com.abin.lee.photo;

public class TestInputNumber {
public static void main(String[] args) {
  int n=4;
  output(n);
}
public static void output(int n){
  int temp=1;
  for(int i=1;i<=n;i++){
   for(int j=0;j    System.out.print(temp+" ");
    temp++;
   }
   System.out.println("");
  }

}
}

4.二叉树算�?br />

package com.abin.lee.algorithm.binary;

public class BinaryNode {
public int data;//根节�?br /> BinaryNode left;//左节�?br /> BinaryNode right;//双��?br />
public BinaryNode(int data,BinaryNode left,BinaryNode right) {
  this.data=data;
  this.left=left;
  this.right=right;
}

public int getData() {
  return data;
}
public void setData(int data) {
  this.data = data;
}
public BinaryNode getLeft() {
  return left;
}
public void setLeft(BinaryNode left) {
  this.left = left;
}
public BinaryNode getRight() {
  return right;
}
public void setRight(BinaryNode right) {
  this.right = right;
}
}

package com.abin.lee.algorithm.binary;

public class BinaryTree {
//前序遍历
public static void preOrder(BinaryNode root){
  if(null!=root){
   System.out.print(root.data+"-");
   preOrder(root.left);
   preOrder(root.right);
  }
}
//中序遍历
public static void inOrder(BinaryNode root){
  if(null!=root){
   inOrder(root.left);
   System.out.print(root.data+"--");
   inOrder(root.right);
  }
}
//后序遍历
public static void postOrder(BinaryNode root){
  if(null!=root){
   postOrder(root.left);
   postOrder(root.right);
   System.out.print(root.data+"---");
  }
}

public static void main(String[] args) {
  BinaryNode one=new BinaryNode(1,null,null);
  BinaryNode three=new BinaryNode(3,null,null);
  BinaryNode two=new BinaryNode(2,three,one);
  BinaryNode four=new BinaryNode(4,one,two);
  BinaryNode five=new BinaryNode(5,four,one);
  System.out.println("preOrder");
  preOrder(five);
  System.out.println();
  System.out.println("inOrder");
  inOrder(five);
  System.out.println();
  System.out.println("postOrder");
  postOrder(five);
  System.out.println();

}

}

输出�l�果�Q?br />preOrder
5-4-1-2-3-1-1-
inOrder
1--4--3--2--1--5--1--
postOrder
1---3---1---2---4---1---5---

5、java插入排序

插入式排序法——插入排序�?/span>

插入排序�Q�Insertion Sortion�Q�的基本思想是：�?/span>n个待排序的元素看成一个有序表和一个无序表�Q�开始有序表只包含一个元素，无序表中包含n-1个元素，排序�q�程中每�ơ从无序表中取出�W�一个元素，把它的排序码依次与有序表元素的排序码�q�行比较�Q�将它插入到有序表中的适当位置�Q��之成为新的有序表�?/span>

public class InjectionSort  //定义一�?InjectionSort �c?br />public static void injectionSort(int[] number) //传数�l?br />for(int j = 1;jint tmp = number[j];  //循环把数�l�第二个值放到tmp�?br />int i = j-1//�l�i 赋�?br />while(tmpnumber[i+1] = number[i];  //如果���于���把�W�一个��D��值给�W�二�?br />i--;
if(i == -1)//如果i�?-1
break;   //退出��@�?br />number[i+1] = tmp //因�ؓ比较数组里的前一个比后一个这样就换交了实��C��把小的放在前�?br />�q�是�W�一�ơ，因�ؓ循环是一个数�l�，后边的就一�ơ往下��@环，最后就把数�l�里的顺序从���到大排序了
public static void main(String[] args){  
		int[] num = {5,46,26,67,2,35};//定义数组num
		injectionSort(num);//调用�Ҏ��
		for(int i = 0;i			System.out.println(num[i]);//昄���排序后的数组�Q�一行显�C�Z��个�?br />
���单说���是数组里第二个和第一个比谁小�Q�把���的攑ֈ��W�一个里�Q�大的放到第二个里，然后�W�二个再和第三个比，���的�q�是攑֜�前，一直比到这个数�l�结束，�q�样���实��C��从小到大�Q�希望我说的够详�l?/pre>

插入排序代码while循环�Q?br />package com.abin.lee.algorithm.insert;
public class InsertSort {
	public static void main(String[] args) {
		int[] input = { 1, 3, 5, 7, 9, 2, 4, 6, 8, 0 };
		input=sort(input);
		for (int i = 0; i < input.length; i++) {
			System.out.print(input[i] + "  ");
		}
	}
	public static int[] sort(int[] input) {
		for (int i = 1; i < input.length; i++) {
			int insertVal = input[i];
			// insertValue准备和前一个数比较
			int index = i - 1;
			while (index >= 0 && insertVal < input[index]) {
				// ���把input[index]向后�U�d��
				input[index + 1] = input[index];
				// 让index向前�U�d��一�?/div>				index--;
			}
			// ���insertValue插入到适当位置
			input[index + 1] = insertVal;
			
			//下面�q�个循环是�ؓ了打��C��下中间的循环看看是不是插入排序的正确���法
			StringBuffer stb=new StringBuffer();
			for(int k=0;k				stb.append(input[k]+" ");
			}
			System.out.println("i="+i+" = "+stb.toString());
		}
		return input;
	}
}


插入排序for循环代码�Q?br />
package com.abin.lee.algorithm.insert;
public class DoInsertSort {
	public static void main(String[] args) {
		int[] input={5,4,6,3,7,2,8,1,0,9};
		input=sort(input);
		for(int i=0;i			System.out.print("input["+i+"]="+input[i]+" ");
		}
	}
	
	public static int[] sort(int[] input){
		for(int i=1;i			int temp=input[i];
			int j;
			for(j=i;j>0;j--){
				if(temp					input[j]=input[j-1];
				}else{
					break;
				}
			}
			input[j]=temp;
			
			//下面�q�个循环是�ؓ了打��C��下中间的循环看看是不是插入排序的正确���法
			StringBuffer stb=new StringBuffer();
			for(int k=0;k				stb.append(input[k]+" ");
			}
			System.out.println("i="+i+" = "+stb.toString());
		}
		
		return input;
	}
}


 
二分查找又称折半查找�Q�它是一�U�效率较高的查找�Ҏ���?/p>
折半查找的算法思想是将数列按有序化(递增或递减)排列�Q�查找过�E�中采用跌���式方式查找，卛_��以有序数列的中点位置为比较对象，如果要找的元素值小于该中点元素�Q�则���待查序列羃����ؓ左半部分�Q�否则�ؓ叛_��部分。通过一�ơ比较，���查扑֌�间羃���一半�?折半查找是一�U�高效的查找�Ҏ��。它可以明显减少比较�ơ数�Q�提高查找效率。但是，折半查找的先��x��件是查找表中的数据元素必���L��序�?/span>
package com.abin.algorithm.template.half;

public class BinarySearch {
	public static void main(String[] args) {
		int[] src=new int[]{1,3,5,7,9,11};
		int result=binarySearch(src, 3);
		System.out.println("result="+result);
		int status=binarySearch(src, 9 ,0 ,src.length);
		System.out.println("status="+status);
	}
	//循环实现
	public static int binarySearch(int[] src,int key){
		int low=0;
		int high=src.length-1;
		while(low<=high){
			int middle=(low+high)/2;
			if(key==src[middle]){
				return middle;
			}else if(key
				high=middle-1;
			}else{
				low=middle+1;
			}
		}
		return -1;
	}
	//递归实现
	public static int binarySearch(int[] src,int key,int low,int high){
		int middle=(low+high)/2;
		if(src[middle]==key){
			return middle;
		}else if(low>=high){
			return -1;
		}else if(src[middle]>key){
			return binarySearch(src, key, low, middle-1);
		}else if(src[middle]
			return binarySearch(src, key, middle+1, high);
		}
		return -1;
	}

}




abin 2013-09-05 16:27 发表评论

国产三线在线,老司机2019福利精品视频导航,日本一区二区不卡视频

二分查找旉���复杂度的计算(�?

插入排序(java)

归�ƈ排序(java)

二分查找�?java)

快速排�?java)

单链表的实现(java)

Java 常常被问到的���法

java 排序���法有多���种

Java 常用���法

二分查找旉��复杂度的计算(�?

Java 常常被问到的��法

java 排序��法有多��种

Java 常用��法