算法实现之部分排序算法实现

插入排序

循环取出数组的一位上的数，从此位向前进行比较。若比前一位小，前一位后移，再往前移一位比较，直到某一位大于这个数且它的前一位小于等于这个数。

public static int[] insertsort(int[]arr)
    {
        for(int i = 0 ; i < arr.length ; i++)
        {
            int a = arr[i];
            int j = i;
            while (j > 0 && a < arr[j - 1])
            {
                arr[j] = arr[j - 1];
                j--;
            }
            arr[j] = a;
        }
        return arr;
    }

 二分归并排序

通过不断的递归调用，把数组对半分开，确保小的数在一半，大的数在另一半，然后按大小整合数组。

public static void mergeSort(int[] arr)
    {
        if (arr == null || arr.length <= 1) 
        {
            return;
        }

        int[] temp = new int[arr.length];
        mergeSort(arr, 0, arr.length - 1, temp);
    }

    private static void mergeSort(int[] arr, int start, int end, int[] temp) 
    {
        if (start >= end) 
        {
            return;
        }

        int mid = start + (end - start) / 2;
        mergeSort(arr, start, mid, temp);
        mergeSort(arr, mid + 1, end, temp);
        merge(arr, start, mid, end, temp);
    }

    private static void merge(int[] arr, int start, int mid, int end, int[] temp) {
        int left = start;
        int right = mid + 1;
        int index = start;

        while (left <= mid && right <= end) 
        {
            if (arr[left] <= arr[right]) 
            {
                temp[index++] = arr[left++];
            } 
            else 
            {
                temp[index++] = arr[right++];
            }
        }

        while (left <= mid)
        {
            temp[index++] = arr[left++];
        }

        while (right <= end) 
        {
            temp[index++] = arr[right++];
        }

        if (end + 1 - start >= 0) System.arraycopy(temp, start, arr, start, end + 1 - start);
    }

冒泡排序

每一次都通过相邻元素的交换把最大的放在最右边。

public static  void bubblesort2(int [] arr)
    {

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

                }
            }


     }


    }

堆排序 

将待排序数组建立为一个最大堆或最小堆，将堆顶元素（即最大值）与堆末尾元素交换，将堆的大小减一，并对堆顶元素进行下沉操作，使其满足最大堆的性质，重复步骤，直到堆的大小为1，此时数组已经有序。

public static void heapSort(int[] arr) 
    {
        int n = arr.length;

        // 构建最大堆
        for (int i = n / 2 - 1; i >= 0; i--)
            heapify(arr, n, i);

        // 从堆顶依次取出元素并进行排序
        for (int i = n - 1; i > 0; i--) 
        {
            // 将堆顶元素与当前堆的最后一个元素交换
            int temp = arr[0];
            arr[0] = arr[i];
            arr[i] = temp;

            // 修复堆性质
            heapify(arr, i, 0);
        }
    }

    public static void heapify(int[] arr, int n, int i) 
    {
        int largest = i; // 初始化最大元素为根节点
        int left = 2 * i + 1; // 左子节点
        int right = 2 * i + 2; // 右子节点

        // 如果左子节点大于最大元素，则更新最大元素的索引
        if (left < n && arr[left] > arr[largest])
            largest = left;

        // 如果右子节点大于最大元素，则更新最大元素的索引
        if (right < n && arr[right] > arr[largest])
            largest = right;

        // 如果最大元素不是根节点，则交换根节点与最大元素，并继续修复堆性质
        if (largest != i) 
        {
            int swap = arr[i];
            arr[i] = arr[largest];
            arr[largest] = swap;

            heapify(arr, n, largest);
        }
    }

快速排序

运用分治的思想，不断选择，使用基准元素将数组一分为二，然后分别从前到后交换大小不符合要求的元素。当数组中所有元素大小顺序符合要求，算法结束。

public  static void quicksort(int[]arr ,int low,int high)
    {
        if(low<high) {
            //low = 0;high =arr.len-1
            int p = arr[low];
            int i = low + 1;
            int j = high;
            int temp;
            while (i <= j) {
                // 找到第一个大于基准值的元素
                while (i <= j && arr[i] <= p) {
                    i++;
                }

                // 找到第一个小于基准值的元素
                while (i <= j && arr[j] > p) {
                    j--;
                }

                // 交换两个元素的位置
                if (i < j) {
                    temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
            }

            // 将基准值放到正确的位置上

            temp = arr[low];
            arr[low] = arr[j];
            arr[j] = temp;


            quicksort(arr, low, j - 1);
            quicksort(arr, j + 1, high);



        }
    }

本文仅为学习记录，如有错误欢迎指正