蓝桥29-3...

题4

搞清楚数据的一个结构就很好算计每个序列的长度了

优化效率

计算a的n次方，采取跳步，没次对a平方，即对a的指数进行翻2倍来进行计算，优化了效率

排序

分治法

分解问题，缩小了问题的规模，而小规模的问题的合并是简单的话，这优化了算法的性能。
（当合并都是简单的，问题每一次缩小的规模越大，算法性能的提升也就越大。）
左边是空集，右边是一个有元素的集合，也算是合并。

快速排序：重在划分
合并排序：重在合并

快速排序

单向是只用以一边用来查找，双向是两边同时找到大于小于的来交换位置，三指针是对于重复元素多的数组效率更高些。

起码需要两个指针

三指针

package 蓝桥29课;

public class Kspxu {
	public static void main(String[] args) {
		int d[]=new int[1000];
		for(int i=0;i<1000;i++) {
			
			d[i]=i;
			if(i%2==0) d[i]+=3;
		}
		for(int i=0;i<d.length;i++)
			System.out.print(d[i]+" ");
		System.out.print("\n");
		//int d[]= {23,555,8,6,684,4,33,6,555,2321};
		kspx(d,0,d.length-1);
		for(int i=0;i<d.length;i++)
		System.out.print(d[i]+" ");
	}
	static void kspx(int arr[],int start,int end) {
		//if(arr.length==1) 这种是错误的，因为arr不变，逻辑上的length其实是与start和end有关
		if(start>=end) return;
		int p=A(arr,start,end);
		kspx(arr,start,p-1);
		kspx(arr,p+1,end);
		
		
		
	}

	private static int A(int[] arr, int start, int end) {
		
		// TODO 自动生成的方法存根
		int pa=start+1;
		int b=end;
		while(pa<b) {//这里不用用等号 等时没必要再比较交换操作了，也会出现死循环
		while(pa<end&&arr[pa]<arr[start]) pa++;
		while(b>start&&arr[b]>=arr[start]) b--;
		//if(start<end) //错在这，想想这里是比较指针，为什么会犯这样的错误。
		if(pa<b)
		swap(arr,pa,b);
		}
		swap(arr,b,start);
		return b;	
				}

	private static void swap(int[] arr, int p, int b) {
		// TODO 自动生成的方法存根
		int z=0;
		z=arr[p];
		arr[p]=arr[b];
		arr[b]=z;
	}
}

时间复杂度
理想的情况是，每次划分所选择的中间数恰好将当前序列几乎等分，经过log2n趟划分，便可得到长度为1的子表。这样，整个算法的时间复杂度为O(nlog2n)。 [4]
最坏的情况是，每次所选的中间数是当前序列中的最大或最小元素，这使得每次划分所得的子表中一个为空表，另一子表的长度为原表的长度-1。这样，长度为n的数据表的快速排序需要经过n趟划分，使得整个排序算法的时间复杂度为O(n2)。

归并排序

package 蓝桥29课;

public class Gbpx {
	static int brr[];
	
	public static void  main(String [] args) {
		int arr[]= {12,56,56,8,894,465,59,21,13};
		 brr=new int[arr.length];//不要b[]
	gbpx(arr,0,arr.length-1);//传错参数，忘减去1
	for(int i=0;i<arr.length;i++)
	System.out.print(arr[i]+" ");
	
	}
	static void gbpx(int arr[],int start,int end) {
		if(end>start) {
		int midindex =start+((end-start)>>1);//注意这里的括号
		 
		gbpx(arr,start,midindex);
		gbpx(arr,midindex+1,end);
		hb(arr,start,end);
	}}

	private static void hb(int[] arr, int start, int end) {
		// TODO 自动生成的方法存根
		int twoarrindex=(start+((end-start)>>1))+1;
		int a=start;
		int b=twoarrindex;
		
		System.arraycopy(arr, start, brr, start, end-start+1);
		//for(int i=0;i<arr.length;i++) {//传进来的数组究竟是谁。还是边界问题
		for(int i=start;i<=end;i++){//这里，i不是0，老犯这种错误。*指针问题*，加1是加第一个元素算进来
			if(a<=twoarrindex-1&b<=end) {
			if(brr[a]<brr[b]) {arr[i]=brr[a]; a++;}//边界问题要考虑全面,先走完的那组最后一个元素不是比没走完的都大，想错了
			else {arr[i]=brr[b]; b++;}}
			else { if(a>twoarrindex-1) break;
			else while(a<=twoarrindex-1) {
				arr[i]=brr[a];i++;a++;
			}}
				
			
		
		}}
		
	}

一些题
水王（大于一半）：消除法

等于一半

分析情况，其实也就是边界

最小可用id

我的想法是
这里midIndex不加1，因为加1会越出去，但是我没有考虑到越出去又会回来的情况，我觉得他这个边界找的比较好，

对归并排序的一些变形，第二道题深刻理解了归并的运算过程，之前先调用的递归，只是在他们内部换了位置，并不影响后面的递归的计数。