排序算法（冒泡，选择，快速）Java 实现
冒泡 排序：
public static void Bubblesort(int [] a)
{
for(int x=0;x<=a.length-1;x++)
{
for(int y=0;y<a.length-1-x;y++)
{
swapArrayAsc(a,y,y+1);
}
}
}
选择排序：
public static void SelectorSort(int [] a)
{
for(int x=0;x<=a.length-1;x++)
{
for(int y=x+1;y<=a.length-1;y++)
{
swapArrayAsc(a,x,y);
}
}
}
快速排序(While)：
public static void quickSort(int[] a, int l, int r) {
int i = l, j = r, x = a[l];
if (l < r) {
while (i < j) {
while (i < j && a[j] >= x)//前面虽然while里判断过，但while最后还有个j--,j--之后可能会出现i=j的情况，所以if不能去掉。
j--;
if (i < j) {
a[i] = a[j];
//i++;
}
while (i < j && a[i] < x)
i++;
if (i < j) {
a[j] = a[i];
//j--;
}
}
a[i] = x;
if( i-l >1 )
quickSort(a, l, i - 1);
if( r-i >1 )
quickSort(a, i + 1, r);
}
}
快速排序(for)
private static void QuickSort(int[] array,int start,int end)
{
if(start<end)
{
int key=array[start];//初始化保存基元
int i=start,j;//初始化i,j
for(j=start+1;j<=end;j++)
{
if(array[j]<key)//如果此处元素小于基元，则把此元素和i+1处元素交换，并将i加1，如大于或等于基元则继续循环
{
int temp=array[j];
array[j]=array[i+1];
array[i+1]=temp;
i++;
}
}
array[start]=array[i];//交换i处元素和基元
array[i]=key;
QuickSort(array, start, i-1);//递归调用
QuickSort(array, i+1, end);
}
}
//快速排序算法，这个比较复杂一点，如果可以，画图理解比较好，主要采取分治策略
public static void quickSort(int[] array,int low,int high){
if(low>=high){
return; // 如果左边的指针往右移超过或者等于了右边的指针，那么跳出递归
}
int left = low;
int right = high;
int baseValue = array[left];
while(left<right){//开启循环递归
while(left<right&&array[right]>=baseValue){
right--; //如果右边指针左移 一直都是比基准值大或者相等的，则继续左移
}
// 跳出了上面的循环，那么意味着右边指针找到比基准值小的数了，这时候填左边坑
array[left] = array[right];
while(left<right&&array[left]<baseValue){
left++; //同理，左边指针右移 一直都是比基准值小的数字，则继续右移
}
//跳出了上面的循环，那么意味着左边指针找到比基准值大的数字了，这时候填右边坑
array[right] = array[left];
//一次循环结束，则要把基准值放入左边坑
array[left] = baseValue;
//开启递归
quickSort(array,low,left-1);
quickSort(array,left+1,high);
}
}
打印以及交换：
public static void printArray(int [] a)
{
System.out.print("[");
for(int i=0;i<=a.length-1;i++)
{
if(i!=a.length-1)
System.out.print(a[i]+",");
else System.out.print(a[i]+"]");
}
}
public static void swapArrayAsc(int [] a, int x,int y)//,boolean sortFlag)
{
if(a[x]>a[y])
{
int temp=a[x];
a[x]=a[y];
a[y]=temp;
}
}
-----------------------------------------------======================================---------------------------------------------------------------------
取最值
public static int getMaxArray(int [] a)
{
int max=0;
for(int x=0;x<=a.length-1;x++)
{
if (a[x]>a[max])
{
max=x;
}
}
return a[max];
}
public static int getMaxArray2(int [] a)
{
int max=a[0];
for(int x=0;x<=a.length-1;x++)
{
if (a[x]>max)
{
max=a[x];
}
}
return max;
}
二分查找法：
public static int halfSearchGetIndex(int [] a,int key)
{
int min=0,max=a.length-1,mid=(min+max)/2;
while(a[mid]!=key)
{
if(a[mid]<key)
{
max=mid-1;
}
else if(a[mid]>key)
{
min=mid+1;
}
if(max<min)
return -1;
mid=(min+max)/2;
}
return mid;
}
public static int halfSearchGetIndex2(int [] a,int key)
{
int min=0,max=a.length-1,mid=(min+max)/2;
while(min<=max)
{
mid=(min+max)/2;
if(a[mid]<key)
{
max=mid-1;
}
else if(a[mid]>key)
{
min=mid+1;
}
else return mid;
}
return -1;
}
