死磕算法-排序

冒泡排序

冒泡排序的基本思想是对相领的元素进行两两比较，顺序相反则进行交换，这样一趟下来就能将最小或最大的元素浮到"顶端"，然后将待排序列分为两部分，一部分为有序序列，另一部分是无序序列，只对无序序列中元素进行两两比较。(关键字就是相邻两两比较)

public static void BubbleSort(int[] arr) {
		if(arr==null || arr.length<2)
			return;
		//数组中有多少个元素就进行多少趟
		for(int end=arr.length-1;end>0;end--) {
			//只对无序序列进行两两比较
			for(int i=0;i<end;i++) {
				if(arr[i]>arr[i+1])
					swap(arr,i,i+1);
			}
		}
	}

时间复杂度：
N为数组长度
(N-1)+(N-2)+(N-3)+…等差数列，之后去掉低阶项和系数，时间复杂度为O(N²⁾

---

选择排序

选择排序的基本思想是将待排序序列分为两部分，一部分为有序序列，另一部分是无序序列。第一趟：从a[0]到a[n-1]中找到最小的数a[i]，然后将a[i]与a[0]交换，第二趟：从a[1]到a[n-1]中找到最小的数a[j]，然后将a[j]与a[1]交换,第三趟：从a[2]到a[n-1]中找到最小的数a[k],然后将a[k]与a[2]交换 ……
实例分析：
arr= {2,4,3,7,9,1};
第一趟：1，{2,4,3,7,9}
第二趟：{1,2},{4,3,7,9}
第三趟：{1,2,3},{4,7,9}
…
最后{1,2,3,4,7,9}

public static void selectSort(int[] arr) {
		if(arr==null || arr.length<2)
			return ;
		for(int i=0;i<arr.length;i++) {
			int minindex=i;
			//找到无序序列中最小的
			for(int j=i+1;j<arr.length;j++) {
				minindex=arr[j]<arr[minindex]? j:minindex;
			}
			swap(arr,i,minindex);
		}
	}

时间复杂度
仍然是(N-1)+(N-2)+(N-3)+…等差数列，之后去掉低阶项和系数，时间复杂度为O(N²⁾

---

插入排序

插入排序的基本思想：

1. 默认第一个元素已经排好序
2. 从无序序列中取出第一个未排序的元素，在已经排好序的元素列表中从后往前扫描，逐一比较
3. 如果该元素小于已排序的元素，将该元素插入到下个位置
4. 重复步骤三，直到该元素大于有序序列中的元素

实例分析：
{2,4,3,7,9,1}
第一趟：2，{4,3,7,9,1} temp=4
temp大于2

第二趟：{2,4} {3,7,9,1} temp=3
temp小于4 temp大于2

第三趟：{2,3,4} {7,9,1} temp=7
tempd大于4
…

public static void insertSort(int[] arr) {
		if(arr==null || arr.length<2)
			return ;
		//从1开始，默认第0处为已排序
		for(int i=1;i<arr.length;i++) {
			//从有序序列的最后一个数开始，temp为无序序列的第一个数
			//直到遇到比temp大的数
			for(int j=i-1;j>=0 && arr[j]>arr[j+1];j--) {
				swap(arr,j,j+1);
			}
		}
	}

时间复杂度
选择排序和冒泡排序和数据状况无关，算法的时间复杂度是固定的；而插入排序的时间复杂度涉及到数据的具体情况。
实例分析：
如果数据一开始就是有序的，{1,2,3,4,5}
那么插入排序中第二个for循环实际上是不用执行的，时间复杂度为O(N)
如果数据一开始都是倒序的,{5,4,3,2,1}
时间复杂度是(N-1)+(N-2)+(N-3)+…等差数列，之后去掉低阶项和系数，时间复杂度为O(N^{2)
而时间复杂度一律按算法流程中最差数据下的指标，所以插入排序的时间复杂度还是为O(N2)}

---

归并排序

归并排序的基本思想就是采用经典的分治（divide-and-conquer）策略（分治法将问题分(divide)成一些小的问题然后递归求解，而治(conquer)的阶段则将分的阶段得到的各答案"修补"在一起，即分而治之)。

public static void mergeSort(int[] arr) {
		if (arr == null || arr.length < 2) {
			return;
		}
		mergeSort(arr, 0, arr.length - 1);
	}

public static void mergeSort(int[] arr, int l, int r) {
		if (l == r) {
			return;
		}
		int mid = l + ((r - l) >> 1);//L和R中点
		mergeSort(arr, l, mid);//T(N/2)
		mergeSort(arr, mid + 1, r);//T(N/2)
		merge(arr, l, mid, r);//O(N)
	}

//快排的方法排序两个数组
public static void merge(int[] arr, int l, int m, int r) {
		int[] help = new int[r - l + 1];
		int i = 0;
		int p1 = l;//左指针
		int p2 = m + 1;//右指针
		while (p1 <= m && p2 <= r) {
			help[i++] = arr[p1] < arr[p2] ? arr[p1++] : arr[p2++];
		}
		//未拷贝完的数组有且只有一个
		//将未拷贝完的内容复制完
		while (p1 <= m) {
			help[i++] = arr[p1++];
		}
		while (p2 <= r) {
			help[i++] = arr[p2++];
		}
		for (i = 0; i < help.length; i++) {
			arr[l + i] = help[i];
		}
	}

归并排序的时间复杂度：

根据Master公式(递归的实质和归并排序复杂度计算)为：O(N*logN)
空间复杂度为O(N),创建了help[N]大小内存

---

对数器

• 一个我们想测的方法a
• 实现一个绝对正确但是时间复杂度不好的方法b
• 实现一个样本随机发生器
• 实现比对的方法
• 如果有一个样本使得比对出错，打印出该样本
• 当样本数量很多比对测试一人正确，可以确定方法a正确

随机数组发生器

public static int[] genetrateRandomArray(int size,int value) {
		//生成长度随机在范围为[0,size]的数组
		int[] arr = new int[(int)((size+1)*Math.random())];
		for(int i=0;i<arr.length;i++) {
			//生成随机数值
			arr[i]=(int)((int)(value+1)*Math.random()-(int)(value-1*Math.random()));
		}
		return arr;
	}

1. Math.random() ->double[0,1}
2. (int)((size+1)*Math.random())->[0,size]整数
3. size=6，size+1=7
4. Math.random()->[0,1}*7–>[0,7}double
5. double[0,7}->int[0,6]

因此产生[0,size]长度的数组

绝对正确的方法

public static void rightMethod(int[] arr) {
		//调用系统提供的排序
		//虽然时间复杂度差，但是绝对正确
		Arrays.sort(arr);
	}

比对

public static boolean isEqual(int[] arr1,int[] arr2) {
		if((arr1==null && arr1!=null) || (arr1!=null && arr2!=null)) {
			return false;
		}
		if(arr1==null && arr2==null ) {
			return true;
		}
		if(arr1.length!=arr2.length) {
			return false;
		}
		for(int i=0;i<arr1.length;i++) {
			if(arr1[i]!=arr2[i])
				return false;
		}
		return true;
	}

测试方法

public static void main(String[] args) {
		//测试次数
		int testTime=5000;
		int size=10;
		int value=500;
		int[] arr2 = null;
		int[] arr3 = null;
		boolean succeed = true;
		for(int i=0;i<testTime;i++) {
			int arr1[] = genetrateRandomArray(size, value);
			//拷贝数组
			System.arraycopy(arr1, 0,arr2,0,arr1.length);
			System.arraycopy(arr1, 0,arr3,0,arr1.length);
			//方法执行
			BubbleSort(arr1);
			rightMethod(arr2);
			if(!isEqual(arr1, arr2)) {
				succeed=false;
				//测试比对出错，打印出错误样本
				for(int j=0;j<arr3.length;j++) {
					System.out.println(arr3[i]);
				}
				break;
			}
			System.out.println(succeed ?"succeed" :"error");
		}
	}