面试排序算法总结---java

1.冒泡排序

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

	}

	public static void main(String[] args) {
		int a[] = { 49, 38, 65, 97, 76, 13, 27, 49, 78, 34, 12, 64, 5, 4, 62, 99, 98, 54, 56, 17, 18, 23, 34, 15, 35,
				25, 53, 51 };
        bubbleSort(a);
		for (int i = 0; i < a.length; i++)
			System.out.println(a[i]);

	}

}

2.插入排序

public class insert{  //比喻成摸牌。从0开始但是手中的牌是拍好的
	
	 public static void insertSort(int[] a) {
	 
	 int length=a.length; //数组长度  
     int j;               //当前值的位置  
     int i;               //指向j前的位置  
     int key;             //当前要进行插入排序的值  
     //从数组的第二个位置开始遍历值  
     for(j=1;j<length;j++){  
         key=a[j];  
         i=j-1;  
         //a[i]比当前值大时，a[i]后移一位,空出i的位置，好让下一次循环的值后移  
         while(i>=0 && key<a[i]){  
             a[i+1]=a[i]; //将a[i]值后移  
             i--;         //i前移  
         }//跳出循环(找到要插入的中间位置或已遍历到0下标)  
         a[i+1]=key;    //将当前值插入  
     }  
 } 
	 
	 
	 public static void main(String[] args) {
		int[] array = { 3, -1, 0, -8, 2, 1 };
		ArrayUtils.printArray(array);
		insertSort(array);
		ArrayUtils.printArray(array);
	}
	
}

3.选择排序

package sort;

public class selectSort {

	 public static void SelectionSort(int a[]){
		   if (a == null || a.length <= 0) {  
	            return;  
	        }  
	        int min;
	        for (int j = 0; j < a.length-1; j++){
	            min = j;
	            for (int k = j+1; k < a.length; k++){
	                if (a[k] < a[min])
	                    min = k;
	            }
	            //swap(a[min], a[j]);
	            int temp ;
	    		temp = a[min];
	    		a[min] =a[j] ;
	    		a[j] = temp ;
	        }
	    }
	
	public static void main(String[] args) {
		int a[] = {1,32,4,6,7,2} ;
		SelectionSort(a);
		for (int i = 0; i < a.length; i++) {
			System.out.println(a[i]);
		}
	}
	
	
}

4.堆排序

package sort;
//堆是一种重要的数据结构，为一棵完全二叉树, 底层如果用数组存储数据的话，
//假设某个元素为序号为i(Java数组从0开始,i为0到n-1), 如果它有左子树，
//那么左子树的位置是2i+1，如果有右子树，右子树的位置是2i+2，如果有父节点，父节点的位置是(n-1)/2取整。
//分为最大堆和最小堆，最大堆的任意子树根节点不小于任意子结点，最小堆的根节点不大于任意子结点。
//所谓堆排序就是利用堆这种数据结构来对数组排序，我们使用的是最大堆。处理的思想和冒泡排序，选择排序非常的类似，一层层封顶，
//只是最大元素的选取使用了最大堆。最大堆的最大元素一定在第0位置，构建好堆之后，交换0位置元素与顶即可。堆排序为原位排序(空间小),
//且最坏运行时间是O(n2)，是渐进最优的比较排序算法。

//交换0位置元素与顶即可
//堆排序的大概步骤如下:
//
//1.构建最大堆。
//2.选择顶，并与第0位置元素交换
//3.由于步骤2的的交换可能破环了最大堆的性质，第0不再是最大元素，需要调用maxHeap调整堆(沉降法)，如果需要重复步骤2
//堆排序中最重要的算法就是maxHeap，该函数假设一个元素的两个子节点都满足最大堆的性质(左右子树都是最大堆)，
//只有跟元素可能违反最大堆性质，那么把该元素以及左右子节点的最大元素找出来，如果该元素已经最大，那么整棵树都是最大堆，
//程序退出，否则交换跟元素与最大元素的位置，继续调用maxHeap原最大元素所在的子树。该算法是分治法的典型应用。具体代码如下:



public class HeapSort2 {
	public static void main(String[] args) {
		int[] array = { 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, -1, -2, -3 };

		System.out.println("Before heap:");
		ArrayUtils.printArray(array);

		heapSort(array);

		System.out.println("After heap sort:");
		ArrayUtils.printArray(array);
	}

	public static void heapSort(int[] array) {
		if (array == null || array.length <= 1) {
			return;
		}

		buildMaxHeap(array);//构建最大堆，最大堆的任意子树根节点不小于任意子结点

		for (int i = array.length - 1; i >= 1; i--) {//倒叙输出为升序
			
			ArrayUtils.exchangeElements(array, 0, i);//最大数字在顶端0的位置，依次将大的值写入array,从i开始就是array最后一个

			maxHeap(array, i, 0);//重构
		}
	}

