八大排序算法二分查找

Posted 2020-07-26 zhaoshuzhan

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

import org.junit.Test;

public class InsertSort {
public static void display(int[] arr){
System.out.print("[");
for(int i=0;i<arr.length;i++){
if(i == arr.length-1){
System.out.print(arr[i]);
}else{
System.out.print(arr[i]+",");
}
}
System.out.print("]");

}
/**
* 直接插入排序
* 原理：
* 在要排序的一组数中，假设前面(n-1)[n>=2] 个数已经是排 好顺序的，
* 现在要把第n 个数插到前面的有序数中，使得这 n个数 也是排好顺序的。
* 如此反复循环，直到全部排好顺序。
*/
public void insertSort1(int[] arr){
if(arr.length<2 || arr == null){
return;
}
for(int i=1;i<arr.length;i++){
int current = arr[i];
int position = i;
for(int j=i-1;j>=0;j--){
if(arr[j]>arr[j+1]){
arr[j+1] = arr[j];
position -=1;
}else{
break;
}
arr[position] = current;
}
}

}
//测试插入排序
@Test
public void testInsertSort(){
int[] arr = {4,9,5,2,8,6,1};
display(arr);
System.out.println();
insertSort1(arr);
display(arr);
}
/*
* 希尔排序（最小增量排序）
* 算法先将要排序的一组数按某个增量 d（n/2,n为要排序数的个数）分成若干组，
* 每组中记录的下标相差 d.对每组中全部元素进行直接插入排序，然后再用一个较小的增量（d/2）对它进行分组，
* 在每组中再进行直接插入排序。当增量减到 1 时，进行直接插入排序后，排序完成。
*/
public void ShellSort(int[] arr){
int h = 1;
while(h<arr.length/3){
h = h*3 +1;
}
while(h> 0){
int temp = 0;
for(int i=h;i<arr.length;i++){
temp = arr[i];
int j = i;
while(j>h-1 && arr[j-h]>= temp){
arr[j] = arr[j-h];
j -= h;
}
arr[j]= temp;
}
h = (h-1)/3;
}
}

//测试希尔排序
@Test
public void testShellSort(){
int[] arr={1,54,6,3,78,34,12,45,56,100};
ShellSort(arr);
display(arr);
}

/**
* 简单选择排序
* 基本思想：在要排序的一组数中，选出最小的一个数与第一个位置的数交换；
* 然后在剩下的数当中再找最小的与第二个位置的数交换，如此循环到倒数第二个数和最后一个数比较为止。
*/
public void SelectSort(int[] arr){
int k = 0;
int temp = 0;
for(int i=0;i<arr.length-1;i++){
k = i;
for(int j=i;j<arr.length;j++){
if(arr[j]<arr[k]){
k = j;
}
}
temp = arr[i];
arr[i] = arr[k];
arr[k] = temp;
}
}

//测试简单排序
@Test
public void testSelectSort(){
int[] arr={1,54,6,3,78,34,12,45,56,100};
SelectSort(arr);
display(arr);
}
/**
* 堆排序
* 堆排序是一种树形选择排序，是对直接选择排序的有效改进。
* 堆的定义如下：具有n个元素的序列（h1,h2,...,hn),当且仅当满足（hi>=h2i,hi>=2i+1）
* 或（hi<=h2i,hi<=2i+1）(i=1,2,...,n/2)时称之为堆。在这里只讨论满足前者条件的堆。
* 由堆的定义可以看出，堆顶元素（即第一个元素）必为最大项（大顶堆）。
* 完全二叉树可以很直观地表示堆的结构。堆顶为根，其它为左子树、右子树。
* 初始时把要排序的数的序列看作是一棵顺序存储的二叉树，调整它们的存储序，使之成为一个堆，这时堆的根节点的数最大。
* 然后将根节点与堆的最后一个节点交换。然后对前面(n-1)个数重新调整使之成为堆。
* 依此类推，直到只有两个节点的堆，并对它们作交换，最后得到有 n个节点的有序序列。
* 从算法描述来看，堆排序需要两个过程，一是建立堆，二是堆顶与堆的最后一个元素交换位置。
* 所以堆排序有两个函数组成。一是建堆的渗透函数，二是反复调用渗透函数实现排序的函数。
*/
public void HeapSort(int[] arr){
System.out.println("开始排序");
int length = arr.length;
for(int i=0;i<length-1;i++){
buildMaxHeap(arr,length-1-i);
swap(arr,0,length-1-i);
display(arr);
System.out.println();

}
}
private void swap(int[] arr, int i, int j) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;

}
private void buildMaxHeap(int[] arr, int lastIndex) {
for(int i=(lastIndex-1)/2;i>=0;i--){
int k=i;
while(k*2+1<=lastIndex){
int biggerIndex = 2*k+1;
if(biggerIndex<lastIndex){
if(arr[biggerIndex]<arr[biggerIndex+1]){
biggerIndex++;
}
}
if(arr[k]<arr[biggerIndex]){
swap(arr,k,biggerIndex);
k=biggerIndex;
}else{
break;
}
}
}

}
//测试
@Test
public void testHeap(){
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};
display(a);
HeapSort(a);
System.out.println();
display(a);
}
/**
* 冒泡排序
* 在要排序的一组数中，对当前还未排好序的范围内的全部数，
* 自上而下对相邻的两个数依次进行比较和调整，让较大的数往下沉，
* 较小的往上冒。即：每当两相邻的数比较后发现它们的排序与排序要求相反时，
* 就将它们互换。
*/
public void bubbleSort(int[] arr){
for(int i=0;i<arr.length-1;i++){
for(int j=arr.length-1;j>i;j--){
if(arr[j]<arr[j-1]){
int temp = arr[j];
arr[j] = arr[j-1];
arr[j-1] = temp;
}
}
}
}

