数据结构相关排序

---

                              数据结构排序梳理（面试后的决心）

       从前向后(或从后向前)依次比较相邻的元素，若发现逆顺序，则交换。小的向前换，大的向后换，像水底的气泡逐渐向上冒，顾名思义冒泡排序法。 通俗一点就是把大的往上挪！向冒泡一样。 缺点：冒泡排序法效率较低。

 

1. 冒泡排序
         从前向后(或从后向前)依次比较相邻的元素，若发现逆顺序，则交换。小的向前换，大的向后换，像水底的气泡逐渐向上冒，顾名思义冒泡排序法。
        
   缺点：冒泡排序法效率较低
       

        泡排序法思路

        外层循环：控制它要走几次。 
        假设你有5个数，那就要走4次，最后一次不用走，最后那个数已经在它位置了所以就要length-1次。 
        内层循环：控制逐一比较，如果发现前一个数比后一个数大，则交换。 
        注意！因为越比较长度就越小了，所以长度要length-1-i。

 

      

public static int[] BubbleSort(int[] a){
		for (int i = 0; i < a.length; i++) {
			for (int j = 0; j < a.length-i-1; j++) {
				if (a[j]>a[j+1]) {
					int temp = a[j];
					a[j] = a[j+1];
					a[j+1] = temp;
					
				}
			}
		}
		
		return a;
	}

     

 2.  快速排序

算法思路：

•     选排序数组基准，通常选数组第一个

public static void quickSort(int a[],int low,int high){
		int i,j,temp;
		if (low>high) {
			return ;
		}
		
		i = low;
		j = high;
		temp = a[low];
		
		while (i<j) {
			while (a[j]>=temp && i <j) {
				j--;
			}
			
			while (a[i]<=temp && i < j) {
				i++;
			}
			
			if (i<j) {
				int  t = a[i];
				a[i] = a[j];
				a[j] = t;
			}
		}
		
		a[low] = a[i];
		a[i] = temp;
		quickSort(a, low, j-1);
		quickSort(a, j+1, high);
		
	}

 

3. 选择排序

算法思路：对需排序数组进行遍历，次数为数组的长度。每次遍历去除最小值，最后成为有序数组。

public static void selectSort(int a[]){
		int minPoint = 0;
		int len = a.length;
		int temp;
		
		for (int i = 0; i < len-1; i++) {
			minPoint = i;
			int value = a[minPoint];
			for (int j = i+1; j <= len -1; j++) {
				if (a[j]<value) {
					minPoint = j;
					value = a[minPoint];
				}
			}
			
			if (minPoint != i) {
				temp = a[i];
				a[i] = a[minPoint];
				a[minPoint] = temp;
			}
		}
}

4. 直接插入排序

原理：

         1、将指针指向某个元素，假设该元素左侧的元素全部有序，将该元素抽取出来，然后按照从右往左的顺序分别与其左边的元素比较，遇到比其大的元素便将元素右移，直到找到比该元素小的元素或者找到最左面发现其左侧的元素都比它大，停止；

         2、此时会出现一个空位，将该元素放入到空位中，此时该元素左侧的元素都比它小，右侧的元素都比它大；

　　  3、指针向后移动一位，重复上述过程。每操作一轮，左侧有序元素都增加一个，右侧无序元素都减少一个。

public static void insertSort(int[] a){
		for (int i = 1; i < a.length; i++) {
			int temp = a[i];
			int leftIndex = i -1;
			while ( leftIndex >=0&& a[leftIndex] > temp ) {
				a[leftIndex+1] = a[leftIndex];
				leftIndex --;
			}
			
			a[leftIndex+1] = temp;
		}
	}