2. 程式人生 > >Java常用的九種排序方法及程式碼實現

Java常用的九種排序方法及程式碼實現

阿新 • • 發佈：2018-11-13

 

  1. package com.algorithm.Demo;
  3. import java.util.ArrayList;
  4. import java.util.Arrays;
  5. import java.util.List;
  7. public class SortRecoder {
  8.     public static void main(String[] args) {
  9.         SortRecoder SR = new SortRecoder();
  10.         int[] a={49,38,65,97,76,13,27,49,78,34,12,64,5,4,18,23,34,15,35,25,53};
  12.         System.out.println(" --1.直接插入排序--");
  13.         SR.insertSort(a);
  14.         System.out.println(" --2.希爾排序--");
  15.         SR.sheelSort(a);
  16.         System.out.println(" --3.簡單選擇排序--");
  17.         SR.selectSort(a);
  18.         System.out.println(" --4.堆排序--");
  19.         SR.heapSort(a);
  20.         System.out.println(" --5.氣泡排序--");
  21.         SR.bubbleSort(a);
  22.         System.out.println(" --6.快速排序--");
  23.         SR.FastSort(a,0,a.length-1);
  24.         SR.printAll(a);
  25.         System.out.println(" --7.歸併排序--");
  26.         SR.mergingSort(a,0,a.length-1);
  27.         SR.printAll(a);
  28.         System.out.println(" --8.基數排序--");
  29.         SR.radixSort(a);
  30.         System.out.println(" --9.類方法排序--");
  31.         SR.ArraySort(a);
  33.     }
  35.     // 列印完整序列
  36.     public void printAll(int[] list) {
  37.         for (int value : list) {
  38.             System.out.print(value+"  ");
  39.         }
  40.         System.out.println();
  41.     }
  43.     //1.直接插入排序
  44.     //將大於要插入值的數整體後移一個單位 ,將需要插入的小數值向前移一位。
  45.     public void insertSort(int[] a){
  46.         for(int i=1;i<a.length;i++){
  47.             int insertNum=a[i];//要插入的數 38,65,97,76,13,27...
  48.             int j=i-1;
  49.             //依次比較更換位置
  50.             for(;j>=0&&insertNum<a[j];j--){ //將大於要插入值的數整體後移一個單位  ，j減少1。
  51.                 a[j+1]=a[j];
  52.             }
  53.             a[j+1]=insertNum;//將需要插入的數放在要插入的位置。
  54.         }
  55.         this.printAll(a);
  56.     }
  58.     //2.希爾排序（最小增量排序）  --對於直接插入排序問題，資料量巨大時。
  59.     //  演算法先將要排序的一組數按某個增量d（n/2,n為要排序數的個數）分成若干組，
  60.     //  每組中記錄的下標相差d.對每組中全部元素進行直接插入排序，然後再用一個較小的增量（d/2）對它進行分組，
  61.     //  在每組中再進行直接插入排序。當增量減到1時，進行直接插入排序後，排序完成。
  62.     public  void sheelSort(int[] a){
  63.         int d  = a.length;
  64.         while (d!=0) {
  65.             d=d/2;
  66.             for (int x = 0; x < d; x++) {//分的組數
  67.                 for (int i = x + d; i < a.length; i += d) {//組中的元素，從第二個數開始
  68.                     int j = i - d;//j為有序序列最後一位的位數
  69.                     int temp = a[i];//要插入的元素 
  70.                     for (; j >= 0 && temp < a[j]; j -= d) {
  71.                         a[j + d] = a[j];//向後移動d位
  72.                     }
  73.                     a[j + d] = temp;
  74.                 }
  75.             }
  76.         }
  77.         this.printAll(a);
  78.     }
  80.     //3.簡單選擇排序    --常用於取序列中最大最小的幾個數時。
  81.     //遍歷整個序列，將最小的數放在最前面。遍歷剩下的序列，將最小的數放在最前面。
  82.     public void selectSort(int[] a) {
  83.         int length = a.length;
  84.         for (int i = 0; i < length; i++) {//迴圈次數
  85.             int key = a[i];
  86.             int position=i;
  87.             for (int j = i + 1; j < length; j++) {//選出最小的值和位置
  88.                 if (a[j] < key) {
  89.                     key = a[j];
  90.                     position = j;
  91.                 }
  92.             }
  93.             a[position]=a[i];//交換位置
  94.             a[i]=key;
  95.         }
  96.         this.printAll(a);
  97.     }
  99.     //4.堆排序  --是一種樹形選擇排序，是對直接選擇排序的有效改進。
  100.     //將根節點與最後一個節點交換，然後斷開最後一個節點。重複第一、二步，直到所有節點斷開。根節點是最小值
  101.     public void heapSort(int[] a){
  102.         int arrayLength=a.length;
  103.         //迴圈建堆  
  104.         for(int i=0;i<arrayLength-1;i++){
  105.             //建堆  
  106.             buildMaxHeap(a,arrayLength-1-i);
  107.             //交換堆頂和最後一個元素  
  108.             swap(a,0,arrayLength-1-i);
  109.            //System.out.println(Arrays.toString(a));
  110.         }
  111.         this.printAll(a);
  112.     }
  113.     private void swap(int[] data, int i, int j) {
  114.         int tmp=data[i];
  115.         data[i]=data[j];
  116.         data[j]=tmp;
  117.     }
  118.     //對data陣列從0到lastIndex建大頂堆  
  119.     private void buildMaxHeap(int[] data, int lastIndex) {
  120.         //從lastIndex處節點（最後一個節點）的父節點開始  
  121.         for(int i=(lastIndex-1)/2;i>=0;i--){
  122.             //k儲存正在判斷的節點  
  123.             int k=i;
  124.             //如果當前k節點的子節點存在  
  125.             while(k*2+1<=lastIndex){
  126.                 //k節點的左子節點的索引  
  127.                 int biggerIndex=2*k+1;
  128.                 //如果biggerIndex小於lastIndex，即biggerIndex+1代表的k節點的右子節點存在  
  129.                 if(biggerIndex<lastIndex){
  130.                     //若果右子節點的值較大  
  131.                     if(data[biggerIndex]<data[biggerIndex+1]){
  132.                         //biggerIndex總是記錄較大子節點的索引  
  133.                         biggerIndex++;
  134.                     }
  135.                 }
  136.                 //如果k節點的值小於其較大的子節點的值  
  137.                 if(data[k]<data[biggerIndex]){
  138.                     //交換他們  
  139.                     swap(data,k,biggerIndex);
  140.                     //將biggerIndex賦予k，開始while迴圈的下一次迴圈，重新保證k節點的值大於其左右子節點的值  
  141.                     k=biggerIndex;
  142.                 }else{
  143.                     break;
  144.                 }
  145.             }
  146.         }
  147.     }
  149.     //5.氣泡排序
  150.     //自上而下對相鄰的兩個數依次進行比較和調整，讓較大的數往下沉，較小的往上冒
  151.     public void bubbleSort(int[] a){
  152.         int temp;
  153.         for(int i=0;i<a.length;i++){
  154.             for(int j=0;j<a.length-i-1;j++){
  155.                 if(a[j]>a[j+1]){
  156.                     temp=a[j];
  157.                     a[j]=a[j+1];
  158.                     a[j+1]=temp;
  159.                 }
  160.             }
  161.         }
  162.         this.printAll(a);
  163.     }
  165.     //6.快速排序   --要求時間最快時。
  166.     //選擇第一個數為p，小於p的數放在左邊，大於p的數放在右邊。遞迴的將p左邊和右邊的數都按照第一步進行，直到不能遞迴
  167.     public void FastSort(int[] a,int low,int high){
  168.         int start = low;
  169.         int end = high;
  170.         int key = a[low];
  171.         while(end>start){
  172.             //從後往前比較
  173.             while(end>start&&a[end]>=key)  //如果沒有比關鍵值小的，比較下一個，直到有比關鍵值小的交換位置，然後又從前往後比較
  174.                 end--;
  175.             if(a[end]<=key){
  176.                 int temp = a[end];
  177.                 a[end] = a[start];
  178.                 a[start] = temp;
  179.             }
  180.             //從前往後比較
  181.             while(end>start&&a[start]<=key)//如果沒有比關鍵值大的，比較下一個，直到有比關鍵值大的交換位置
  182.                start++;
  183.             if(a[start]>=key){
  184.                 int temp = a[start];
  185.                 a[start] = a[end];
  186.                 a[end] = temp;
  187.             }
  188.         //此時第一次迴圈比較結束，關鍵值的位置已經確定了。左邊的值都比關鍵值小，右邊的值都比關鍵值大，但是兩邊的順序還有可能是不一樣的，進行下面的遞迴呼叫
  189.         }
  190.         //遞迴
  191.         if(start>low) FastSort(a,low,start-1);//左邊序列。第一個索引位置到關鍵值索引-1
  192.         if(end<high) FastSort(a,end+1,high);//右邊序列。從關鍵值索引+1到最後一個
  193.     }
  195.     //7.歸併排序  --速度僅次於快排
  196.     //選擇相鄰兩個陣列成一個有序序列。 然後再把相鄰有序子序列合併為整體有序序列。重複執行，直到全部組成一個有序序列
  197.     public void mergingSort(int[] data, int left, int right) {
  198.         if(left<right){
  199.             //找出中間索引  
  200.             int center=(left+right)/2;
  201.             //對左邊陣列進行遞迴  
  202.             mergingSort(data,left,center);
  203.             //對右邊陣列進行遞迴  
  204.             mergingSort(data,center+1,right);
  205.             //合併  
  206.             merge(data,left,center,right);
  207.         }
  209.     }
  211.     public void merge(int[] data, int left, int center, int right) {
  212.         int [] tmpArr=new int[data.length];
  213.         int mid=center+1;
  214.         //third記錄中間陣列的索引  
  215.         int third=left;
  216.         int tmp=left;
  217.         while(left<=center&&mid<=right){
  218.             //從兩個陣列中取出最小的放入中間陣列  
  219.             if(data[left]<=data[mid]){
  220.                 tmpArr[third++]=data[left++];
  221.             }else{
  222.                 tmpArr[third++]=data[mid++];
  223.             }
  225.         }
  227.         //剩餘部分依次放入中間陣列  
  228.         while(mid<=right){
  229.             tmpArr[third++]=data[mid++];
  230.         }
  232.         while(left<=center){
  233.             tmpArr[third++]=data[left++];
  234.         }
  236.         //將中間陣列中的內容複製回原陣列  
  237.         while(tmp<=right){
  238.             data[tmp]=tmpArr[tmp++];
  239.         }
  240.         //System.out.println(Arrays.toString(data));  
  241.     }
  243.     //8.基數排序   --用於大量數，很長的數進行排序時。
  244.     //將所有待比較數值統一為同樣的數位長度，數位較短的數前面補零。然後，從最低位開始，依次進行一次排序。這樣從最低位排序一直到最高位排序完成以後,數列就變成一個有序序列。
  245.     public void radixSort (int[] array) {
  246.         //首先確定排序的趟數;     
  247.         int max = array[0];
  248.         for (int i = 1; i < array.length; i++) {
  249.             if (array[i] > max) {
  250.                 max = array[i];
  251.             }
  252.         }
  253.         int time = 0;
  254.         //判斷位數;     
  255.         while (max > 0) {
  256.             max /= 10;
  257.             time++;
  258.         }
  259.         //建立10個佇列;     
  260.         List<ArrayList> queue = new ArrayList<ArrayList>();
  261.         for (int i = 0; i < 10; i++) {
  262.             ArrayList<Integer> queue1 = new ArrayList<Integer>();
  263.             queue.add(queue1);
  264.         }
  265.         //進行time次分配和收集;     
  266.         for (int i = 0; i < time; i++) {
  267.             //分配陣列元素;     
  268.             for (int j = 0; j < array.length; j++) {
  269.                 //得到數字的第time+1位數;   
  270.                 int x = array[j] % (int) Math.pow(10, i + 1) / (int) Math.pow(10, i);
  271.                 ArrayList<Integer> queue2 = queue.get(x);
  272.                 queue2.add(array[j]);
  273.                 queue.set(x, queue2);
  274.             }
  275.             int count = 0;//元素計數器;     
  276.             //收集佇列元素;     
  277.             for (int k = 0; k < 10; k++) {
  278.                 while (queue.get(k).size() > 0) {
  279.                     ArrayList<Integer> queue3 = queue.get(k);
  280.                     array[count] = queue3.get(0);
  281.                     queue3.remove(0);
  282.                     count++;
  283.                 }
  284.             }
  285.         }
  286.         this.printAll(array);
  287.     }
  289.     //9.類方法降序排列
  290.     public void ArraySort(int[] a){
  291.         Arrays.sort(a);
  292.         //this.printAll(a);
  293.         for(int i=0,j=a.length-1;i<j;i++,j--){
  294.             int temp=a[i];
  295.             a[i]=a[j];
  296.             a[j]=temp;
  297.         }
  298.         this.printAll(a);
  299.     }
  301. }

