冒泡、简单选择、插入、递归排序

一、冒泡排序

        冒泡排序是众多排序方法中非常经典、简单的排序。

1.流程

        冒泡排序的流程非常简单。整个算法需要两个嵌套关系的for循环。时间复杂度O(n^2)

        以升序排序为例：

int[] arr= new int[]{6,3,5,9,8,7,4,1,2};

从第一个元素开始，6与他的下一个元素3进行比较，升序数组中大数放在后边，把6与3交换。接下来，

第二个元素变成6，与5比较，交换。

第三个元素变成6，与9比较，无操作。

第四个元素9，与8比较，交换。

经过以上循环，9这个数组里最大的数字，到了最后一位。

同样的操作，重复下去，最后排序完毕。

2.代码实现

int tem,sign = 0;
		for (int i = 0; i<arr.length ; i++)
		{
			for (int j=0 ;j<arr.length-1-i;j++)
			{
				if (arr[j]>arr[j+1]) {
					tem=arr[j];
					arr[j]=arr[j+1];
					arr[j+1] =tem;
					sign = 1;
				}
			}
			if (sign==0)
				break;
			sign = 0;
		}
		System.out.println(Arrays.toString(arr));
	}

---

二、简单选择排序

1.流程

        选择数组里的最小元素，放到数组的第 1 位；再从剩下的元素中找到最小值，放到第 2 位；依此类推。直接这样做，会导致原第 1 位，和第 2 位上的元素被覆盖，所以采用交换的方法。举例如下：

int[] arr= new int[]{6,3,5,9,8,7,4,1,2};

通过循环，找到最小元素 1 ，与第一位上的6 进行交换；

然后忽略 arr[0] ，寻找从 arr[1] 开始后面的最小值 2 ，与第二位上的3 进行交换。以此类推。

2.代码实现

    int min , minIndex,temp;
		for (int i=0 ; i<arr.length;i++) {
			min=arr[i];
			minIndex=i;
			for (int j = i+1; j<arr.length;j++) {
				if (arr[j]<min) {
					min=arr[j];
					minIndex=j;
				}
			}
			temp=arr[i];
			arr[i]=arr[minIndex];
			arr[minIndex]=temp;	
		}
		System.out.println(Arrays.toString(arr));

---

三、插入排序

1.流程

        要注意插入排序的开始是数组的第 2 个元素，也就是下标是 1  的位置开始。

        话不多说，直接看例子：

int[] arr= new int[]{6,3,5,9,8,7,4,1,2};

从 3 开始，3 和前面的 6 比较，升序排序，6 应该在后面，于是3、6交换

{3,6,5,9,8,7,4,1,2};

5 和前面的 6 比较，交换；

直到下面这一情况：此时应当给 7 排序

[3, 5, 6, 8, 9, 7, 4, 1, 2]

肉眼所见，7 应该放在 8 的前面。所以我们要做的操作，不仅仅是要与前一个元素比较，而是与前面所有元素比较，找到合适的位置，插入元素。这样的排序方法，可以保证每一个元素插入之前和之后，前面的部分都是有序的。

现在，插入元素的方法就是关键了。

以上面的 7 的排序为例。

首先 设置一个变量 temp=arr[5] 即 7 。

然后 从后向前依次与 7 比较，9 大于 7 ，放在 7的位置上，将其覆盖。

8 放在原来 9 的位置，覆盖原来的 9。

temp 放在原来 8 的位置，ok。

2.代码实现

int j = 0;
		for (int i = 1; i<arr.length;i++) {
			int temp = arr[i];
			for (j=i-1;j>=0;j--) {
				if (arr[j]>temp) {
					arr[j+1] = arr[j];
				}else {break;}
			}
			arr[j+1]  = temp;
		}
		System.out.println(Arrays.toString(arr));

---

四、递归排序

        我们首先来看递归，递归是一种函数调用自身的方法。

        下面是一段简单的递归代码，输入为 n ,输出为 n

public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		System.out.print("请输入n：");
		int n = in.nextInt();
		System.out.println(recursion(n));
	}
	public static int recursion(int n) {
		if (n==1) {
			return 1;
		}
			return recursion(n-1)+1;
		
	}

1.流程

        在数组里选择一个元素作为基准数，取第一个元素即可。在数组的左右两端同时检索；同时我们设置 i , j 两个变量记录被检索元素的下标。

左端检索到大于基准数的元素时停止；

右端检索到小于基准数的元素时停止；

两元素交换；重复，直到 i >= j ；

        （这样可以使比基准数大的元素在数组的右部分，比基准数小的元素在数组的左部分。）

然后将基准数 与此时 i 或 j 位置上的元素互换，达成以基准数为界，左边小，右边大。

2.代码实现

public static void main(String[] args) {
	int[] arr= new int[]{6,3,5,9,8,7,4,1,2};
    System.out.println(Arrays.toString(fast(arr,0,arr.length-1)));
}
public static int[] fast(int arr[],int left,int right) {
	if (left>=right) {
		return arr;
	}
	int i = left;
	int j = right;
	int base = arr[left];
    while(i!=j) {
		while(arr[j]>= base && i<j) {
			j--;
		}
		while(arr[i]<=base && i<j) {
			i++;
		}
		int temp = arr[i];
		arr[i] = arr[j];
		arr[j] = temp;
        //这里在完成交换之后 arr[j]>=base,arr[i]<=base, 上边的可以继续循环。
        //最后 j 的前移 会使 j == i ;  
	}
	arr[left] = arr[i];
	arr[i] = base;

	fast(arr, left , i-1);
	fast(arr, i+1 , right);
	return arr;
}