javajack
- 浏览: 21823 次
- 性别:
- 来自: 北京
-
最新评论
-
flyfeifei66：
牛人啊，学习了
Itext应用封装(一)__写pdf模板 -
javajack：
java_base 写道您好，想问一下，如果我想做一个模板，模 ...
Itext应用封装(一)__写pdf模板 -
java_base：
您好，想问一下，如果我想做一个模板，模板里有两个区域，区域里可 ...
Itext应用封装(一)__写pdf模板 -
javajack：
wgcniler 写道你好,我根据你的方法根据模板来新创pdf ...
Itext应用封装(一)__写pdf模板 -
wgcniler：
你好,我根据你的方法根据模板来新创pdf文件,但是为什么那些域 ...
Itext应用封装(一)__写pdf模板
前一段时间面试，经常遇到有关排序的面试题，闲了无事，将各种排序方法用java写了一下。
代码如下：
import java.lang.Math;
import java.util.Random;
/**
* 排序
*
* @author javajack
*/
public class OrderTest {
public static void main(String args[]) {
OrderTest.ExecOrder(2);
}
/**
* 交换值，交换数组的两个值
* @param array
* @param i
* @param j
*/
private static void swap(int[] array,int i, int j)
{
int tmp = array[i];
array[i] = array[j];
array[j] = tmp;
}
/**
*
* @param method
* 1为升序，2为降序
*/
public static void ExecOrder(int method) {
int[] array = null;
array = initArray(10, 210, 10);
//int[] orderarray = bubbleOrder(array,method);
int[] orderarray = doubleBubbleOrder(array,method);
//int[] orderarray = insertOrder(array, method);
//int [] orderarray = quickOrder(array,method);
//int[] orderarray = selectOrder(array, method);
for (int i = 0; i < orderarray.length; i++) {
System.out.println(orderarray[i]);
}
}
/**
* 取随机数据，初始化一个数组
*
* @param min
* 随机数的最小值
* @param max
* 最大值
* @param size
* 取得随机数的数量
* @return
*/
public static int[] initArray(int min, int max, int size) {
int[] init = new int[size];
for (int i = 0; i < size; i++) {
Random ra = new Random();
init[i] = min + (int) (Math.random() * (max - min + 1));
System.out.println(i + "-------" + init[i]);
}
return init;
}
/**
* 交换排序方法
* 原理：依次交换值
* @param array
* @return
*/
public static int[] convertOrder(int[] array, int method) {
for (int i = 0; i < array.length; i++) {
for (int j = i + 1; j < array.length; j++)
{
if (method==2)
{
if (array[i] < array[j])
swap(array,i,j);
}else if (method == 1) {
if (array[i] > array[j])
swap(array,i,j);
}
}
}
return array;
}
/**冒泡排序方法
* 原理：从最后一个开始将小的或大的逐渐冒出
* @param array
* @param method
* @return
*/
public static int[] bubbleOrder(int[] array,int method)
{
for(int i=0;i<array.length;i++)
{
for (int j=array.length -1 ;j>i;j--)
{
if (method==2)
{
if (array[i] < array[j])
swap(array,i,j);
}else if (method==1)
if (array[i] > array[j])
swap(array,i,j);
}
}
return array;
}
/**
* 双向冒泡排序
* 原理：类似于冒泡排序，只不过是双向的
* @param array
* @param method
* @return
*/
public static int[] doubleBubbleOrder(int[] array,int method)
{
int left = 0;
int right = array.length -1 ;
while (left < right)
{
for(int i=left;i<=right;i++)
{
if (method==1)
{
if (array[left] > array[i])
swap(array,left,i);
}else
{
if (array[left] < array[i])
swap(array,left,i);
}
}
for (int i=left+1;i<=right;i++)
{
if (method==1)
{
if (array[right] < array[i])
swap(array,right,i);
}else
{
if (array[right] > array[i])
swap(array,right,i);
}
}
left++;
right--;
}
return array;
}
/**
* 快速排序方法，运用到递归
* 排序原理：随机找到一个值，然后以此值大小进行分为两个数组，大的放左边，小的放右边，
* 然后再对左右两侧的数据依次排序根据
* @param array
* @param method
* @return
*/
public static int[] quickOrder(int[] array, int method)
{
quickDeal(array,0,array.length - 1,method);
return array;
}
/**
*
* @param array
* @param begin
* 开始位置
* @param end
* 结束位置
*/
private static void quickDeal(int[] array, int begin, int end,int method) {
if (end > begin) {
int pos = begin + (int) (Math.random() * (end - begin + 1)); // 计算分隔位置
int posvalue = array[pos]; // 取得分隔位置的值
swap(array,pos,end); //将posvalue放到最end的位置
pos=begin; //初始化pos
for (int i=begin; i < end; i++) {
if (method==1)
{
if (array[i] < posvalue) { //当小于posvalue时，将此值移动到pos位置，也就是向前移动
swap(array,pos,i);
pos++; //移动后pos增1
}
}else if(method == 2)
{
if (array[i] > posvalue) { //当小于posvalue时，将此值移动到pos位置，也就是向前移动
swap(array,pos,i);
pos++; //移动后pos增1
}
}
}
swap(array,pos,end); //end位置的值前移
quickDeal(array,begin,pos -1,method);
quickDeal(array,pos+1,end,method);
}
}
/**
* 插入排序方法
* 排序原理：抽出一个数，做为排序基序列，然后依次抽出其它数与，与此序列中的数进行比较，放入合适的位置
* @param array
* @param method
* @return
*/
public static int[] insertOrder(int[] array, int method) {
for (int i = 1; i < array.length; i++) {
if (method == 1) {
if (array[i - 1] > array[i]) {
int tmp = array[i]; //
int j = i - 1;
do {
array[j + 1] = array[j];
j--;
} while (j >= 0 && tmp < array[j]); //当j>=0并且 当前值大于数据中j位置的值时移动
array[j + 1] = tmp; //插入排序值
}
} else if (method == 2) {
if (array[i - 1] < array[i]) {
int tmp = array[i];
int j = i - 1;
do {
array[j + 1] = array[j];
j--;
} while (j >= 0 && tmp > array[j]);
array[j + 1] = tmp;
}
}
}
return array;
}
/**
* 选择排序方法
* 排序原理：每次选择一个最大的或最小的数放到已排序序列中
* @param array
* @param method
* @return
*/
public static int[] selectOrder(int[] array,int method)
{
for (int i=0;i<array.length - 1;i++)
{
int tmp = array[i];
int pos = i+1; //记录大值或小值的位置
for (int j=i+1;j<array.length;j++)
{
if (method==1)
{
if (array[j]<tmp)
{
tmp = array[j];
pos= j ;//记录大值或小值的位置
}
}else if (method==2)
{
if (array[j]>tmp)
{
tmp = array[j];
pos= j ;//记录大值或小值的位置
}
}
}
if (tmp != array[i])
swap(array,i,pos); //不相同时交换
}
return array;
}
}
分享到：
评论
9 楼
ivyloo
2009-06-15
楼主是个有心人
8 楼
sdnasky
2009-06-15
chirking 写道
想想海量数据如何排序，比如1个1G的文件。
分成小部分来拍,最后合并结果就可以啦
7 楼
fengqx
2009-06-14
学习中，谢谢
6 楼
chirking
2009-06-11
想想海量数据如何排序，比如1个1G的文件。
5 楼
dust_dn
2008-10-02
javajack 写道
谢谢jjwenbo，当初写完后，也感觉交换排序与冒泡排序一样!
不过这段程序好像有问题，试想这三个数，2，1,3,运用此法将不能排序，应该怎么样更改呢？
引用
public int[] convertOrder(int []array)
{
for(int i=0;i<array.length;i++)
{
for(int j=i+1;j<array.length;j++)
{
if(array[j-1]>array[j])
swap(array,j-1,j);
}
}
return array;
}
不过这段程序好像有问题，试想这三个数，2，1,3,运用此法将不能排序，应该怎么样更改呢？
写得有问题。。。如果要从小到大排，前面的先不动的话，应该从后往前冒，把最小的冒泡到array[i]。。。
4 楼
flykete
2008-09-12
冒泡排序还能改进，
int[] a=new int[]{1,2,3,4};
boolean flag=false;
for(int i=0;i<a.length-1;i++){
if(flag==false&&i>0){
break;
}
flag=false;
for(int j=i+1;j<a.length;j++){
if(a[i]<a[j]){
int tmp=a[i];
a[i]=a[j];
a[j]=tmp;
flag=true;
}
}
}
int[] a=new int[]{1,2,3,4};
boolean flag=false;
for(int i=0;i<a.length-1;i++){
if(flag==false&&i>0){
break;
}
flag=false;
for(int j=i+1;j<a.length;j++){
if(a[i]<a[j]){
int tmp=a[i];
a[i]=a[j];
a[j]=tmp;
flag=true;
}
}
}
3 楼
javajack
2008-09-12
谢谢jjwenbo，当初写完后，也感觉交换排序与冒泡排序一样!
不过这段程序好像有问题，试想这三个数，2，1,3,运用此法将不能排序，应该怎么样更改呢？
引用
public int[] convertOrder(int []array)
{
for(int i=0;i<array.length;i++)
{
for(int j=i+1;j<array.length;j++)
{
if(array[j-1]>array[j])
swap(array,j-1,j);
}
}
return array;
}
不过这段程序好像有问题，试想这三个数，2，1,3,运用此法将不能排序，应该怎么样更改呢？
2 楼
alph0618
2008-09-10
<pre name='code' class='java'>import java.lang.Math;
import java.util.Random;
/**
* 排序
*
* @author javajack
*/
public class OrderTest {
public static void main(String args[]) {
OrderTest.ExecOrder(2);
}
/**
* 交换值，交换数组的两个值
* @param array
* @param i
* @param j
*/
private static void swap(int[] array,int i, int j)
{
int tmp = array[i];
array[i] = array[j];
array[j] = tmp;
}
/**
*
* @param method
* 1为升序，2为降序
*/
public static void ExecOrder(int method) {
int[] array = null;
array = initArray(10, 210, 10);
//int[] orderarray = bubbleOrder(array,method);
int[] orderarray = doubleBubbleOrder(array,method);
//int[] orderarray = insertOrder(array, method);
//int [] orderarray = quickOrder(array,method);
//int[] orderarray = selectOrder(array, method);
for (int i = 0; i < orderarray.length; i++) {
System.out.println(orderarray[i]);
}
}
/**
* 取随机数据，初始化一个数组
*
* @param min
* 随机数的最小值
* @param max
* 最大值
* @param size
* 取得随机数的数量
* @return
*/
public static int[] initArray(int min, int max, int size) {
int[] init = new int[size];
for (int i = 0; i < size; i++) {
Random ra = new Random();
init[i] = min + (int) (Math.random() * (max - min + 1));
System.out.println(i + "-------" + init[i]);
}
return init;
}
/**
* 交换排序方法
* 原理：依次交换值
* @param array
* @return
*/
public static int[] convertOrder(int[] array, int method) {
for (int i = 0; i < array.length; i++) {
for (int j = i + 1; j < array.length; j++)
{
if (method==2)
{
if (array[i] < array[j])
swap(array,i,j);
}else if (method == 1) {
if (array[i] > array[j])
swap(array,i,j);
}
}
}
return array;
}
/**冒泡排序方法
* 原理：从最后一个开始将小的或大的逐渐冒出
* @param array
* @param method
* @return
*/
public static int[] bubbleOrder(int[] array,int method)
{
for(int i=0;i<array.length;i++)
{
for (int j=array.length -1 ;j>i;j--)
{
if (method==2)
{
if (array[i] < array[j])
swap(array,i,j);
}else if (method==1)
if (array[i] > array[j])
swap(array,i,j);
}
}
return array;
}
/**
* 双向冒泡排序
* 原理：类似于冒泡排序，只不过是双向的
* @param array
* @param method
* @return
*/
public static int[] doubleBubbleOrder(int[] array,int method)
{
int left = 0;
int right = array.length -1 ;
while (left < right)
{
for(int i=left;i<=right;i++)
{
if (method==1)
{
if (array[left] > array[i])
swap(array,left,i);
}else
{
if (array[left] < array[i])
swap(array,left,i);
}
}
for (int i=left+1;i<=right;i++)
{
if (method==1)
{
if (array[right] < array[i])
swap(array,right,i);
}else
{
if (array[right] > array[i])
swap(array,right,i);
}
}
left++;
right--;
}
return array;
}
/**
* 快速排序方法，运用到递归
* 排序原理：随机找到一个值，然后以此值大小进行分为两个数组，大的放左边，小的放右边，
* 然后再对左右两侧的数据依次排序根据
* @param array
* @param method
* @return
*/
public static int[] quickOrder(int[] array, int method)
{
quickDeal(array,0,array.length - 1,method);
return array;
}
/**
*
* @param array
* @param begin
* 开始位置
* @param end
* 结束位置
*/
private static void quickDeal(int[] array, int begin, int end,int method) {
if (end > begin) {
int pos = begin + (int) (Math.random() * (end - begin + 1)); // 计算分隔位置
int posvalue = array[pos]; // 取得分隔位置的值
swap(array,pos,end); //将posvalue放到最end的位置
pos=begin; //初始化pos
for (int i=begin; i < end; i++) {
if (method==1)
{
if (array[i] < posvalue) { //当小于posvalue时，将此值移动到pos位置，也就是向前移动
swap(array,pos,i);
pos++; //移动后pos增1
}
}else if(method == 2)
{
if (array[i] > posvalue) { //当小于posvalue时，将此值移动到pos位置，也就是向前移动
swap(array,pos,i);
pos++; //移动后pos增1
}
}
}
swap(array,pos,end); //end位置的值前移
quickDeal(array,begin,pos -1,method);
quickDeal(array,pos+1,end,method);
}
}
/**
* 插入排序方法
* 排序原理：抽出一个数，做为排序基序列，然后依次抽出其它数与，与此序列中的数进行比较，放入合适的位置
* @param array
* @param method
* @return
*/
public static int[] insertOrder(int[] array, int method) {
for (int i = 1; i < array.length; i++) {
if (method == 1) {
if (array[i - 1] > array[i]) {
int tmp = array[i]; //
int j = i - 1;
do {
array[j + 1] = array[j];
j--;
} while (j >= 0 && tmp < array[j]); //当j>=0并且 当前值大于数据中j位置的值时移动
array[j + 1] = tmp; //插入排序值
}
} else if (method == 2) {
if (array[i - 1] < array[i]) {
int tmp = array[i];
int j = i - 1;
do {
array[j + 1] = array[j];
j--;
} while (j >= 0 && tmp > array[j]);
array[j + 1] = tmp;
}
}
}
return array;
}
/**
* 选择排序方法
* 排序原理：每次选择一个最大的或最小的数放到已排序序列中
* @param array
* @param method
* @return
*/
public static int[] selectOrder(int[] array,int method)
{
for (int i=0;i<array.length - 1;i++)
{
int tmp = array[i];
int pos = i+1; //记录大值或小值的位置
for (int j=i+1;j<array.length;j++)
{
if (method==1)
{
if (array[j]<tmp)
{
tmp = array[j];
pos= j ;//记录大值或小值的位置
}
}else if (method==2)
{
if (array[j]>tmp)
{
tmp = array[j];
pos= j ;//记录大值或小值的位置
}
}
}
if (tmp != array[i])
swap(array,i,pos); //不相同时交换
}
return array;
}
}</pre>
<p> </p>
import java.util.Random;
/**
* 排序
*
* @author javajack
*/
public class OrderTest {
public static void main(String args[]) {
OrderTest.ExecOrder(2);
}
/**
* 交换值，交换数组的两个值
* @param array
* @param i
* @param j
*/
private static void swap(int[] array,int i, int j)
{
int tmp = array[i];
array[i] = array[j];
array[j] = tmp;
}
/**
*
* @param method
* 1为升序，2为降序
*/
public static void ExecOrder(int method) {
int[] array = null;
array = initArray(10, 210, 10);
//int[] orderarray = bubbleOrder(array,method);
int[] orderarray = doubleBubbleOrder(array,method);
//int[] orderarray = insertOrder(array, method);
//int [] orderarray = quickOrder(array,method);
//int[] orderarray = selectOrder(array, method);
for (int i = 0; i < orderarray.length; i++) {
System.out.println(orderarray[i]);
}
}
/**
* 取随机数据，初始化一个数组
*
* @param min
* 随机数的最小值
* @param max
* 最大值
* @param size
* 取得随机数的数量
* @return
*/
public static int[] initArray(int min, int max, int size) {
int[] init = new int[size];
for (int i = 0; i < size; i++) {
Random ra = new Random();
init[i] = min + (int) (Math.random() * (max - min + 1));
System.out.println(i + "-------" + init[i]);
}
return init;
}
/**
* 交换排序方法
* 原理：依次交换值
* @param array
* @return
*/
public static int[] convertOrder(int[] array, int method) {
for (int i = 0; i < array.length; i++) {
for (int j = i + 1; j < array.length; j++)
{
if (method==2)
{
if (array[i] < array[j])
swap(array,i,j);
}else if (method == 1) {
if (array[i] > array[j])
swap(array,i,j);
}
}
}
return array;
}
/**冒泡排序方法
* 原理：从最后一个开始将小的或大的逐渐冒出
* @param array
* @param method
* @return
*/
public static int[] bubbleOrder(int[] array,int method)
{
for(int i=0;i<array.length;i++)
{
for (int j=array.length -1 ;j>i;j--)
{
if (method==2)
{
if (array[i] < array[j])
swap(array,i,j);
}else if (method==1)
if (array[i] > array[j])
swap(array,i,j);
}
}
return array;
}
/**
* 双向冒泡排序
* 原理：类似于冒泡排序，只不过是双向的
* @param array
* @param method
* @return
*/
public static int[] doubleBubbleOrder(int[] array,int method)
{
int left = 0;
int right = array.length -1 ;
while (left < right)
{
for(int i=left;i<=right;i++)
{
if (method==1)
{
if (array[left] > array[i])
swap(array,left,i);
}else
{
if (array[left] < array[i])
swap(array,left,i);
}
}
for (int i=left+1;i<=right;i++)
{
if (method==1)
{
if (array[right] < array[i])
swap(array,right,i);
}else
{
if (array[right] > array[i])
swap(array,right,i);
}
}
left++;
right--;
}
return array;
}
/**
* 快速排序方法，运用到递归
* 排序原理：随机找到一个值，然后以此值大小进行分为两个数组，大的放左边，小的放右边，
* 然后再对左右两侧的数据依次排序根据
* @param array
* @param method
* @return
*/
public static int[] quickOrder(int[] array, int method)
{
quickDeal(array,0,array.length - 1,method);
return array;
}
/**
*
* @param array
* @param begin
* 开始位置
* @param end
* 结束位置
*/
private static void quickDeal(int[] array, int begin, int end,int method) {
if (end > begin) {
int pos = begin + (int) (Math.random() * (end - begin + 1)); // 计算分隔位置
int posvalue = array[pos]; // 取得分隔位置的值
swap(array,pos,end); //将posvalue放到最end的位置
pos=begin; //初始化pos
for (int i=begin; i < end; i++) {
if (method==1)
{
if (array[i] < posvalue) { //当小于posvalue时，将此值移动到pos位置，也就是向前移动
swap(array,pos,i);
pos++; //移动后pos增1
}
}else if(method == 2)
{
if (array[i] > posvalue) { //当小于posvalue时，将此值移动到pos位置，也就是向前移动
swap(array,pos,i);
pos++; //移动后pos增1
}
}
}
swap(array,pos,end); //end位置的值前移
quickDeal(array,begin,pos -1,method);
quickDeal(array,pos+1,end,method);
}
}
/**
* 插入排序方法
* 排序原理：抽出一个数，做为排序基序列，然后依次抽出其它数与，与此序列中的数进行比较，放入合适的位置
* @param array
* @param method
* @return
*/
public static int[] insertOrder(int[] array, int method) {
for (int i = 1; i < array.length; i++) {
if (method == 1) {
if (array[i - 1] > array[i]) {
int tmp = array[i]; //
int j = i - 1;
do {
array[j + 1] = array[j];
j--;
} while (j >= 0 && tmp < array[j]); //当j>=0并且 当前值大于数据中j位置的值时移动
array[j + 1] = tmp; //插入排序值
}
} else if (method == 2) {
if (array[i - 1] < array[i]) {
int tmp = array[i];
int j = i - 1;
do {
array[j + 1] = array[j];
j--;
} while (j >= 0 && tmp > array[j]);
array[j + 1] = tmp;
}
}
}
return array;
}
/**
* 选择排序方法
* 排序原理：每次选择一个最大的或最小的数放到已排序序列中
* @param array
* @param method
* @return
*/
public static int[] selectOrder(int[] array,int method)
{
for (int i=0;i<array.length - 1;i++)
{
int tmp = array[i];
int pos = i+1; //记录大值或小值的位置
for (int j=i+1;j<array.length;j++)
{
if (method==1)
{
if (array[j]<tmp)
{
tmp = array[j];
pos= j ;//记录大值或小值的位置
}
}else if (method==2)
{
if (array[j]>tmp)
{
tmp = array[j];
pos= j ;//记录大值或小值的位置
}
}
}
if (tmp != array[i])
swap(array,i,pos); //不相同时交换
}
return array;
}
}</pre>
<p> </p>
1 楼
jjwenbo
2008-09-09
辛苦楼主了，不过你写的你所说的交换排序就是冒泡排序，只是一个重后开始冒泡，一个是重前开始冒泡。
你所说的交换排序：
public int[] convertOrder(int []array)
{
for(int i=0;i<array.length;i++)
{
for(int j=i+1;j<array.length;j++)
{
if(array[j-1]>array[j])
swap(array,j-1,j);
}
}
return array;
}
你所说的交换排序：
public int[] convertOrder(int []array)
{
for(int i=0;i<array.length;i++)
{
for(int j=i+1;j<array.length;j++)
{
if(array[j-1]>array[j])
swap(array,j-1,j);
}
}
return array;
}
发表评论
-
mavne记录
2012-12-08 20:10 01、POM文件报错maven-dependency-plugi ... -
itext更换模板中图片的方法
2011-07-26 17:36 2767生成pdf文件时，一般情况都是些表格或文字的，但也有pdf的需 ... -
Itext应用封装(二)_生成表格
2011-01-17 15:19 2328去年写了对itext封装，主要是向模板写数据，而在我们的项目中 ... -
Itext应用封装(一)__写pdf模板
2010-01-19 15:51 4896忙，每天都在忙，几乎没有时间写代码，每天在各种文档中打开 ... -
Java中对象的串行化
2008-07-16 14:52 1318今天在网上转，偶尔看到有关串行化一篇文章，感觉不错，稍加整理， ... -
去除arraylist中的重复值
2008-07-03 13:43 4483今天偶尔用到去除arraylist中的重复值，在网上找到两种方 ...
相关推荐
C语言数组排序总结
Java数组排序总结(冒泡_选择_插入_希尔)__递归算法的复杂度，实用
首先接触的就是PHP数组排序、降序的排序问题。sort：本函数为 array 中的单元赋予新的键名。这将删除原有的键名而不仅是重新排序。 rsort：本函数对数组进行逆向排序（最高到最低）。 删除原有的键名而不仅是重新...
在php中数组排序一直是一个老生常谈的问题，下面我们来集中讲一下关于在php中一维数组与二维数组排序的实现程序，相信对大家有一定的参考借鉴价值. 功能:对数组进行重新排序. 说明:冒泡排序 (一维数组)(二维数组某个...
我自己总结的 .C语言数组排序小结
数组排序的各种算法，包括基数排序，快速排序，插排等
开发中，遇到数组排序的需求很频繁，这篇文章会介绍几个常见排序思路。 一、希尔排序（性能最好） 如果要从大到小排列，则 while(arr[n] > arr[n – interval] && n > 0) 。 // 希尔排序算法 function xier(arr){ ...
sort函数怎么使用的总结
第五单元包括十个单元，分别是一维数组的定义、一维数组的输入与输出、一维数组的插入删除、一维数组的查找统计、一维数组的元素排序、一维数组的应用举例、二维数组的定义与操作、二维数组的应用举例、数字方阵、...
数组常用方法总结： 下面我只总结了es3中常...2个数组排序方法：reverse（）、sort（） 连接数组的方法： 1、concat（） 作用：连接两个数组，合并为一个新数组。 用法：arr1.concat（arr2，arr2…） 示例： [removed]
本文实例总结了JS数组排序技巧。分享给大家供大家参考，具体如下： ① 冒泡排序 bubbleSort:function(array){ var i = 0, len = array.length, j, d; for(; i<len; i++){ for(j=0; j<len; j++){ if(array[i] ...
用Java写的插入排序， 对一维整型数组进行插入排序。 一个类。
包括代码和总结部分
由于最近都在freecodecamp上刷代码，运用了很多JavaScript数组的方法，因此做了一份关于JavaScript教程的整理，具体内容如下： 一、普通方法 1、join() 将数组元素连接在一起，并以字符串形式返回 参数：可选，指定...
合并数组并且转为有序去重集合，我看到很多资源博客，百度都弄的很繁琐，所以自己总结描述了一下
数组总结（概念、定义、默认值、可变长参数、值传递与引用传递等）。1.冒泡排序： 两两相比(两个相邻的数进行比较) 条件成立 互换位置 外层循环控制比较的轮数 **轮数永远是 长度 -1 (n - 1)** 内层循环...
本文实例讲述了JavaScript实现获取两个排序数组的中位数算法。分享给大家供大家参考，具体如下： 题目 给定两个大小为 m 和 n 的有序数组 nums1 和 nums2...分析:用数组排序方法轻松解决 JS代码： var findMedianSo