	private static void buildMaxHeap(int[] array) {//1.构建最大堆。
		if (array == null || array.length <= 1) {
			return;
		}

		int half = array.length;
		for (int i = half; i >= 0; i--) {
			maxHeap(array, array.length, i);
		}
	}

	private static void maxHeap(int[] array, int heapSize, int index) {//maxHeap调整堆(沉降法)
		int left = index * 2 + 1;
		int right = index * 2 + 2;

		int largest = index;
		if (left < heapSize && array[left] > array[index]) {//单课二叉树判断大小
			largest = left;
		}

		if (right < heapSize && array[right] > array[largest]) {//right < heapSize,left < heapSize排除最后一排
			largest = right;
		}

		if (index != largest) {
			ArrayUtils.exchangeElements(array, index, largest);

			maxHeap(array, heapSize, largest);//递归
		}
	}
}

5.快速排序

package sort;

public class quickSort2 {

	//快速排序
	static void quicksort(int s[], int l, int r)
	{
	    if (l < r)
	    {
			//Swap(s[l], s[(l + r) / 2]); //将中间的这个数和第一个数交换 参见注1有的书上是以中间的数作为基准数的，要实现这个方便非常方便，直接将中间的数和第一个数进行交换就可以了。
	        int i = l, j = r, x = s[l];//风之思想加+挖坑，左右岗哨
	        while (i < j)//数组大于2
	        {
	            while(i < j && s[j] >= x) // 从右向左找第一个小于x的数
					j--;  //没找到就继续指针向左
	            if(i < j) 
					s[i++] = s[j];//找到后坑里填进去，填进去另一侧
				
	            while(i < j && s[i] < x) // 从左向右找第一个大于等于x的数
					i++;   //没找到就继续指针向右
	            if(i < j) 
					s[j--] = s[i];
	        }
	        s[i] = x;//相遇为止第一个数基准填进来
	        quicksort(s, l, i - 1); // 递归调用 
	        quicksort(s, i + 1, r);
	    }
	}
	
	public static void main(String[] args) {
		int a[] = {1,3,4,6,7,4,9,3} ;
		quicksort(a,0,a.length-1);
		for (int i = 0; i < a.length; i++) {
			System.out.println(a[i]);
		}
		
	}

	
}

6.归并排序

package sort;

public class mergerSort2 {

static void merge(int arr[], int L, int M, int R) {//合并算法
    int LEFT_SIZE = M - L;//left array size
    int RIGHT_SIZE = R - M + 1;
//    int left[LEFT_SIZE];
//    int right[RIGHT_SIZE];
    int left[] = new int[LEFT_SIZE];
    int right[] = new int[RIGHT_SIZE];
    int i, j, k;
    
    // 1. Fill in the left sub array
    for (i=L; i<M; i++) {
        left[i-L] = arr[i];//sub array begin from 0
    }
    // 2. Fill in the right sub array
    for (i=M; i<=R; i++) {
        right[i-M] = arr[i];//sub array begin from 0
    }
    
    // 3. Merge into the original array
    i = 0;  j = 0;  k = L;//k point to the left array
    while (i < LEFT_SIZE && j < RIGHT_SIZE) {//没有到达子矩阵的顶端，这时比较左右矩阵如果左面小arr[k]位置放入左面值，即达到取晓得放入新的矩阵，i，j,k指针各自加上1
        if (left[i] < right[j]) {
            arr[k] = left[i];
            i++;
            k++;
        }
        else {
            arr[k] = right[j];
            j++;
            k++;
        }
    }
    
    while (i < LEFT_SIZE) {//一边到达了顶端，那么如果另一方还没到直接放入新矩阵
        arr[k] = left[i];
        i++;
        k++;
    }
    while (j < RIGHT_SIZE) {
        arr[k] = right[j];
        j++;
        k++;
    }
}

static void mergeSort(int arr[], int L, int R) {//分治+归并！！！！
    if (L == R) {//分支的结束为只有一个
        return;
    }
    else {
        int M = (L + R) / 2;
        mergeSort(arr, L, M);
        mergeSort(arr, M+1, R);
        merge(arr, L, M+1, R);
    }
}

public static void main(String[] args) 	
{
    int arr[] = {6, 8, 10, 9, 4, 5, 2, 7,3};
    int L = 0;
    int R = arr.length;
    mergeSort(arr, L, R);
    
    int i;
    for (i=0; i<=R; i++) {
        System.out.println(arr[i]);
    }
 }
	
}