相關推薦

Java常用的九種排序方法及程式碼實現

  package com.algorithm.Demo; import java.util.ArrayList; import java.util.Arrays; import j

Java常用的八種排序演算法與程式碼實現（三）：桶排序、計數排序、基數排序

三種線性排序演算法：桶排序、計數排序、基數排序 線性排序演算法（Linear Sort）：這些排序演算法的時間複雜度是線性的O(n)，是非比較的排序演算法 桶排序（Bucket Sort） 　　將要排序的資料分到幾個有序的桶裡，每個桶裡的資料再單獨進行排序，桶內排完序之後，再把桶裡的

Java常用的八種排序演算法與程式碼實現（二）：歸併排序法、快速排序法

注：這裡給出的程式碼方案都是通過遞迴完成的 －－－ 歸併排序（Merge Sort）： 　　分而治之，遞迴實現 　　如果需要排序一個數組，我們先把陣列從中間分成前後兩部分，然後對前後兩部分進行分別排序，再將排好序的數組合並在一起，這樣整個陣列就有序了 　　歸併排序是穩定的排序演算法，時間

Java常用的八種排序演算法與程式碼實現（一）：氣泡排序法、插入排序法、選擇排序法

這三種排序演算法適合小規模資料排序 －－－ 　　共同點：基於比較，時間複雜度均為O(n2)，空間複雜度均為O(1)（原地排序演算法） 　　不同點：插入排序和氣泡排序是穩定的排序演算法，選擇排序不是 －－－ 　　穩定排序演算法：可以保持數值相等的兩個物件，在排序之

