排序算法

排序算法

---

排序的定义

• 对一序列对象根据某个关键字排序

术语

• 稳定：如果a原本在b前面，a=b，排序之后a仍然在b前面。
• 不稳定：如果a原本在b前面，a=b，排序之后a可能在b后面。
• 时间复杂度：描述算法运行的时间的函数，用O符号表述。
• 空间复杂度：算法所需要的空间。

1、冒泡排序

• 比较相邻的元素。如果第一个比第二个大，就交换它们两个.

• 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数.

• 针对所有的元素重复以上的步骤，除了最后一个.

• 重复步骤1~3，直到排序完成.

  • public static int[] bubbleSort(int[] array){
        if(arrar.length>0){
            if(int i = 0;i<array.length;i++){
                for(int j = 0;j<array.length-1-i;j++){
                    if(array[j]>array[j+1]){
                        int t = array[j];
                        array[j] = array[j+1];
                        array[j+1] = t;
                    }
                }
            }
        }
        return array;
    }
    

2、选择排序

• 首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。

  • public static int[] selectionSort(int[] array){
        if(arrar.length>0){
            for(int i = 0;i<array.length;i++){
                int minIndex = i;
                for(int j = i;j<array.length;j++){
                    if(array[j]>arr[minIndex]){
                        minIndex = j;
                    }
                }
                if(minIndex!=i){
                    int t = array[minIndex];
                    arr[minIndex] = array[i];
                    array[i] = t;
                }
            }
        }
        return array;
    }
    

3、插入排序

• 从第一个元素开始，该元素可以认为已经被排序；

• 取出下一个元素，在已经排序的元素序列中从后向前扫描；

• 如果该元素（已排序）大于新元素，将该元素移到下一位置；

• 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；

• 将新元素插入到该位置后；

• 重复步骤2~5。

  • 
    	public static int[] insertSort(int[] array){
    		if(array.length > 0){			
    			for(int i = 0 ;i<array.length - 1;i++){
    				int current = array[i+1];
    				int index = i;
    				while(index >= 0 && current < array[index]){
    					array[index + 1] = array[index]; 
    					index--;
    				}
    				array[index+1] = current;
    			}
    			
    		}
    		return array;
    	}
    

4、归并排序

• 把长度为n的输入序列分成两个长度为n/2的子序列；

• 对这两个子序列分别采用归并排序；

• 将两个排序好的子序列合并成一个最终的排序序列。

  • public static int[] MergeSort(int[] array){
    		if(array.length < 2){
    			return array;
    		}
    		int mid = array.length /2;
    		int[] left = Arrays.copyOfRange(array, 0, mid);
    		int[] right = Arrays.copyOfRange(array, mid, array.length);
    		return merge(MergeSort(left),MergeSort(right));	
    	}
    	
    	public static int[] merge(int[] left,int[] right){
    		int[] result = new int[left.length + right.length];
    		for(int index = 0,i = 0, j = 0;index < result.length;index++){
    			if(i >= left.length){
    				result[index] = right[j++];
    			}else if(j >= right.length){
    				result[index] = left[i++];
    			}else if(left[i] > right[j]){
    				result[index] = right[j++];
    			}else{
    				result[index] = left[i++];
    			}
    		}
    		return result;
    		
    	}
     
    

5、快速排序

• 从数列中挑出一个元素，称为 “基准”（pivot）；

• 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；

• 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。

  • public static void QuickSort(int[] array,int low,int hight){
    		//if (array.length < 1 || low < 0 || hight >= array.length || low > hight) return null;
    		if(low < hight){
    			int privotpos = partition(array,low,hight);
    			QuickSort(array,low,privotpos - 1);
    			QuickSort(array,privotpos + 1,hight);			
    		}
    	
    	}
    	
    	public static int partition(int[] array,int low,int hight){
    		int privot = array[low];
    		while(low < hight){
    			while(low < hight && array[hight] >= privot) --hight;
    			array[low] = array[hight];
    			while(low < hight && array[low] <= privot) ++low;
    			array[hight] = array[low];
    		}
    		array[low] = privot;
    		return low;			
    }
    

y[hight];
while(low < hight && array[low] <= privot) ++low;
array[hight] = array[low];
}
array[low] = privot;
return low;
}
```