排序算法总结

最新推荐文章于 2022-04-22 11:08:43 发布

星晴相恋

最新推荐文章于 2022-04-22 11:08:43 发布

阅读量98

点赞数

本文链接：https://blog.csdn.net/qq_35158401/article/details/107799455

版权

/*选择排序：选择当前遍历的首位作为最小值，依次往后遍历，如果后面有比首位值更小，交换值

时间复杂度：O(N2)  不稳定算法*/

public class SelectionSort {

    public static void main(String[] args) {

        //初始化一个无序数组

        int[] arr = {2,1,3,5,4,7,7,9,0};

        //排序

        selectSort(arr);

        //输出排序后的结果集

        for(int i = 0;i< arr.length;i++){

            System.out.println(arr[i]);

        }

    }

    public static void selectSort(int[] arr){

        //两层循环进行排序

        for(int i =0;i<arr.length;i++){

            for(int j = i+1;j<arr.length;j++){

                if(arr[i] > arr[j]){

                    swap(arr,i,j);

                }

            }

        }

    }



    public static void swap(int arr[],int temp1,int temp2){

    //不用临时变量进行交换数值

    arr[temp1] = arr[temp1] ^ arr[temp2];

    arr[temp2] = arr[temp1] ^ arr[temp2];

    arr[temp1] = arr[temp1] ^ arr[temp2];

    }

}

/*冒泡排序：两两相邻比较，最小值的放在首位
时间复杂度：O(N2),为稳定性算法*/
public class BubbleSort {
    public static void main(String[] args) {
        //初始化一个无序数组
        int[] arr = {0,2,1,5,7,9,9,6};
        //排序
        bubbleSort(arr);
        //输出排序后的结果集
        for(int i = 0;i< arr.length;i++){
            System.out.println(arr[i]);
        }
    }

    public static void bubbleSort(int arr[]){
        //外层循环控制排序趟数
        for(int i = 0;i< arr.length-1;i++){
            //内层循环控制每一趟排序多少次
            for(int j =i;j< arr.length-i-1;j++){
                if(arr[j] > arr[j+1]){
                    swap(arr,j,j+1);
                }
            }
        }
    }

    public static void swap(int arr[],int temp1,int temp2){
        //不用临时变量进行交换数值
        arr[temp1] = arr[temp1] ^ arr[temp2];
        arr[temp2] = arr[temp1] ^ arr[temp2];
        arr[temp1] = arr[temp1] ^ arr[temp2];
    }
}

/*插入排序：类似于扑克牌排序，每一个待排序的牌的前面已然有序，通过比较插入到合适的位置
* 时间复杂度 O(N2) 稳定性排序*/
public class insertSort {
    public static void main(String[] args) {
        //初始化一个无序数组
        int[] arr = {2,1,3,5,4,7,7,9,0};
        //排序
        insertSort(arr);
        //输出排序后的结果集
        for(int i = 0;i< arr.length;i++){
            System.out.println(arr[i]);
        }
    }

    //插入排序
    public static void insertSort (int array[]) {
        int i,j,temp;
        for(i=1;i<array.length;i++) {
            temp=array[i];
            for(j=i-1;j>=0;j--) {
                //通过临时变量一直和之前的数值进行比较，如果前者的数比自己小，退出循环，赋值；
                //否则进行变量的值拷贝，待最终确定临时变量的位置，再进行数值交换即可
                //好处显而易见，不需要通过频繁更换下标等繁琐操作
                if(temp>array[j]) {
                    break;
                }else {
                    array[j+1]=array[j];
                }
            }
            array[j+1]=temp;
        }
    }
}

//快排

public class QuickSort {
    public static void main(String[] args) {
        //初始化一个无序数组
        int[] arr = {4,6,3,0,2};
        //排序
        QuickSort(arr,0,arr.length - 1);
        //输出排序后的结果集
        for(int i = 0;i< arr.length;i++){
            System.out.println(arr[i]);
        }
    }

    /**
     * 快速排序方法
     * @param array
     * @param start
     * @param end
     * @return
     */
    public static int[] QuickSort(int[] array, int start, int end) {
        if (array.length < 1 || start < 0 || end >= array.length || start > end) return null;
        int smallIndex = partition(array, start, end);
        if (smallIndex > start)
            QuickSort(array, start, smallIndex - 1);
        if (smallIndex < end)
            QuickSort(array, smallIndex + 1, end);
        return array;
    }
    /**
     * 快速排序算法——partition
     * @param array
     * @param start
     * @param end
     * @return
     */
    public static int partition(int[] array, int start, int end) {
        int pivot = (int) (start + Math.random() * (end - start + 1));
        int smallIndex = start - 1;
        swap(array, pivot, end);
        for (int i = start; i <= end; i++)
            if (array[i] <= array[end]) {
                smallIndex++;
                if (i > smallIndex)
                    swap(array, i, smallIndex);
            }
        return smallIndex;
    }