Java常用的八種排序演算法與程式碼實現(一)

本文需要5分鐘左右閱讀完成，建議收藏以後閱讀，裡面都是乾貨，可以親自試驗一下，如果覺得好用可以幫忙點贊轉發一下，謝謝！交流學習java大資料可以加群460570824。 1.直接插入排序 經常碰到這樣一類排序問題：把新的資料插入到已經排好的資料列中。 將第一個數和第二個數

一遍記住Java常用的八種排序演算法與程式碼實現

1.直接插入排序 經常碰到這樣一類排序問題：把新的資料插入到已經排好的資料列中。 將第一個數和第二個數排序，然後構成一個有序序列將第三個數插入進去，構成一個新的有序序列。對第四個數、第五個數……直到最後一個數，重複第二步。 如何寫寫成程式碼： 首先設定插入次數，即迴圈

Java 常用的八種排序演算法與程式碼實現

寫排序演算法是一個大工程，估計得好多天才可以寫完。。。就慢慢寫吧。未完待續。。。。 內部排序和外部排序 內部排序是資料記錄在記憶體中進行排序，而外部排序是因排序的資料很大，一次不能容納全部的排序記錄，在排序過程中需要訪問外存。 我們這裡說說八大排序就是

Java常用的八種排序演算法與程式碼實現--轉載

