基本算法

标签：冒泡排序   返回   test   奇偶数   array   ++   lag   返回顶部   import   

二分查找
快速排序
冒泡排序

二分查找

public static void main(String[] args) {

		int[] para = {1,2,3,4,5,6,7,8,9};
		System.out.println(binarySearch(para,8,0));
	}

	//{6,7,8,9}
	public static int binarySearch(int[] para,int target,int count){//8
		count++;
		if(para.length<=1){
			return count;
		}

		//先判断奇偶数
		if(para.length%2 > 0){//奇数
			int subNum = para.length/2;//2
			if(target == para[subNum]){
				return count;
			}else if(target>para[subNum]){
				binarySearch(subArray(para,subNum,para.length),target,count);
			}else if(target<para[subNum]){
				binarySearch(subArray(para,0,subNum),target,count);
			}
		}else{//偶数
			int subNum = para.length/2;//2
			if(target == para[subNum]){
				return count;
			}else if(target>para[subNum]){
				binarySearch(subArray(para,subNum,para.length),target,count);
			}else if(target<para[subNum]){
				binarySearch(subArray(para,0,subNum),target,count);
			}
		}

		return count;
	}

	private static int[] subArray(int[] para,int beginIndex,int endIndex){//4,8
		int[] result = new int[endIndex-beginIndex-1];
		int index = 0;
		for(int i=beginIndex+1;i<endIndex;i++){
			result[index] = para[i];
			index++;
		}
		return result;
	}

返回顶部

快速排序

package com.longfor.ads2.Test;

import java.util.Arrays;

public class QuickSort {
    /***
     * 快速排序
     * 每次把数组分割成左右两半，然后通过递归，分别在调用排序方法
     */
    public static void main(String[] args) {
        int[] num = { 5,1,4,6,3};
        QuickSort.quickSort(num, 0, num.length - 1);
        System.out.println(Arrays.toString(num));
    }

    /***
     * 快速排序
     * 每次把数组分割成左右两半，然后通过递归，分别在调用排序方法
     */
    public static void quickSort(int[] para,int left,int right){
        if(left<right){
            int index = sort(para,left,right);

            quickSort(para,left,index-1);
            quickSort(para,index+1,right);
        }
    }

    public static int sort(int[] para,int left,int right){
        int key = para[left];
        int index = left;
        int fangxiang = 0;//0代表是左边，1代表是在右边
        while (left<right){
            if(fangxiang==0){//坑在左边，从右边获取元素与key比较
                if(para[right] < key){
                    int tmp = para[left];//首先替换左右
                    para[left] = para[right];
                    para[right] = tmp;
                    left++;//左边界加1
                    fangxiang++;//将坑移动到右边
                    index = right;
                }else if(para[right] >= key){
                    right--;
                }
            }else{//坑在右边，从左边获取元素与key比较
                if(para[left] > key){
                    int tmp = para[left];//首先替换左右
                    para[left] = para[right];
                    para[right] = tmp;
                    right--;//右边界减1
                    fangxiang--;//将坑移动到左边
                    index = left;

                }else if(para[left] <= key){
                    left++;
                }
            }
        }
        return index;
    }

}

返回顶部

冒泡排序

    public static void main(String[] args) {
        int[] bubbleSort = {3,2,5,9,3,6,10,22};
        int[] bubbleSort2 = bubbleSort(bubbleSort);
        for(int tmp:bubbleSort2){
            System.out.println(tmp);
        }


    }

/***
     * 冒泡排序
     * 32593
     *
     * 23593
     * 23593
     * 23593
     * 23539
     *
     * 23539
     * 23539
     * 23359
     *
     * 23359
     * 23359
     *
     *
     * 两个优化点：
     * 1、如果序列大部分都是有序的数据，少部分需要排序，那么如果某次排序的时候没有发生数据交换，则可以认为序列已经排序完毕
     * 2、假设序列有1000个数据，后900个都是有序的并且都比前100个数据大，则每次排序只需要比较到前100
     *
     */
    public static int[] bubbleSort(int[] para){
        int length = para.length;
        int flag2 = 0;//记录最后一次交换的位置，那么后续遍历，这个位置后的数据不需要进行排序
        for(int i=0;i<length-2;i++){
            boolean flag = true;
            for(int j=0;j<length-i-1;j++){
                if(j<flag2){
                    int a = para[j];
                    int b= para[j+1];
                    if(a>b){
                        para[j]=b;
                        para[j+1]=a;
                        flag=false;
                        flag2= j;
                    }
                }
            }
            if(flag){//优化1：如果序列本身大部分数据都是有序的，则某一次排序没有发生交换，证明全部排序已经完毕
                return para;
            }
        }
        return para;
    }

返回顶部

基本算法

标签：冒泡排序   返回   test   奇偶数   array   ++   lag   返回顶部   import   

原文地址：https://www.cnblogs.com/yanhui007/p/12595937.html