数组的排序算法

1.冒泡法：对比相邻的元素值，如果满足条件就交换元素值，把较小的元素移动到数组前面，把大的元素移动到数组后面（即交换元素的位置）。

public class BubbleSort {
	public static void main(String[] args) {
		int[] array = new int[] {63,4,24,13,26,87};
		
		for(int i=0; i<array.length; i++) {
			for(int j=0;j<array.length-i-1;j++) {
				if(array[j]>array[j+1]) {
					int temp = array[j];
					array[j] = array[j+1];
					array[j+1] = temp;
				}
			}
		}
		for(int i : array) {
			System.out.print(i +" ");
		}
	}
}

 

2.选择排序法：每一趟从待排序的数据元素中选出最小（最大）的一个元素，放在已排好序的数列的最后（最前），直到全部待排序的数据元素排完。

public class SelectSort {
	public static void main(String[] args) {
		//数组的初始化
		int[] array = new int[] {1,23,56,75,45,89,99};
		//设置结尾字符拼接
		String end = "";
		int index;
		for(int i = 1; i < array.length; i++) {
			index = 0;
			for(int j = 1; j<= array.length - i; j++) {
				//比较大小 找出最大
				if(array[j] > array[index]) {
					index = j;
				}
			}
			end = array[index]+" "+end;
			//元素值交换  交换位置array.length - i 和 index
			//这里是为了避免最大值不在最后一个index处，交换位置做到在数组中真正的交换
			int temp = array[array.length-i];
			array[array.length-i] = array[index];
			array[index] = temp;
			//可以打印出还未排序的数组
			System.out.print("[");
			for(int j=0; j<array.length-i; j++) {
				System.out.print(array[j]+" ");
			}
			System.out.println("]"+end);
		}
		System.out.print("排好序的数组：");
		for(int i : array) {
			System.out.print(i+" ");
		}
	}
}

 

3.直接插入排序法：将n个有序数存放在数组a中，要插入的数为x，首先确定x插在数组中的位置p，数组中p之后的元素都向后移动一个位置，空出a(p),j将x放入a(p).

public class InsertSort {
	public static void main(String[] args) {
		//数组的初始化
		int[] array = new int[] {33,23,56,1,75,45,89,99};
		System.out.println("排序前：");
		for(int i : array) {
			System.out.print(i+" ");
		}
		//临时变量
		int temp;
		int j;
		//选定j后一个元素为temp，无论是否发生j与j+1的交换 都要执行temp赋值给j+1的操作
		for(int i=1; i<array.length; i++) {
			temp = array[i];//保存临时变量
			for(j=i-1;j>=0&&array[j]>temp;j--) {
				array[j+1] = array[j];
			}
			array[j+1] = temp;
		}
		System.out.println("\n排序后：");
		for(int i : array) {
			System.out.print(i+" ");
		}
	}
}

与相邻的相比，逐渐向前排序。保持临时变量位置不变，则可以一直排序，直到此循环之后数组有序为止。

 

4.快速排序：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分数的所有数据都比另外一部分的所有数据要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此使整个数据编程有序序列

public class QuickTest {
	public static void main(String[] args) {
		int[] array = new int[] {1,23,5,78,98,67,34};
		QuickSort(array, 0, array.length - 1);
        for (int i : array) {
            System.out.print(i + " ");
        }
	}
	//初步排序
	public static int FirstSort(int arr[],int low, int high) {
		//low处的值定义data
		int status= arr[low];
		while(low < high) {
			//从后往前 找一个比data小的值
			while(low<high && arr[high]>=status) {
				high--;
			}
			arr[low] = arr[high];
			//从前往后 找一个比data大的值
			while(low<high && arr[low]<=status) {
				low++;
			}
			arr[high] = arr[low];
		}
		arr[low] = status;
		return low;
	}
	
	public static void QuickSort(int arr[],int low, int high) {
		if(low < high) {
			int index = FirstSort(arr, low, high);
			QuickSort(arr,low, index-1);
			QuickSort(arr,index+1,high);
		}
	}
}

快速排序的主要思想就是前后找两个端点，前面端点设定为i，后面端点设置为j，从j开始寻找大于status的点

例如 1 23 5 78 98 67 34 

第一次从34开始，从右往左寻找，发现只有原始状态1，第一次查找结束，因为从左往右第一次查找两人就碰面，结束

第二次从34开始，此时的初始值为23，从右往左寻找，发现5比23要小，而从左往右出来就碰面，所以5和23交换位置

此时为 1 5 23 78 98 67 34 ，可知道23之前比23小与23之后都比23大

第三次（之前还是要从23开始，不过23开始对结果没有影响）寻找从78开始，从右往左34满足，从左往右98满足，此时交换，数组为1 5 23 78 34 67 98，循环未结束，继续寻找，从右往左67满足，从左往右两人在67处碰面，交换67与78，此时1 5 23 67 34 78 98

第四次从67开始，从右往左，发现只有34符合，而且从左往右，出来就碰面，直接交换34和67.结束循环

结果 1 5 23 34 67 78 98结束