数据结构

数组

一.数组的查找

二、数组的排序

1.冒泡排序

排序原理：数组元素两两比较，交换位置，大元素往后放，那么经过一轮的比较后，最大的元素，就会出现在最大索引处。

int[] arr = {24,69,90,57,12}; //待排序数组
for(int i =0;i< arr.length-1;i++){
 	for(int j =0;j< arr.length-1-j;j++){
    	if(arr[i]>arr[i+1]){
            int tmp = arr[i];
            arr[i] = arr[i+1];
            arr[i+1] = tmp;
        }
	}   
}

2. 选择排序

​ 排序原理：从0索引开始，依次和后面的元素进行比较，小的元素往放前，经过一轮比较后，最小的元素就出现在最小索引处。

int[] arr = {24,69,80,57,13};

for(int i = 0; i<arr.length-1;i++){
    for(int j = 1+i; j< arr.length;j++ ){
        if(arr[i]>arr[j]){
            int tmp = arr[i];
            arr[i] = arr[j];
            arr[j] = tmp;
        }
    }
}

3.直接插入排序

排序原理：直接插入排序，是一种最简单的排序方法，他的基本操作是将一个记录插入到一个长度为m的有序表中，使之仍保持有序。

int arr[] = {49,38,64,7,6,23};
for(int i =1;i<arr.length;i++){
    for(int j=i;j>0;j--){
        if(arr[j]<arr[j-1]){
            int tmp = arr[j];
            arr[j] = arr[j-1];
            arr[j-1] = tmp;
        }
    }
}

4.希尔排序

算法原理：希尔排序又称缩小增量排序。

基本思想：先将原表按增量ht分组，每个子文件按照直接插入排序。同样，用下一个增量ht/2将文件再分 为子文件，再用直接插入法排序。直到ht=1时整个文件排好序。

关键：选择合适的增量

希尔排序算法 选择数组长度的一半，还可以选择一种序列叫做Knuth序列

h = 1 ; h= h * 3 + 1;

int[] arr = {46,55,13,42,17,94,5,70};

for(int h = arr.length/2;h>0;h/=2){
    for(int i = h;i<arr.length;i++){
        for(int j =i;j>h-1;j-=h){
            if(arr[j]<arr[j-h]){
                int tmp = arr[j];
                arr[j] = arr[j-h];
                arr[j-h] = tmp;
            }
        }
    }
}

5.快速排序

算法的基本思想

分治法：比大小，再分区

1. 从数组中取出一个数，作为基准数。
2. 分区：将比这个数大或者等于的数全部放在他的右边，小于他的数全放到他的左边。
3. 再对左右区间重复第二步，直到各区间只有一个数。

int[] arr = {10,3,5,6,1,0,100,40,50,8,-1};
quickSort(arr,0,arr.length-1)

public void quickSort(int[] arr,int start, int end){
    if(start<end){
        int index = getIndex(arr,start,end);
        quickSort(arr,start,index-1);
        quickSort(arr,index+1,end);
    }
}

public int getIndex(int[] arr,int start,int end){
    int i = start;
    int j = end;
    int x = arr[i];
    while(i<j){
        while(i<j&&arr[j]>=x){
            j--;
        }
        if(i<j){
            arr[i] = arr[j];
            i++
        }
        
        while(i<j&&arr[i]>=x){
            i++;
        }
        if(i<j){
            arr[j] = arr[i];
            j--;
        }
    }
}

6.归并排序

算法思想：利用归并的思想实现排序的方法。假设初始序列有N个记录，则可以看成N个有序的子序列，每个子序列的长度为1，然后两两归并，得到N/2个长度为2或者1的有序子序列，再两两归并…，如此重复，直至得到一个长度为N的有序序列为止，这种排序方法称为2路归并排序。

int[] arr = {4,5,6,7,8,10,2,3};

int[][] tempArr = new int[10][arr.length];
int[] counts = new int[10];
int max = getMax(arr); //得到arr中最大的元素
int len = String.valueOf(max).length();
//循环轮次
for (int i = 0,n=1;i<len;i++,n*10){
    for(int j =0; j< arr.length;j++){
    	//获取每个位上的数字
        int ys = arr[j]/n%10;
        tempArr[ys][counts[ys]++]=arr[j];
    }
    //取出桶中的元素
    int index = 0;
    for(int k = 0; k < counts.length; k++){
        if(counts[k]!=0){
            for(int h =0; h < counts[k];h++){
                //从桶中取出元素放回原数组
                arr[index] = tempArr[k][h];
                index++;
            }
            counts[k] = 0; 
        }
    }
}

7.堆排序

public class Main {

    public static void main(String[] args) {
        // write your code here
        //定义一个数组
        int[] arr = {1, 0, 6, 8, 3, 12, 9};

        int startIndex = (arr.length - 1) / 2;
        for (int i = startIndex; i >= 0; i--) {
            toMaxHeap(arr, arr.length, i);
        }
        System.out.println(Arrays.toString(arr));

        for (int i = arr.length - 1; i > 0; i--) {
            int t = arr[0];
            arr[0] = arr[i];
            arr[i] = t;
            toMaxHeap(arr, i, 0);
        }
        System.out.println(Arrays.toString(arr));
    }

    /***
     *
     * @param arr 要排序的数组
     * @param length 调整的元素个数
     * @param index 从哪里开始调整
     */
    private static void toMaxHeap(int[] arr, int length, int index) {
        //获取左右字节的索引
        int leftNodeIndex = index * 2 + 1;
        int rightNodeIndex = index * 2 + 2;
        //查找最大节点所对应的索引
        int maxIndex = index;
        if (leftNodeIndex < length && arr[leftNodeIndex] > arr[maxIndex]) {
            maxIndex = leftNodeIndex;
        }
        if (rightNodeIndex < length && arr[rightNodeIndex] > arr[maxIndex]) {
            maxIndex = rightNodeIndex;
        }

        //调换位置
        if (maxIndex != index) {
            int t = arr[maxIndex];
            arr[maxIndex] = arr[index];
            arr[index] = t;
        }
    }
}