排序算法

排序算法

1.冒泡排序

通过相邻元素的比较和交换，来吧小的数交换到最前面，这个过程类似水泡向上升

时间复杂度：O(n² )

void BubbleSort(int[] arr)
{
	if(arr==null||arr.length==0) return;
	for(int i=0;i<arr.length;i++)
	{
		for(int j=i+1;j<arr.length;j++)
		{
			if(arr[j]<arr[i])
			{
				int tmp=arr[i];
				arr[i]=arr[j];
				arr[j]=tmp;
			}
		}
	}
}

选择排序法

从当前无序区中选择一个最小的与无序区的第一个元素交换

时间复杂度：O(n² )

void SelectSort(int[] arr)
{
	if(arr==null||arr.length==0) return;
	for(int i=0;i<arr.length-1;i++)
	{
		int index=i;
		for(int j=i+1;j<arr.length;j++)
		{
			if(arr[j]<arr[index])
			{
				index=j;
			}
		}
		if(index!=i)
		{
			int tmp=arr[i];
			arr[i]=arr[j];
			arr[j]=tmp;
		}
	}
}

插入排序

将当前无序区的第一个元素插入到有序区中合适的位置

从第二个元素依次开始，比前面小就交换（有点像逆向冒泡）

时间复杂度：O(n² )

void InsertSort(int[] arr)
{
	if(arr==null||arr.length==0) return;
	for(int i=1;i<arr.length;i++)
	{
		target=arr[i];
		int j=i
		while(j>0&&target<arr[j-1])
		{
			arr[j]=arr[j-1];
			j--;
		}
		arr[j]=target;
	}
}

快速排序

在待排序的n个元素中任取一个元素（通常取第一个元素为基准），把该元素放入适当的位置后，数据序列被此元素划分成两部分，所有比该元素小的被放到前一部分，所有比它大的被放到后一部分，并将该元素排在这两部分中间。这个过程被称为一趟快速排序。之后对产生的这两部分分别重复上述过程，直至每部分内只有一个元素或为空为止。

时间复杂度：O(nLog(n))~O(n² )

int Partition(int[] arr,int left,int right)
{
	int tmp=arr[left];

	while(left<right)
	{
		while(left<right&&arr[right]>=tmp)
			right--;
		arr[left]=a[right];			//把小的移到左边
		while(left<right&&arr[left]<=tmp)
			left++;
		arr[right]=a[left];			//把大的移到右边
	}
	arr[left]=tmp;		//最后把tmp值赋值到中间
	return left;
}

void QuickSort(int[] arr,int left,int right)
{
	if(left>=right) return;

	int midPos=Partition(arr,left,right);
	Partition(arr,left,midPos-1);			//注意midPos-1
	Partition(arr,midPos+1,right);			//注意midPos+1
}

void Sort(int[] arr)
{
	if(arr==null||arr.length==0) return;

	QuickSort(arr,0,arr.length-1)		//注意arr.length-1
}

堆排序

堆排序是借助堆来实现的选择排序，思想同简单的选择排序，以下以大顶堆为例。注意：如果想升序排序就使用大顶堆，反之使用小顶堆。原因是堆顶元素需要交换到序列尾部。
大顶堆：每个节点的值都大于或等于其子节点的值，在堆排序算法中用于升序排列；
小顶堆：每个节点的值都小于或等于其子节点的值，在堆排序算法中用于降序排列；
　　首先，实现堆排序需要解决两个问题：
　　1. 如何由一个无序序列键成一个堆？
　　2. 如何在输出堆顶元素之后，调整剩余元素成为一个新的堆？
　　第一个问题，可以直接使用线性数组来表示一个堆，由初始的无序序列建成一个堆就需要自底向上从第一个非叶元素开始挨个调整成一个堆。
　　第二个问题，怎么调整成堆？首先是将堆顶元素和最后一个元素交换。然后比较当前堆顶元素的左右孩子节点，因为除了当前的堆顶元素，左右孩子堆均满足条件，这时需要选择当前堆顶元素与左右孩子节点的较大者（大顶堆）交换，直至叶子节点。我们称这个自堆顶自叶子的调整成为筛选。
　　从一个无序序列建堆的过程就是一个反复筛选的过程。若将此序列看成是一个完全二叉树，则最后一个非终端节点是n/2取底个元素，由此筛选即可。举个栗子：
49,38,65,97,76,13,27,49序列的堆排序建初始堆和调整的过程如下：

public class HeapSort {
    
    /**
     * 堆筛选，除了start之外，start~end均满足大顶堆的定义。
     * 调整之后start~end称为一个大顶堆。
     * @param arr 待调整数组
     * @param start 起始指针
     * @param end 结束指针
     */
    public static void heapAdjust(int[] arr, int start, int end) {
        int temp = arr[start];
        
        for(int i=2*start+1; i<=end; i*=2) {
            //左右孩子的节点分别为2*i+1,2*i+2
            
            //选择出左右孩子较小的下标
            if(i < end && arr[i] < arr[i+1]) {
                i ++; 
            }
            if(temp >= arr[i]) {
                break; //已经为大顶堆，=保持稳定性。
            }
            arr[start] = arr[i]; //将子节点上移
            start = i; //下一轮筛选
        }
        
        arr[start] = temp; //插入正确的位置
    }
    
    
    public static void heapSort(int[] arr) {
        if(arr == null || arr.length == 0)
            return ;
        
        //建立大顶堆
        for(int i=arr.length/2; i>=0; i--) {
            heapAdjust(arr, i, arr.length-1);
        }
        
        for(int i=arr.length-1; i>=0; i--) {
            swap(arr, 0, i);
            heapAdjust(arr, 0, i-1);
        }
        
    }
    
    public static void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
}