㈠ 排序都有哪幾種方法用java實現一個快速排序。
排序的方法有：插入排序（直接插入排序、希爾排序），交換排序（冒泡排序、快速排序），選擇排序（直接選擇排序、堆排序），歸並排序，分配排序（箱排序、基數排序）
快速排序的偽代碼。
/ /使用快速排序方法對a[ 0 :n- 1 ]排序
從a[ 0 :n- 1 ]中選擇一個元素作為m i d d l e，該元素為支點
把餘下的元素分割為兩段left 和r i g h t，使得l e f t中的元素都小於等於支點，而right 中的元素都大於等於支點
遞歸地使用快速排序方法對left 進行排序
遞歸地使用快速排序方法對right 進行排序
所得結果為l e f t + m i d d l e + r i g h t
㈡ JAVA實現插入排序
public class Test {
public static void main(String[] args) {
int[] source = { 1, 3, 2, 5, 12, 3, 123, 23, 2, 541, 1, 76, 76 };
Test test = new Test();
test.printArray(source);
test.insertSort(source);
test.printArray(source);
}
public void insertSort(int[] source) {
for (int i = 1; i < source.length; i++) {
for (int j = i; (j > 0) && (source[j] < source[j - 1]); j--) {
swap(source, j, j - 1);
}
}
printArray(source);// 輸出插入排序後的數組值
}
private void swap(int[] source, int x, int y) {
int temp = source[x];
source[x] = source[y];
source[y] = temp;
}
public void printArray(int[] source) {
for (int i : source) {
System.out.print(i + " ");
}
System.out.println();
}
}
㈢ 請給出java幾種排序方法
java常見的排序分為：
1 插入類排序
主要就是對於一個已經有序的序列中，插入一個新的記錄。它包括：直接插入排序，折半插入排序和希爾排序
2 交換類排序
這類排序的核心就是每次比較都要「交換」，在每一趟排序都會兩兩發生一系列的「交換」排序，但是每一趟排序都會讓一個記錄排序到它的最終位置上。它包括：起泡排序，快速排序
3 選擇類排序
每一趟排序都從一系列數據中選擇一個最大或最小的記錄，將它放置到第一個或最後一個為位置交換，只有在選擇後才交換，比起交換類排序，減少了交換記錄的時間。屬於它的排序：簡單選擇排序，堆排序
4 歸並類排序
將兩個或兩個以上的有序序列合並成一個新的序列
5 基數排序
主要基於多個關鍵字排序的。
下面針對上面所述的演算法，講解一些常用的java代碼寫的演算法
二 插入類排序之直接插入排序
直接插入排序,一般對於已經有序的隊列排序效果好。
基本思想：每趟將一個待排序的關鍵字按照大小插入到已經排序好的位置上。
演算法思路，從後往前先找到要插入的位置，如果小於則就交換，將元素向後移動，將要插入數據插入該位置即可。時間復雜度為O(n2),空間復雜度為O(1)
package sort.algorithm;
public class DirectInsertSort {
public static void main(String[] args) {
// TODO Auto-generated method stub
int data[] = { 2, 6, 10, 3, 9, 80, 1, 16, 27, 20 };
int temp, j;
for (int i = 1; i < data.length; i++) {
temp = data[i];
j = i - 1;
// 每次比較都是對於已經有序的
while (j >= 0 && data[j] > temp) {
data[j + 1] = data[j];
j--;
}
data[j + 1] = temp;
}
// 輸出排序好的數據
for (int k = 0; k < data.length; k++) {
System.out.print(data[k] + " ");
}
}
}
三 插入類排序之折半插入排序(二分法排序)
條件：在一個已經有序的隊列中，插入一個新的元素
折半插入排序記錄的比較次數與初始序列無關
思想：折半插入就是首先將隊列中取最小位置low和最大位置high，然後算出中間位置mid
將中間位置mid與待插入的數據data進行比較，
如果mid大於data，則就表示插入的數據在mid的左邊，high=mid-1;
如果mid小於data，則就表示插入的數據在mid的右邊,low=mid+1
最後整體進行右移操作。
時間復雜度O(n2),空間復雜度O(1)
package sort.algorithm;
//折半插入排序
public class HalfInsertSort {
public static void main(String[] args) {
int data[] = { 2, 6, 10, 3, 9, 80, 1, 16, 27, 20 };
// 存放臨時要插入的元素數據
int temp;
int low, mid, high;
for (int i = 1; i < data.length; i++) {
temp = data[i];
// 在待插入排序的序號之前進行折半插入
low = 0;
high = i - 1;
while (low <= high) {
mid = (low + high) / 2;
if (temp < data[mid])
high = mid - 1;
else
// low=high的時候也就是找到了要插入的位置，
// 此時進入循環中，將low加1，則就是要插入的位置了
low = mid + 1;
}
// 找到了要插入的位置，從該位置一直到插入數據的位置之間數據向後移動
for (int j = i; j >= low + 1; j--)
data[j] = data[j - 1];
// low已經代表了要插入的位置了
data[low] = temp;
}
for (int k = 0; k < data.length; k++) {
System.out.print(data[k] + " ");
}
}
}
四 插入類排序之希爾排序
希爾排序，也叫縮小增量排序，目的就是盡可能的減少交換次數，每一個組內最後都是有序的。
將待續按照某一種規則分為幾個子序列，不斷縮小規則，最後用一個直接插入排序合成
空間復雜度為O(1)，時間復雜度為O(nlog2n)
演算法先將要排序的一組數按某個增量d（n/2,n為要排序數的個數）分成若干組，每組中記錄的下標相差d.對每組中全部元素進行直接插入排序，然後再用一個較小的增量（d/2）對它進行分組，在每組中再進行直接插入排序。當增量減到1時，進行直接插入排序後，排序完成。
package sort.algorithm;
public class ShellSort {
public static void main(String[] args) {
int a[] = { 1, 54, 6, 3, 78, 34, 12, 45, 56, 100 };
double d1 = a.length;
int temp = 0;
while (true)
{
//利用這個在將組內倍數減小
//這里依次為5,3,2,1
d1 = Math.ceil(d1 / 2);
//d為增量每個分組之間索引的增量
int d = (int) d1;
//每個分組內部排序
for (int x = 0; x < d; x++)
{
//組內利用直接插入排序
for (int i = x + d; i < a.length; i += d) {
int j = i - d;
temp = a[i];
for (; j >= 0 && temp < a[j]; j -= d) {
a[j + d] = a[j];
}
a[j + d] = temp;
}
}
if (d == 1)
break;
}
for (int i = 0; i < a.length; i++)
System.out.print(a[i]+" ");
}
}
五 交換類排序之冒泡排序
交換類排序核心就是每次比較都要進行交換
冒泡排序：是一種交換排序
每一趟比較相鄰的元素，較若大小不同則就會發生交換，每一趟排序都能將一個元素放到它最終的位置！每一趟就進行比較。
時間復雜度O(n2)，空間復雜度O(1)
package sort.algorithm;
//冒泡排序：是一種交換排序
public class BubbleSort {
// 按照遞增順序排序
public static void main(String[] args) {
// TODO Auto-generated method stub
int data[] = { 2, 6, 10, 3, 9, 80, 1, 16, 27, 20, 13, 100, 37, 16 };
int temp = 0;
// 排序的比較趟數,每一趟都會將剩餘最大數放在最後面
for (int i = 0; i < data.length - 1; i++) {
// 每一趟從開始進行比較，將該元素與其餘的元素進行比較
for (int j = 0; j < data.length - 1; j++) {
if (data[j] > data[j + 1]) {
temp = data[j];
data[j] = data[j + 1];
data[j + 1] = temp;
}
}
}
for (int i = 0; i < data.length; i++)
System.out.print(data[i] + " ");
}
}
㈣ Java插入排序
Java程序入口是main函數，
而main函數的參數必須是String[] args;
所以你要把函數名mian改成其他如sort，並新寫一個main函數來調用他。
public static void main(String[] args){
}
㈤ Java 直接插入排序法
比如數組[3，2，1，5]
這段處理就返回[1，2，3，5]
它的處理是從第二位開始依次跟前邊的比，比前邊的小就往前移動。
也就是[3，2，1，5]
[2，3，1，5]
[1，2，3，5]
(int j = i - 1; j >= 0 && temp < array[j]; j--)
i是這次處理的下標，第一次是1，第二次是2，第三次是3，對應上邊原數組里的2，1，5
處理開始時把下標i對應的值存在temp里，j表示的是i前邊的下標，temp < array[j]的時候說明i下標的值比前邊的小，所以把小的值拿到前邊去。
這么看是很抽象的，自己在本上寫的數組，畫一下處理過程會更有助於你理解。
㈥ java 直接插入排序的例子
public void insertSort(int[] data)
{
int length = data.length();//獲取數組長度
for(int i=1;i<length;i++)
{
int tmp = data[i];
if(tmp<data[i-1])
{
int j = i-1;
for(;j>=0&&data[j]>tmp;j--)
{
data[j+1] = data[j];
}
data[j+1] = tmp;
}
}
}
大概就是這樣，有什麼問題問我吧。
希望能對你有所幫助，謝謝
㈦ java數組的插入排序
什麼狗蛋書,完全不知道在搞什麼.
要排序直接用API里的Arrays工具類就好.要學原理那都是數學的問題.代碼講究不要重復發明輪子.
排序這種大眾功能肯定已經有高手寫好了效率非常高的.完全沒有必要再去寫
㈧ java怎麼實現排序
Java實現幾種常見排序方法
日常操作中常見的排序方法有：冒泡排序、快速排序、選擇排序、插入排序、希爾排序，甚至還有基數排序、雞尾酒排序、桶排序、鴿巢排序、歸並排序等。
以下常見演算法的定義
1. 插入排序：插入排序基本操作就是將一個數據插入到已經排好序的有序數據中，從而得到一個新的、個數加一的有序數據，演算法適用於少量數據的排序，時間復雜度為O(n^2)。是穩定的排序方法。插入排序的基本思想是：每步將一個待排序的紀錄，按其關鍵碼值的大小插入前面已經排序的文件中適當位置上，直到全部插入完為止。
2. 選擇排序：選擇排序（Selection sort）是一種簡單直觀的排序演算法。它的工作原理是每一次從待排序的數據元素中選出最小（或最大）的一個元素，存放在序列的起始位置，直到全部待排序的數據元素排完。 選擇排序是不穩定的排序方法。
3. 冒泡排序：冒泡排序（Bubble Sort），是一種計算機科學領域的較簡單的排序演算法。它重復地走訪過要排序的數列，一次比較兩個元素，如果他們的順序錯誤就把他們交換過來。走訪數列的工作是重復地進行直到沒有再需要交換，也就是說該數列已經排序完成。這個演算法的名字由來是因為越大的元素會經由交換慢慢「浮」到數列的頂端。
4. 快速排序：快速排序（Quicksort）是對冒泡排序的一種改進。它的基本思想是：通過一趟排序將要排序的數據分割成獨立的兩部分，其中一部分的所有數據都比另外一部分的所有數據都要小，然後再按此方法對這兩部分數據分別進行快速排序，整個排序過程可以遞歸進行，以此達到整個數據變成有序序列。
5. 歸並排序：歸並排序是建立在歸並操作上的一種有效的排序演算法,該演算法是採用分治法（Divide and Conquer）的一個非常典型的應用。將已有序的子序列合並，得到完全有序的序列；即先使每個子序列有序，再使子序列段間有序。若將兩個有序表合並成一個有序表，稱為二路歸並。
6. 希爾排序：希爾排序(Shell Sort)是插入排序的一種。也稱縮小增量排序，是直接插入排序演算法的一種更高效的改進版本。希爾排序是非穩定排序演算法。希爾排序是把記錄按下標的一定增量分組，對每組使用直接插入排序演算法排序；隨著增量逐漸減少，每組包含的關鍵詞越來越多，當增量減至1時，整個文件恰被分成一組，演算法便終止。
https://www.cnblogs.com/wangmingshun/p/5635292.html
㈨ 關於java直接插入演算法的問題
/**這是一個利用直接插入排序法寫的一個小程序；
直接插入排序是一個將待排序列中的元素p[i]與一個有序序列中的元素q[j--]比較（從後向前）,當p[i] >= q[j] （遞增排序）或 p[i] <= q[j] （遞減排序）時，q[j+1] = p[i];反之就將q[j]移位到q[j+1]為p[i]的插入預留空間且如果j==0則q[j] = p[i].
*/
public class SISort
{
public static int[] sortAscending(int []with){ //整數遞增排序
int length = with.length; //獲取待排數組的元素個數；
int []temp = new int[length];
temp[0] = with[0]; //定義一個只有一個元素的有序數組
for(int i=1; i<length; i++){
for(int j=i-1; j>=0;j--){
if(with[i] >= temp[j]){ //如果待排序列中的元素大於等於有有序序列中的元素，則插入
temp[j+1] = with[i];
break;
}
else {
temp[j+1] = temp[j]; //給待插入元素預留空間
if(j == 0)
temp[j] = with[i]; //with[[i]是有序序列中最小的，因此排在開頭
}
}
}
return temp;
}
public static double[] sortAscending(double []with){ //帶小數的遞增排序
int length = with.length; //獲取待排數組的元素個數；
double []temp = new double[length];
temp[0] = with[0]; //定義一個只有一個元素的有序數組
for(int i=1; i<length; i++){
for(int j=i-1; j>=0;j--){
if(with[i] >= temp[j]){ //如果待排序列中的元素大於等於有有序序列中的元素，則插入
temp[j+1] = with[i];
break;
}
else {
temp[j+1] = temp[j]; //給待插入元素預留空間
if(j == 0)
temp[j] = with[i]; //with[[i]是有序序列中最小的，因此排在開頭
}
}
}
return temp;
}
public static double[] sortDescending(double []with){ //遞減排序
int length = with.length; //獲取待排數組的元素個數；
double []temp = new double[length];
temp[0] = with[0]; //定義一個只有一個元素的有序數組
for(int i=1; i<length; i++){
for(int j=i-1; j>=0;j--){
if(with[i] <= temp[j]){ //如果待排序列中的元素小於等於有有序序列中的元素，則插入
temp[j+1] = with[i];
break;
}
else {
temp[j+1] = temp[j]; //給待插入元素預留空間
if(j == 0)
temp[j] = with[i]; //with[[i]是有序序列中最大的，因此排在開頭
}
}
}
return temp;
}
public static int[] sortDescending(int []with){ //遞減排序
int length = with.length; //獲取待排數組的元素個數；
int []temp = new int[length];
temp[0] = with[0]; //定義一個只有一個元素的有序數組
for(int i=1; i<length; i++){
for(int j=i-1; j>=0;j--){
if(with[i] <= temp[j]){ //如果待排序列中的元素小於等於有有序序列中的元素，則插入
temp[j+1] = with[i];
break;
}
else {
temp[j+1] = temp[j]; //給待插入元素預留空間
if(j == 0)
temp[j] = with[i]; //with[[i]是有序序列中最大的，因此排在開頭
}
}
}
return temp;
}
/* public static void main(String[] args)
{
int []test1 = {2,6,5,8,7,9,10,256,248,14}; //測試數組
double []test2 = {1.1,2.0,3,5,6,8.9,99,5};
int []temp1; //中間變數
double []temp2;
temp1 = sortDescending(test1); //測試整數遞減排序
System.out.println("get a Decreasing sequence ");
for(int i=0; i<temp1.length; i++){
System.out.println(temp1[i]);
}
temp1 = sortAscending(test1); //測試整數遞增排序
System.out.println("get a Increasing sequence");
for(int i=0; i<temp1.length; i++){
System.out.println(temp1[i]);
}
temp2 = sortDescending(test2); //測試帶小數遞減排序
System.out.println("get a Decreasing sequence ");
for(int i=0; i<temp2.length; i++){
System.out.println(temp2[i]);
}
temp2 = sortAscending(test2); //測試帶小數遞增排序
System.out.println("get a Increasing sequence");
for(int i=0; i<temp2.length; i++){
System.out.println(temp2[i]);