数据结构与算法之数组排序

1.冒泡排序算法

public void bubbleSort(long[] array){
    for(int i= 0;i<array.length-1;i++){
       for(int j=array.length-1;j>i;j--){
             if(array[j]<array[j-1]){ 
                  int temp = array[j];
                  array[j]=array[j-1];
                  array[j-1]=temp;
             }
         }
    }
}

2.选择排序

public static void selectSort(long[] arr) {
		int k = 0;
		long tmp = 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;
				}
			}
			tmp = arr[i];
			arr[i] = arr[k];
			arr[k] = tmp;
		}
	}

3.插入排序

public static void sort(long[] arr) {
		long tmp = 0;
		
		for(int i = 1; i < arr.length; i++) {
			tmp = arr[i];
			int j = i;
			while(j > 0 && arr[j-1] >= tmp) {
				arr[j] = arr[j - 1];
				j--;
			}
			arr[j] = tmp;
		}
	}

4.希尔排序

public static void sort(long[] arr) {
		//初始化一个间隔
		int h = 1;
		//计算最大间隔
		while(h < arr.length / 3) {
			h = h * 3 + 1;
		}
		
		while(h > 0) {
			//进行插入排序
			long tmp = 0;
			for(int i = h; i < arr.length; i++) {
				tmp = arr[i];
				int j = i;
				while(j > h - 1 && arr[j - h] >= tmp) {
					arr[j] = arr[j - h];
					j -= h;
				}
				arr[j] = tmp;
			}
			//减小间隔
			h = (h - 1) / 3;
		}
	}

5.二分法查找元素

public int binarySearch(int[] data,int teargetNum){
      int start = 0;  //开始位置
      int end  = data.length-1;
      while(start<=end){
            int middle = (start+end)/2;
                    if(targetNum==data[middle]){
                            return middle;
                    }else if(targetNum>data[middle]){
                            start = middle+1; 
                    }else{
                             end = middle -1;
                    } 
      }
        return -1  //-1表示没有找到
}

6.快速排序

public static void quickSort(int [] a, int left, int right) {  
    int i, j, t, base;  
    if (left > right)  
        return;  
    base = a[left]; // temp中存的就是基准数  
    i = left;       // 设置两个哨兵  
    j = right;  
    while (i != j) {  
        // 顺序很重要，要先从右边开始找  
        while (a[j] >= base && i < j)  
            j--;  
        // 再找右边的  
        while (a[i] <= base && i < j)  
            i++;  
        // 交换两个数在数组中的位置  
        if (i < j) {  
            t = a[i];  
            a[i] = a[j];  
            a[j] = t;  
        }  
    }  
    // 最终将基准数归位  
    a[left] = a[i];  
    a[i] = base;  
  
    quickSort(a, left, i - 1);// 继续处理左边的，这里是一个递归的过程  
    quickSort(a, i + 1, right);// 继续处理右边的 ，这里是一个递归的过程  
}