1.直接插入排序      我們經常會到這樣一類排序問題：把新的資料插入到已經排好的資料列中。將第一個數和第二個數排序，然後構成一個有序序列將第三個數插入進去，構成一個新的有序序列。對第四個數、第五個數……直到最後一個數，重複第二步。如題所示：直接插入排序（Straight

Java四種排序方法及99乘法口訣表

import java.util.Arrays; public class Sort { /**排序 * @param args */ public static void main(String[] args) { int array[]={12,3

設計模式：Java常用23種設計模式及六大原則簡介

目錄 簡介 建立型模式 結構型模式 行為型模式 簡介 設計模式（Design pattern）代表了最佳的實踐，通常被有經驗的面向物件的軟體開發人員所採用。設計模式是軟體開發人員在軟體開發過程中面臨的一般問題的解決方案。這些解決方案是眾多軟體開發人員經

Java常用八種排序演算法

直接插入排序/** * 1.直接插入排序（穩定） * 原理：將陣列分為無序區和有序區兩個區，然後不斷將無序區的第一個元素按大小順序插入到有序區中去，最終將所有無序區元素都移動到有序區完成排序。 * 要點：設立哨兵，作為臨時儲存和判斷陣列邊界之用。 * */ publ

Java陣列3種排序方法

一、陣列封裝好的排序方法              public static void main(String[] args) {         i

Java中的選擇排序和氣泡排序思想及程式碼實現

選擇排序 選擇排序基本思想(假設從大到小排序)： 初始化一個數組：int[] array={n個數據} 第1次排序：將索引為0的元素取出來，用該元素與之後的每一個元素做比較，比該元素小則不動，比該元素大則交換二者的數值，依次比較到最後，這樣最大值就放到了索引為0

Android Design: 九種常見Activity及程式碼解析之"Navigation Drawer Activity"

Navigation Drawer Activity 如果我們是直接new一個“Navigation Drawer Activity”,自動生成的程式碼如下： NavigationDrawerActivity.java public class NavigationDra

四種聚類方法及程式碼實現。K-means 高斯聚類 密度聚類 均值漂移聚類

四種方法的matlab程式碼實現：連結: https://pan.baidu.com/s/1b6pKH65rYrRcBLnczz-EnA 密碼: 4iag1.K-means聚類：演算法步驟： (1) 首先我們選擇一些類/組，並隨機初始化它們各自的中心點。中心點是與每個資料點向

陣列排序方法及C實現的總結

1、問題描述     陣列排序（即按某種特定的順序排列資料，如升序或降序）是最重要的計算應用之一，銀行用帳號對所有的支票進行能夠排序，並根據排序結果準備月底的財務報告，學校學生成績管理系統用陣列排序的方法將考試成績從高到低進行排名，陣列排序方法很多，有直接插入排序、氣泡排序

大牛的23種設計模式及程式碼實現全解析

一、設計模式的分類 總體來說設計模式分為三大類： 建立型模式，共五種：工廠方法模式、抽象工廠模式、單例模式、建造者模式、原型模式。 結構型模式，共七種：介面卡模式、裝飾器模式、代理模式、外觀模式、橋接模式、組合模式、享元模式。 行為型模式，共十一種：策略模式、模板

Java讀取資料夾大小的6種方法及程式碼

這篇文章介紹了JAVA讀取資料夾大小的幾種方法例項，有需要的朋友可以參考一下。 (一)單執行緒遞迴方式 package com.taobao.test; import java.io.File; public class TotalFileSizeSequential { pub

設計模式（建立型）：Java常用23種設計模式之單例模式詳解以及Java程式碼實現

可以說單例模式是所有設計模式中最簡單的一種。 單例模式就是說系統中對於某類的只能有一個物件，不可能出來第二個。 單例模式也是23中設計模式中在面試時少數幾個會要求寫程式碼的模式之一。主要考察的是多執行緒下面單例模式的執行緒安全性問題。 1.多執行緒安全單例模式例項一(不使用同步鎖)

在java中對LIst集合的兩種排序方法(即sort的使用方法)

List集合的排序: java提供了兩種排序方式,分別是Collections.sort(List)和Collections.sort(List,Commparator),下面就這兩種方法的使用做詳細的說明: -Collections.sort(List); sort的引數是一