    /**
     * 交换数组内两个元素
   * @param array
     * @param i
     * @param j
     */
    public static void swap(int[] array, int i, int j) {
        int temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }
}

/**

* 归并排序

* @param array

* @return

public static int[] MergeSort(int[] array) {

if (array.length < 2) return array;

int mid = array.length / 2;

int[] left = Arrays.copyOfRange(array, 0, mid);

int[] right = Arrays.copyOfRange(array, mid, array.length);

return merge(MergeSort(left), MergeSort(right));

}

/**

* 归并排序——将两段排序好的数组结合成一个排序数组

* @param left

* @param right

* @return

public static int[] merge(int[] left, int[] right) {

int[] result = new int[left.length + right.length];

for (int index = 0, i = 0, j = 0; index < result.length; index++) {

if (i >= left.length)

result[index] = right[j++];

else if (j >= right.length)

result[index] = left[i++];

else if (left[i] > right[j])

result[index] = right[j++];

else

result[index] = left[i++];

}

return result;

}

//声明全局变量，用于记录数组array的长度；

static int len;

/**

* 堆排序算法

* @param array

* @return

public static int[] HeapSort(int[] array) {

len = array.length;

if (len < 1) return array;

//1.构建一个最大堆

buildMaxHeap(array);

//2.循环将堆首位（最大值）与末位交换，然后在重新调整最大堆

while (len > 0) {

swap(array, 0, len - 1);

len--;

adjustHeap(array, 0);

}

return array;

}

/**

* 建立最大堆

* @param array

public static void buildMaxHeap(int[] array) {

//从最后一个非叶子节点开始向上构造最大堆

for (int i = (len/2 - 1); i >= 0; i--) { //感谢 @让我发会呆网友的提醒，此处应该为 i = (len/2 - 1)

adjustHeap(array, i);

}

/**

* 调整使之成为最大堆

* @param array

* @param i

public static void adjustHeap(int[] array, int i) {

int maxIndex = i;

//如果有左子树，且左子树大于父节点，则将最大指针指向左子树

if (i * 2 < len && array[i * 2] > array[maxIndex])

maxIndex = i * 2;

//如果有右子树，且右子树大于父节点，则将最大指针指向右子树

if (i * 2 + 1 < len && array[i * 2 + 1] > array[maxIndex])

maxIndex = i * 2 + 1;

//如果父节点不是最大值，则将父节点与最大值交换，并且递归调整与父节点交换的位置。

if (maxIndex != i) {

swap(array, maxIndex, i);

adjustHeap(array, maxIndex);

}

//荷兰国旗问题(快排思路)

package basic_class_01;

public class Code_08_NetherlandsFlag {

   public static int[] partition(int[] arr, int l, int r, int p) {
      int less = l - 1;
      int more = r + 1;
      while (l < more) {
         if (arr[l] < p) {
            swap(arr, ++less, l++);
         } else if (arr[l] > p) {
            swap(arr, --more, l);
         } else {
            l++;
         }
      }
      return new int[] { less + 1, more - 1 };
   }

   // for test
   public static void swap(int[] arr, int i, int j) {
      int tmp = arr[i];
      arr[i] = arr[j];
      arr[j] = tmp;
   }

   // for test
   public static int[] generateArray() {
      int[] arr = new int[10];
      for (int i = 0; i < arr.length; i++) {
         arr[i] = (int) (Math.random() * 3);
      }
      return arr;
   }

   // for test
   public static void printArray(int[] arr) {
      if (arr == null) {
         return;
      }
      for (int i = 0; i < arr.length; i++) {
         System.out.print(arr[i] + " ");
      }
      System.out.println();
   }

   public static void main(String[] args) {
      int[] test = generateArray();

      printArray(test);
      int[] res = partition(test, 0, test.length - 1, 1);
      printArray(test);
      System.out.println(res[0]);
      System.out.println(res[1]);

   }
}

星晴相恋

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
排序算法总结

/*选择排序：选择当前遍历的首位作为最小值，依次往后遍历，如果后面有比首位值更小，交换值时间复杂度：O(N2) 不稳定算法*/public class SelectionSort { public static void main(String[] args) { //初始化一个无序数组 int[] arr = {2,1,3,5,4,7,7,9,0}; //排序 selectSort(arr); ...
复制链接

扫一扫