[c++]一道算法题的思考

题目描述：

输入一个整数数组，实现一个函数调整数组中数字机的顺序，使得所有的奇数位于数组的前半部分，偶数位于后半部分，并保持奇数和奇数间，偶数与偶数间的相对位置。

实际是一道排序题，排序的依据是奇数<偶数，要求稳定

因此所有的稳定的排序算法都可以用在这个地方 递归分制，插排，冒泡法，桶排

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. 自反性 没有弄明白 在想想  如何通过小于关系判断等于关系??