2. 程式人生 > 其它 >java--演算法--排序演算法

java--演算法--排序演算法

阿新 • • 發佈：2021-07-11
  1. 排序演算法的基本介紹：

  2. 演算法的具體實現：

      1. package com.model.sort;

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.Arrays;
import java.util.UUID;

/**
 * @Description:測試類
 * @Author: 張紫韓
 * @Crete 2021/7/11 9:11
 * 排序演算法:
 * 氣泡排序
 
         
        */
public class SortDemo01 {
    public static void main(String[] args) {
        int[] arr=new int[]{1,5,3,9,4,2,6,7};
        int[] arr1=new int[]{1,2,3,4,5,6};
        System.out.println(Arrays.toString((sort(arr1))));
        int[] arr2=new int[80000];
        for (int i = 0; i < 80000; i++) {
            arr2[i]
         
        = (int)(Math.random()*80000);
        }
        int second = LocalDateTime.now().getSecond();
        sort(arr2);
        System.out.println("總共花費時間："+(LocalDateTime.now().getSecond()-second));

    }
    public static int[] sort(int[] arr){
        //        氣泡排序的時間複雜度是o(n^2)
        boolean flag=false;
        
         
        for (int i=0;i< arr.length-1;i++){
            for (int j = 0; j < arr.length-1-i ; j++) {
                if (arr[j]>arr[j+1]){
                    flag=true;//如果某一趟一次交換都沒有發生則說明已經排好了，可以直接退出了
                    int n=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=n;
                }
            }
            if (flag==false){
                break;
            }else {
                flag=false;
            }
        }
       return arr;

    }

}
      4. package com.model.sort;

import java.time.LocalDateTime;
import java.util.Arrays;

/**
 * @Description:測試類
 * @Author: 張紫韓
 * @Crete 2021/7/11 10:34
 * 排序演算法：
 * 選擇排序 Select Sort
 */
public class SortDemo02 {
    public static void main(String[] args) {
        int[] array=new int[]{9,3,1,6,4,2,7,8,5};
        selectSort(array);
        System.out.println(Arrays.toString(array));

        int[] array1=new int[80000];
        for (int i=0;i<80000;i++){
         array1[i]=(int)(Math.random()*800000);
        }
        int second = LocalDateTime.now().getSecond();
        selectSort(array1);
        System.out.println(LocalDateTime.now().getSecond()-second);

    }
//    選擇排序：記錄最小值和最小值的下標
    public static void selectSort(int[] array){
        for (int i=0;i<array.length-1;i++){//第一圈找到最小的放在第一個位置
            int min=array[i];
            int index=i;
            for (int j = i; j < array.length; j++) {
                if (array[j]<min){
                    min=array[j];
                    //找到最小的進行交換
                    index=j;
                }
            }
            if (i != index) {
                int n=array[i];
                array[i]=array[index];
                array[index]=n;
            }


        }

    }
}
      3. package com.model.sort;

import java.util.Arrays;

/**
 * @Description:測試類
 * @Author: 張紫韓
 * @Crete 2021/7/11 11:06
 * 選擇排序：
 * 插入排序 （Insertion Sort）
 * 分成兩個表，一個是有序的的，一個無序的表，尋找無序表中第一個元素在有序表中的位置，插入，一次類推，將無序表中的資料全部放在有序表中
 */
public class SortDemo03 {
    public static void main(String[] args) {
        int[] array = new int[]{9,5, 6, 4, 2, 1, 3, 7,8};
//        insertionSort(array);
//        System.out.println(Arrays.toString(array));
//        insertionSort02(array);
//        System.out.println(Arrays.toString(array));

        insertionSort02(array);
        System.out.println(Arrays.toString(array));
    }

    public static void insertionSort(int[] array) {

        for (int i = 1; i < array.length; i++) {
            int insertVal = array[i];
            int index = i - 1;
            while (index >= 0 && insertVal < array[index]) {
                array[index + 1] = array[index];
                index--;
            }
            array[index + 1] = insertVal;
        }
    }

    public static void insertionSort02(int[] array) {

        for (int i = 1; i < array.length; i++) {
            int insertVal = array[i];
            int index = i;
            for (int j = 0; j <= i; j++) {
                if (array[j] > insertVal) {
                    index = j;
                    break;
                }
            }
            for (int k = i; k > index; k--) {
                array[k] = array[k - 1];
            }
            array[index] = insertVal;
        }
    }

