题目描述:
输入一个整数数组,实现一个函数调整数组中数字机的顺序,使得所有的奇数位于数组的前半部分,偶数位于后半部分,并保持奇数和奇数间,偶数与偶数间的相对位置。
实际是一道排序题,排序的依据是奇数<偶数,要求稳定
因此所有的稳定的排序算法都可以用在这个地方 递归分制,插排,冒泡法,桶排
class RecursiveSort{
public void sort(int[] array,int beg,int end){
//1. 将array分成有序的两部分
//2. 将有序的两部分组合起来
// if(beg>=end)
// return;
int mid = (beg + end) / 2;
dosort(array, beg, mid);
dosort(array, mid + 1, end);
merge(array, beg, mid, end);
}
void merge(int[] array,int beg,int mid,int end){
//将 beg-mid mid+1-end有序数组组合起立
int left_size=mid-beg+1;
int[] left=new int[left_size];
System.arraycopy(array, beg, left, 0, left_size);
int right_size=end-mid;
int[] right=new int[right_size];
System.arraycopy(array, mid+1, right, 0, right_size);
int i=0,j=0;
int count=beg; //开始初始为0 一直出错
while((i<left_size) && (j<right_size))
{
boolean isLfetOdd=(left[i]%2==1),isRightOdd=(right[j]%2==1);
if(isLfetOdd || (!isLfetOdd&&!isRightOdd))//left is odd
{
array[count++]=left[i++];
}else
array[count++]=right[j++];
}
while(i<left_size)
array[count++]=left[i++];
while(j<right_size)
array[count++]=right[j++];
}
}
class InsertSort{
public void sort(int[] array,int beg,int end){
//1. 从第二个元素开始,讲其与前面的元素比较 找到合适的插入位置
if(beg>=end)
return;
for(int i=beg+1;i<=end;++i)
{
int temp=array[i];
if(temp%2==1) //temp是奇数
{
int j=i-1;
while(j>=0 && array[j]%2==0) //array[j]为偶数
{
array[j+1]=array[j];
j--;
}
array[j+1]=temp;
}
}
}
}
class BubbletSort{
public void sort(int[] array,int beg,int end){
if(beg >= end)
return;
for(int i=beg;i<end;++i)
{
boolean changed=false;
for(int j=end;j>i;--j)
{
if(array[j]%2==1 && array[j-1]%2==0) //array[j] is odd array[j-1] is even
{
changed=true;
int temp=array[j];
array[j]=array[j-1];
array[j-1]=temp;
}
}
if(!changed)
return;
}
}
}
还有桶排序
import java.util.Arrays;
public class BucketSort {
//桶排
//1. 预先知道要排序的范围[0,m]
//2. 记录每一个桶中元素出现的次数
//3. 从头向后累加
//4. 对array从后往前 插入和合适的位置
public void sort(int[] array,int max)
{
Test.print(array);
int[] bucket=new int[max+1];
//Test.print(bucket);
for(int i : array)
{
if(i%2==1)
bucket[0]++;
else
bucket[1]++;
}
//Test.print(bucket);
for(int i=1;i<bucket.length;++i)
{
bucket[i]+=bucket[i-1];
}
//Test.print(bucket);
int []temp=Arrays.copyOf(array, array.length);
for(int i=temp.length-1;i>=0;--i)
{
if(temp[i]%2==1)
array[--bucket[0]]=temp[i];
else
array[--bucket[1]]=temp[i];
}
Test.print(array);
}
public static void main(String [] args)
{
int[] array=RandNums.getIntArrays(20,0,20);
BucketSort bs=new BucketSort();
int max=2;
bs.sort(array,max);
}
}
最后总结一下:
排序排的是什么?
序可以自己定义,正如c++中向有序容器中插入元素需要制定元素间的比较操作一样,制定序是需要满足几个关系:
1. 对称性 如果a <b为true,则b<a为false,反之亦然
2. 传递性 a < b , b < c => a < c
3. 自反性 没有弄明白 在想想 如何通过小于关系判断等于关系??