各类算法与性能分析

各类算法与性能分析

排序算法概论

1.冒泡排序O(n² )：

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

2.简单选择排序O(n²)

冒泡排序的优化

public class ChoiceSort{
    public static int[] sort(int[] array){
        if (array.length == 0)
            return array;
        for(int i=0;i<array.length;i++){
            //存放最小数的下标
            int minIndex = i;
            for(int j=i;j<array.length;j++){
                //找到最小的那个数
                if(array[j]<array[minIndex]){
                    minIndex = j;
                }
            }
            //交换
            int temp = array[minIndex];
            array[minIndex] = array[i];
            array[i] = temp;
        }
    }
}

3.简单插入排序O(n²)

插入排序当前数据向后移动一位不会覆盖下一位的元素吗?

不会 比较一个移动一个，移动前后一个位置已经空出来了。

public class InstertionSort {
    public static int[] sort(int[] array){
        if (array.length == 0)
            return array;
        int currentValue;//待排序的数据
        for(int i=0;i<array.length-1;i++){//默认第一个元素已经排序
            int preIndex = i;//已排序数据的索引
            currentValue = array[preIndex+1];
      while(preIndex >= 0 && currentValue < array[preIndex]){
                array[preIndex+1] = array[preIndex];
                preIndex--;//遍历已排序的数组
            }
            array[preIndex+1] = currentValue;
        }
    }
}

4.分治法

1.希尔排序O(nlogn)

改进了简单插入排序，也称为缩小增量排序，突破了O(n²)

public class ShellSort{
   public static int[] sort(int[] array){
       if(array.length == 0)
           return array;
   }
   int len = array.length;
   int grap = len/2;
   //组内待排序的数据
   int currentValue;
   while(grap>0){
       for(int i=grap;i<len;i++)
           currentValue = array[i];
       int preIndex = i-grap;
       while(preIndex>0&&array[preIndex]>currentValue){
           array[preIndex + grap] = array[preindex];
           preIndex = preIndex - grap;
       }
   }
   grap = grap/2;
}

2.归并排序O(nlogn)

public class MergeSort{
    public static int[] sort(int[] array){
        //切分的位置
        int mid = array.length/2;
        int[] left = Arrays.copyOfRange(array,0,mid);
        int[] right = Arrays.copyOfRange(array,mid,array.length)
        return merge(sort(left),sort(right));
        
     private static int[] merge(int[] left, int[] right){
         int[] result = new int[left.length + right.length];
         for(int index = 0.leftIndex = 0.rightIndex = 0;index<result.length;index++){
             if(leftIndex>=left.length){
                 result[index] = right[rightIndex++]
             }
             else if(rightIndex>=right.length){
                 result[index] = left[rightIndex++]
         	 }
             else if(left[leftIndex]>=right.length){
                 result[index] = right[rightIndex++]
     		 }
             else{
                 result[index] = left[leftIndex++]    
   	 	}
	}
}

3.快速排序O(nlogn)

20世纪科学和工程十大算法

public class QuickSort {
    public static int[] sort(int[] array, int start, int end){
        if(array.length < 1 || start < 0 || end >= array.length || start > end)
            return null;
        //分区(割)指示器 = 一趟快速排序之后的返回值下标
        int zoneIndex = partition(array,start,end);
        //对左右两部分递归调用sort方法
        if(zoneIndex > start){           
            sort(array,start,zoneIndex-1);
        }
        if(zoneIndex < end){
            sort(array,zoneIndex+1,end);
        }
        
        return array;
    }
    
    private static in partition(int[] attay, int start,int end){
        //基准数
        int pivot = (int)(start+Math.random() * (end - start=1));
        int zoneIndex = start - 1;
        swap(array,pivot,end);//交换基准数和尾元素
        for(int i= start;i<end;i+=){
            if(array[i]<array[end]){
                zoneIndex +=;
                if(i>zoneIndex){
                    swap(array,i,zoneIndex);
                }
            }
        }
        return zoneIndex;
    }
    
    public static void swap(int[] array, int i, int j){
        int temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }
}

5.堆排序O(nlogn)

public class HeapSort {
    //声明全局遍历。用于记录数组array的长度
    private static int len;
    private static int[] sort(int[] array){
        len = array.length;
        if(len<1) return array;
        //构建一个最大堆
        buildMaxHeap(array);
        //取出堆顶元素和尾元素交换
        while(len>0){
            swap(array,0,len-1);
            len--;//len -- 数组不变 
            adjustHeap(array,i);
        }
        
        return array;
    }
}
//构建一个最大堆
private static void bulidMaxHeap(int[] array){
    for(int i= (len/2-1);i>=0;i--){
        adjustHeap(array,i);
    }
}

//调整堆
private static void adjustHeap(int[] array,int i){
	int maxIndex = i;//保存最大的元素
    int left = 2*i+1;//左节点
    int right = 2*(i+1);//右节点
    if(left<len&& array[left]>array[MaxIndex]){
        maxIndex = left;
    }
    if(right<len&& array[right]>array[MaxIndex]){
        maxIndex = right;
    } 
    if(maxIndex != i){
        swap(array,maxIndex,i);
        adjustHeap(array,maxIndex)
    }    
}

public static void swap(int[] array, int i, int j){
        int temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }
}

6.桶

1.计数排序

2.桶排序O(nlogn)

3.基数排序

总结：

二分查找

前提：

数据已经有序排放在数组中，通过将待查的元素与数组最中间元素进行对比，如果大于中间值，则目标值可能存在于右半部分，否则可能在左半部分，查到为止

public class BinarySearch{
    public static void main(String[] args){
        int arr[] = {1,2,3,4,5,6,7,8,9,10};//源数据
        int key = 8;
    }
    
    public static int biSerach(int arr[],int a){
        int start = 0;
        int end = arr.length - 1;
        
        int mid;
        while(start<=end){
        	mid = (start+end)/2;
        
        	if(arr[mid] < a){
            	end = mid+1;
        	}else if(arr[mid] > a){
            	end = mid - 1;
        	}else{
            	arr[mid];
      	  }
        }
        return -1;
    }
}