    public static void insertionSort03(int[] array) {

        for (int i = 1; i < array.length; i++) {
            int insertVal = array[i];
            int index = 0;
            for (int j = i - 1; j >= 0; j--) {
                if (insertVal > array[j]) {
                    index = j + 1;
                    break;
                }
                array[j + 1] = array[j];
            }
            array[index] = insertVal;
        }
    }
}
      4. package com.model.sort;

import java.time.LocalDateTime;
import java.util.Arrays;

/**
 * @Description:測試類
 * @Author: 張紫韓
 * @Crete 2021/7/11 17:13
 * 排序演算法：
 * 希爾排序 （Hill Sort）
 */
public class SortDemo04 {
    static int count=0;
    public static void main(String[] args) {

        int[] array = new int[]{8, 9, 1, 7, 2, 3, 5, 4, 6, 0};
//        hillSort(array);
//        System.out.println(Arrays.toString(array));
//        hillSort02(array);
//        System.out.println(Arrays.toString(array));
//        hillSort03(array);
//        System.out.println(Arrays.toString(array));
//        hillSort04(array);
//        System.out.println(Arrays.toString(array));

        int[] arrays = new int[8000000];
        for (int i = 0; i < 8000000; i++) {
            arrays[i]= (int) (Math.random()*800000);
        }
        int second = LocalDateTime.now().getSecond();
        hillSort04(arrays);
        System.out.println("花費時間為"+(LocalDateTime.now().getSecond()-second));


    }

    public static void hillSort(int[] array) {
        int groupNum = array.length / 2;
        while (groupNum >= 1) {

            for (int i = 0; i < groupNum; i++) {

                //對每組的資料進行插入排序
                for (int j = 1; j < array.length / groupNum; j++) {
                    int insertVal = array[i + j * groupNum];
                    int index = i + (j - 1) * groupNum;
                    while (index >= 0 && insertVal < array[index]) {
                        array[index + groupNum] = array[index];
                        index = index - groupNum;
                    }
                    array[index + groupNum] = insertVal;
                }

            }
            groupNum = groupNum / 2;

        }
    }

    //    交換的方式實現希爾排序
    public static void hillSort02(int[] array) {

        int groupNum = array.length / 2;
        while (groupNum >= 1) {
            for (int i = groupNum; i < array.length; i++) {
                for (int j = i - groupNum; j >= 0; j -= groupNum) {
                    if (array[j] > array[j + groupNum]) {
                        int temp = array[j + groupNum];
                        array[j + groupNum] = array[j];
                        array[j] = temp;
                    }
                }
            }
            System.out.println("第"+count+++"躺"+Arrays.toString(array));
            groupNum = groupNum / 2;
        }
    }

    public static void hillSort03(int[] array){
        int temp=0;
        for (int groupNum=array.length/2;groupNum>0;groupNum/=2){
            for (int i=groupNum;i<array.length;i++){
                for (int j=i-groupNum;j>=0;j-=groupNum){
                    if (array[j]>array[j+groupNum]){
                        temp=array[j];
                        array[j]=array[j+1];
                        array[j+1]=temp;
                    }
                }
            }
            System.out.println("第"+(++count)+"輪比較的結果："+Arrays.toString(array));
        }
    }
//    移動的方式實現希爾排序(時間最快)
    public static void hillSort04(int[] array){
        for (int groupNum=array.length/2;groupNum>0;groupNum/=2){
            for (int i=groupNum;i<array.length;i++){
                int insertVal=array[i];
                int index=i-groupNum;
                while(index>=0&&insertVal<array[index]){
                    array[index+groupNum]=array[index];
                    index-=groupNum;
                }
                array[index+groupNum]=insertVal;
            }
        }
    }
}
      3. package com.model.sort;

import java.util.Arrays;

/**
 * @Description:測試類
 * @Author: 張紫韓
 * @Crete 2021/7/11 20:26
 * 排序演算法：
 * 快速排序（Quick sort）-->交換排序（氣泡排序）
 */
public class SortDemo05 {
    public static void main(String[] args) {
        int[] array = {1, 2, 3, -1, -2, 0};
        quickSort(array, 0, array.length - 1);
        System.out.println(Arrays.toString(array));

    }

    public static void quickSort(int[] array, int left, int right) {

        int l = left;
        int r = right;
        int pivot = array[(l + r) / 2];
        //遞迴實現將比pivot大的值放在右邊，比pivot小的值放在左邊
        while (l < r) {
            while (array[l] < pivot) {
                l++;
            }
            while (array[r] > pivot) {
                r--;
            }
            if (l >= r) {
                break;
            }
            int temp = array[l];
            array[l] = array[r];
            array[r] = temp;
            //交換之後發現，這個值和pivot相等，則跳過這個值
            if (array[l]==pivot){
                l++;
            }
            if (array[r]==pivot){
                r--;
            }
        }
        if (l==r){
            l++;
            r--;
        }
        if (left<r) quickSort(array, left, r);
        if (left>l) quickSort(array, l, r);
    }
}

    6. 　　

