数组常见排序

                            数组常见排序

      数组排序有许多种，如冒泡排序，快速排序，选择排序，插入排序等

      也有java本身的方法，如sort()方法，TreeSet也可以排序，但是它会把相同的排除

     数组排序
        冒泡排序 （两两比较然后交换值，把大的数往后排）

		int[] arr = { 214, 31, 145, 7765, 222, 446, 22, 44 };
		for (int k : arr) {
			System.out.print(k + " ");
		}
		System.out.println();
		for (int i = 1; i < arr.length; i++) {
			// 把一次中的最大值给移除下一次排序
			for (int j = 0; j < arr.length - i; j++) {
				if (arr[j] > arr[j + 1]) {
					// 交换两个值
					int temp = arr[j + 1];
					arr[j + 1] = arr[j];
					arr[j] = temp;
				}
			}
			System.out.print("第" + i + "次遍历结果：");
			for (int k : arr) {
				System.out.print(k + " ");
			}
			System.out.println();
		}

  选择排序   （找到一次遍历中的最小值的位置，与遍历中的第一个交换值）

	int[] arr = { 214, 31, 145, 7765, 222, 446, 22, 44 };
		for (int k : arr) {
			System.out.print(k + " ");
		}
		System.out.println();
		for (int i = 0; i < arr.length; i++) {
			int index = i;
			for (int j = i; j < arr.length; j++) {
				if(arr[index]>arr[j])index = j;
			}
			if(index != i){
				int temp = arr[i];
				arr[i] = arr[index];
				arr[index] = temp;
			}
			System.out.print("第"+(i+1)+"次选择排序结果:");
			for (int k : arr) {
				System.out.print(k + " ");
			}
			System.out.println();
		}

  快速排序   （取数组中的一个key值，遍历数组把数组分为大于key，和小于key的两组）

（快速排序不稳定）

package array;

public class QuickSort {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		int[] arr = { 14, 6, 845, 546, 77, 797, 45, 67, 9, 2 ,87};
		quickSort(arr, 0, arr.length-1);
                System.out.println();
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i]+" ");
		}
	}

	public static void quickSort(int[] arr, int left, int right) {
		int key, temp;
		int lefttemp = left, righttemp = right;
		key = arr[(left + right) / 2];//设置key为数组的中间

	//把小于key的放在左边，大于等于放在右边，只是分成两边，两边没有排序
		while (lefttemp < righttemp) {
			while (arr[lefttemp] < key) {
			     //从左边找到第一个大于等于的数组下标，跳出循环

    				++lefttemp;
			}
			while (arr[righttemp] > key) {
				--righttemp;//从右边找到第一个小于等于的数组下标，跳出循环
			}
			//把刚才找到的左边的数组元素和右边找到的数组元素交换值
			if (lefttemp <= righttemp) {
				temp = arr[lefttemp];
				arr[lefttemp] = arr[righttemp];
				arr[righttemp] = temp;
				//继续循环
				--righttemp;
				++lefttemp;
			}
		}
		
	//改变lefttemp的值，确保下一次把刚才的key加入进去计算防止少算了
		if (lefttemp == righttemp) {
			lefttemp++;
		}
			System.out.println();
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i]+" ");
		}
		if(left<righttemp){

 			//把左边的进行快数排序
			quickSort(arr, left, lefttemp-1);
		}
		if(lefttemp <right){

			//把右边的进行快数排序
			quickSort(arr, righttemp+1, right);
		}
	}

}

   
  插入排序 （在前两个数组元素有序的数组中，那第三个数组元素和前两数比较，

然后插入其中。第四个元素与前三个数比较，以此类推）
    一种方法

        public static int[] insertSort(int[] a) {

		int i, j, temp;
		for (i = 1; i < a.length; i++) {
			temp = a[i];// 保存插入的值
			j = i - 1;// j = 0 1 2 ...
			// 把大于它的数组元素往后移动一位，小于就退出循环
			while (j >= 0 && temp < a[j]) {
				a[j + 1] = a[j];
				j--;
			}
			// 填充空出的位置
			a[j + 1] = temp;
		}
		return a;//返回一个数组
	}

       第二种方法

int[] arr = { 14, 6, 845, 546, 77, 797, 45, 67, 9, 2 };
		 System.out.print("第1次插入排序：");
		 for (int i : arr) {
		 System.out.print(i + " ");
		 }
		 System.out.println();
		if (arr[0] > arr[1]) {// 把前两个数排序
			int temp = arr[0];
			arr[0] = arr[1];
			arr[1] = temp;
		}
		for (int i = 2; i < arr.length; i++) {
			int index = i;// 定义下标变量
			for (int j = 0; j <= i; j++) {
				if (arr[i] < arr[j]) {
					index = j;// 找到第一个大于它的数，找到下标
					break;// 然后退出循环
				}
			}
			if (index != i) {// 判断是否当前插入的数是排序中最大的数
				int temp1 = arr[i];// 把保存插入的数
				// 把大于等于下标的数组往后移动一位
				for (int j = i; j > index; j--) {
					arr[j] = arr[j - 1];
				}
				arr[index] = temp1;// 填充空出的数组就是把指定的数插入指定位置
			}
			 System.out.print("第"+i+"次插入排序");
			 for (int k : arr) {
			 System.out.print(k+ " ");
			 }
			 System.out.println();
		}

结果效果图