//测试冒泡排序
@Test
public void testbubbleSort(){
int[] arr={1,54,6,3,78,34,12,45,56,100};
bubbleSort(arr);
display(arr);
}

/**
*
* 快速排序
* 选择一个基准元素,通常选择第一个元素或者最后一个元素,通过一趟扫描，
* 将待排序列分成两部分,一部分比基准元素小,一部分大于等于基准元素,
* 此时基准元素在其排好序后的正确位置,然后再用同样的方法递归地排序划分的两部分。
*/
public static int partion(int[] arr,int left,int right,int point){
int leftPtr = left -1;
int rightPtr = right;
while(true){
while(leftPtr <rightPtr && arr[++leftPtr] < point);
while(leftPtr <rightPtr && arr[--rightPtr] > point);
if(leftPtr>=rightPtr){
break;
}else{
int temp = arr[leftPtr];
arr[leftPtr] = arr[rightPtr];
arr[rightPtr] = temp;
}
}
int temp = arr[leftPtr];
arr[leftPtr] = arr[right];
arr[right] = temp;
return leftPtr;
}
public void sort(int arr[],int left,int right){
if(right - left <=0){
return;
}else{
int point = arr[right];
int partion = partion(arr,left,right,point);
sort(arr,left,partion-1);
sort(arr,partion+1,right);

}
}
//测试快速排序
@Test
public void testQuerySort(){
int[] arr = new int[10];
for(int i=0;i<10;i++){
arr[i] = (int)(Math.random()*100);
}
display(arr);
sort(arr,0,arr.length-1);
System.out.println();
display(arr);
}


/**
* 归并排序
* 归并（Merge）排序法是将两个（或两个以上）有序表合并成一个新的有序表，
* 即把待排序序列分为若干个子序列，每个子序列是有序的。
* 然后再把有序子序列合并为整体有序序列。
*/
public void mergingSort(int[] arr){

}
public void sort1(int[] data, int left, int right) {

// TODO Auto-generatedmethod stub
if(left<right){
//找出中间索引
int center=(left+right)/2;
//对左边数组进行递归
sort1(data,left,center);
//对右边数组进行递归
sort1(data,center+1,right);
//合并
merge(data,left,center,right);
}
}
private void merge(int[] data, int left, int center, int right) {
int [] tmpArr=new int[data.length];
int mid=center+1;
//third 记录中间数组的索引
int third=left;
int tmp=left;
while(left<=center&&mid<=right){
//从两个数组中取出最小的放入中间数组
if(data[left]<=data[mid]){
tmpArr[third++]=data[left++];
}else{
tmpArr[third++]=data[mid++];
}
}
//剩余部分依次放入中间数组
while(mid<=right){
tmpArr[third++]=data[mid++];
}
while(left<=center){
tmpArr[third++]=data[left++];
}
//将中间数组中的内容复制回原数组
while(tmp<=right){
data[tmp]=tmpArr[tmp++];
}
System.out.println(Arrays.toString(data));

}

//归并排序
@Test
public void testmergingSort(){
int[] a={49,38,65,97,76,13,27,78,34,12,64,5,4,62,99,98,54,56,17,18,23,34,15,35,25,53,51};
sort1(a,0,a.length-1);


}
/**
* 基数排序
* 将所有待比较数值（正整数）统一为同样的数位长度，数位较短的数前面补零。
* 然后，从最低位开始，依次进行一次排序。这样从最低位排序一直到最高位排序完成以后,
* 数列就变成一个有序序列。
*/
public void radixSort(int[] array){
int max=array[0];
for(int i=0;i<array.length;i++){
if(array[i]>max){
max = array[i];
}
}
int time=0;
while(max>0){
max/=10;
time++;
}
List<ArrayList> queue = new ArrayList();
for(int i=0;i<10;i++){
ArrayList<Integer> queue1 = new ArrayList<Integer>();
queue.add(queue1);
}
for(int i=0;i<time;i++){
for(int j=0;j<array.length;j++){
int x = array[j]%(int)Math.pow(10,i+1)/(int)Math.pow(10, i);
ArrayList<Integer> queue2 =queue.get(x);
queue2.add(array[j]);
queue.set(x, queue2);
}
int count = 0;
for(int k=0;k<10;k++){
while(queue.get(k).size()>0){
ArrayList<Integer> queue3 = queue.get(k);
array[count] = queue3.get(0);
count++;
}
}
}
}
//基数排序
@Test
public void testRadix(){
int a[]={49,38,65,97,76,13,27,49,78};
display(a);
radixSort(a);
System.out.println();
display(a);
}
//二分查找
public int binarySearch(int[] arr,int value){
int start = 0;
int end = arr.length-1;
while(start<=end){
int middle = (start+end)/2;
if(arr[middle]==value){
return middle;
}else if(arr[middle]>value){
end = middle-1;
}else {
start = middle +1;
}
}
return -1;
}
public int binarySearch2(int[] arr,int start,int end,int value){
while(start<=end){
int middle = (start+end)/2;
if(arr[middle]==value){
return middle;
}else if(arr[middle]>value){
end = middle-1;
binarySearch2(arr,start, end, 3);
}else {
start = middle +1;
binarySearch2(arr,start, end, 3);
}
}
return -1;
}
@Test
public void testBinary(){
int[] arr = {1,2,3,4,5};
display(arr);
int a = binarySearch2(arr,0,arr.length,3);
System.out.println(a);
display(arr);
}
}