相關推薦

JAVA堆排序演算法的講解

預備知識 堆排序 　　堆排序是利用堆這種資料結構而設計的一種排序演算法，堆排序是一種選擇排序，它的最壞，最好，平均時間複雜度均為O(nlogn)，它也是不穩定排序。首先簡單瞭解下堆結構。

java常見排序演算法

技術標籤：二分法java資料結構 @java常見排序演算法 import java.util.Arrays; public class MethodTest06 { public static void main(String[] args) { int[] arr = {3, 1, 2, 1, 5}; int[] arr1 = {3, 1, 2, 1

java選擇排序演算法

技術標籤：排序演算法java演算法 java選擇排序演算法 一，選擇排序演算法簡介

java--演算法--排序演算法

排序演算法的基本介紹： 演算法的具體實現： package com.model.sort; import java.time.LocalDateTime;

假期java自學-----排序演算法

今天對java語言排序演算法進行了深入學習： Java的幾種常見排序演算法 　　一、所謂排序，就是使一串記錄，按照其中的某個或某些關鍵字的大小，遞增或遞減的排列起來的操作。排序演算法，就是如何使得記錄按照要求排

Spring Data JPA 實現多表操作，Java常見排序演算法面試題

linkMan.setLkmName(\"聯絡人1\"); linkMan.setLkmGender(\"male\"); linkMan.setLkmMobile(\"11111111111\");

Java常用排序演算法

1、氣泡排序 public class BubbleSort { public static void main(String[] args) { // TODO Auto-generated method stub

演算法 | Java 常見排序演算法（純程式碼）

目錄 彙總 1. 氣泡排序 2. 選擇排序 3. 插入排序 4. 快速排序 5. 歸併排序 6. 希爾排序

【JAVA】排序演算法之選擇排序

前言： 基礎排序演算法，旨在簡單易懂講解演算法邏輯和思路，以下均使用升序方式來講解和實現演算法。

資料結構與演算法——排序演算法-選擇排序

基本介紹 選擇排序（select sorting）也屬於內部排序法，是從欲排序的資料中，按指定的規則選出來某個元素，再依規定交換位置後達到排序的目的。

資料結構與演算法——排序演算法-歸併排序

目錄簡單介紹基本思想思路分析程式碼實現對程式碼的一些改進大資料量耗時測試複雜度

[演算法] 排序演算法總結

總述 借圖侵刪 SHELL排序 時間複雜度：O(N^(X)) (X<=2) 又稱“縮小增量排序”，是插入排序的進化版，其高效之處在於通過增量間隔的比較和交換，比樸素的插入排序減少了交換次數，從而提高了效率。感性認知來

JavaScript演算法—排序演算法01

介紹了排序演算法中的氣泡排序，選擇排序，插入排序，歸併排序，快速排序5種基本排序方法

JavaScript演算法——排序演算法 下

希爾排序 希爾排序，也稱遞減增量排序演算法，是插入排序的一種更高效的改進版本。但希爾排序是非穩定排序演算法。

演算法 | 排序演算法圖形化比較：快速排序、插入排序、選擇排序、氣泡排序

用Objective-C實現幾種基本的排序演算法，並把排序的過程圖形化顯示。其實演算法還是挺有趣的 。

面試題: java中常見的排序演算法的實現及比較

目錄1.氣泡排序1.1 氣泡排序普通版1.2 冒泡排序升級版2.選擇排序3.插入排序4.快速排序5.歸併排序6.希爾排序7.基數排序8.堆排序各種演算法的比較

十大經典排序演算法（java）

十大經典排序演算法最強總結（含JAVA程式碼實現） 轉載（https://www.cnblogs.com/guoyaohua/p/8600214.html）

如何基於js及java分析並封裝排序演算法

前言 　　本次來分享一下排序的api底層的邏輯，這次用js模擬，java的邏輯也是差不多。

Java實現經典七大經典排序演算法

利用Java語言實現七大經典排序演算法：氣泡排序、選擇排序、插入排序、希爾排序、堆排序、歸併排序以及快速排序。

Java排序演算法三之歸併排序的遞迴與非遞迴的實現示例解析

歸併有遞迴和非遞迴兩種。 歸併的思想是： 1.將原陣列首先進行兩個元素為一組的排序，然後合併為四個一組，八個一組，直至合併整個陣列；