遞迴法
public void sort(int nums, int l, int r)
nums[i] = x;
sort(nums, l, i-1);
sort(nums, i+1, r);
}}
非遞迴法
private static int partition(int nums, int start, int end)
nums[start] = pivot;
return start;
}public static void sort(int nums, int start, int end)
if(mid+1 < right)
}}
1. 僅交換值
public void partition(listnode head, listnode tail)
curr = curr.next;
}swap(head, left);
partition(head, left);
partition(left.next, tail);
}void swap(listnode n1, listnode n2)
2. 節點交換
public listnode partition(listnode head)
else
curr = curr.next;
}l.next = rs.next;
r.next = null;
listnode right = partition(head.next);
head.next = null;
listnode left = partition(ls.next);
curr = left;
while(curr.next != null)
curr = curr.next;
curr.next = right;
return left;
}
public void sort(int nums)
for(int i = len-1; i > 0; i--)
}private void adjust(int nums, int i, int len)
if(tmp < nums[k])
else break;
}}private void swap(int nums, int i, int j)
public void sort(int nums)
}if(falg) break;
}}private void swap(int nums, int i, int j)
o(n)，最差：o(n^2)。
穩定性：穩定。
public void sort(int nums)
if(min != i)
swap(nums, i, min);
}}private void swap(int nums, int i, int j)
o(n^2)。
穩定性：不穩定。
public void sort(int nums)
}private void swap(int nums, int i, int j)
o(n)，最差：o(n^2)。
穩定性：穩定。
public void sort(int nums)
nums[k + gap] = tmp;}}
if(gap == 1) break;
}}
o(n^2)。
穩定性：不穩定。
public int sort(int nums, int l, int r) ;
int mid = l + (r - l) / 2;
int left = sort(nums, l, mid);
int right = sort(nums, mid + 1, r);
int newarr = new int[left.length + right.length);
int i = 0, j = 0, k = 0;
while(i < left.length && j < right.length)
newarr[k++] = left[i] < right[j] ? left[i++] : right[j++];
while(i < left.length)
newarr[k++] = left[i++];
while(j < right.length)
newarr[k++] = right[j++];
return newarr;
}
o(nlog n)
空間複雜度：o(n)
穩定性：穩定。
排序演算法小結
1 快速排序 quicksort 快速排序是乙個就地排序，分而治之，大規模遞迴的演算法。從本質上來說，它是歸併排序的就地版本。快速排序可以由下面四步組成。1 如果不多於1個資料，直接返回。2 一般選擇序列最左邊的值作為支點資料。3 將序列分成2部分，一部分都大於支點資料，另外一部分都小於支點資料。4...
排序演算法小結
1 歸併排序 3.區別與聯絡 遞迴是從未知推到已知，相當於把未知的東西壓入棧，等到可以算出結果了，就一步一步出棧。迭代是從已知到未知，從已知的東西一步一步推至目標。遞迴與迭代就好像一對逆元。遞迴的 更加清晰，但開銷更大，也更容易出錯，除錯較困難 而迭代的 編寫更困難，但速度和開銷較小。4.空間占用 ...
排序演算法小結
演算法過程 假設乙個無序的序列，該演算法將其分成兩部分，前一部分已經完成排序 有序，一開始時只有乙個元素 後一部分任然無序，將後面序列選擇第乙個插入到前面的有序序列，如此直到所有完全有序。複雜度 最簡單的即為,整個序列原來即有序，按照一種最 省事 的方式，我們僅需比較n 1次即可。最複雜的情況，應該...