심플 시퀀싱

템플릿 기능 정렬 알고리즘

무효화 x_Sort (ElementType에 A [], INT의 N)

　　대부분의 경우, 간단하게하기 위해, 토론은 큰 정수에 작은에서 정렬

N은 인 양의 정수

논의에만 기반을 둔 비교를 (> = <정의) 정렬

만 논의 내부 정렬을

안정성 : 임의의 두 개의 동일한 데이터는 상대 위치가 이전과 주문 후 변하지 않는다

어떤 경우 최적의 성능에 어떤 종류의가 없습니다

버블 정렬

무효화 Bubble_Sort (ElementType에 A [], INT의 N)

{

　　INT 플래그;

　　{- (; P> = 0 P-- INT 1의 P = N)에 대한

　　　　플래그 = 0;

　　　　{// 트립 버블 링 (; 나 P를 <I ++는 i가 0 = INT)

　　　　　　경우 (A [i]를> A [I + 1]) {

　　　　　　　　스왑 (A [i]를, A [I + 1]);

　　　　　　　　플래그 = 1; // 교환의 발생을 파악

　　　　　　}

　　　　경우 (깃발 == 0) 휴식; // 전체 없음 교환

　　}

최상의 경우 : 서열 T = O (N)

최악의 경우 : T = O (N ^ 2)를 역방향

정렬 알고리즘 버블 정렬 알고리즘은 안정적이다.

삽입 정렬

/ ********** 삽입 정렬 알고리즘 ********************************************************** /

무효화 Insertion_Sort (ElementType에 A [], INT의 N)

{

　　ElementType에의 Tmp;

　　경우 (P = INT 1. ; P <N은, P는 ++) {// 기본 시작 시간은 단지 하나 개의 소자가 정렬 될 때

　　　　TMP = A [P]는, 카드, 즉 정렬되지 않은 서열을 가지고 첫번째 요소를 터치 //

　　　　대 (INT I = P; 나는> 0 && A [I - 1 ] "이 Tmp, 난 - )

　　　　　　A [I]는 = A [ I - 1이다. ]; // 갭, 즉, 소자가 정렬 된 이후에 서열 비교 및 우측 중

　　　　적절한 위치로 // 새로운 좌석, 즉, A [I] = 개의 Tmp

　　}

최상의 경우 : 서열 T = O (N)

최악의 경우 : T = O (N ^ 2)를 역방향

삽입 정렬은 안정적인 정렬 알고리즘

예 : {34, 8, 64, 51, 32, 21}, 거품 정렬 및 삽입의 초기 정렬 순서 감안

얼마나 많은 시간을 각 요소를 완료하는 데 교환 할 필요가 있겠습니까?

시간 하한

(I, J)라고 A [J], 역순으로 한 쌍의 첨자를 들어 난 <A [i]는 경우, J>를이 (반전)

문제점 : 번호 역순 시퀀스 {34, 8, 64, 51, 32, 21}?

(34, 8) (34, 32) (34, 21) (64, 51) (64, 32) (64, 21) (51, 32) (51, 21) (32, 21)

스왑 두 개의 인접한 요소는 역 순서를 제거!

삽입 정렬 : T (N, I) = O (N + I)

　　서열이 실질적으로 정렬하는 경우, 간단하고 효율적인 삽입 정렬

정리 다음 N의 평균을 갖는 일련의 다른 요소 N (N - 1) 중 / 4 역전 쌍

정리 : 상관 교환 알고리즘은 평균 시간 복잡도 Ω이며, 두 개의 인접한 정렬 원소 (N ^ 2)

이는 : 효율성을 개선하기 위해 우리가해야　

　　모든 하나 이상의 역순를 제거!

　　각 Exchange 두 가지 요소가 멀리 떨어져!

정렬 힐 (도널드 쉘에 의해)

증분 정의 시퀀스 D_m> D_ (m-1)> ...> d_1의 파라미터 = 1

각 D_k 용 - 정렬 "D_k 간격 '(K = M, M -1, ..., 1)

주 : "D_k 간격"순차적 시퀀스를 구현에서 "D_ (K - 1) - 간격"정렬 후, 여전히

"D_k - 간격"질서

힐 증분 순서

원래 힐 정렬 D_m = [N / 2] 내림, D_k가 = [D_ (K + 1) / 2] 내림

무효화 Shell_Sort (ElementType에 A [], INT의 N)

{

　　대 (INT D = N / 2, D> 0, D / 2 =) {// 증분 서열 힐

　　　　{// 삽입 정렬 (; P <N P ++ INT P = D)에 대한

　　　　　　TMP = A [P];

　　　　　　대해 (ⅰ = P에서 INT; I> = D && A [I - D]>의 Tmp, I - = D)

　　　　　　　　- [D I] A [I]는이 =

　　　　　　A [I]의 Tmp =;

　　　　}

최악의 경우 : T = Θ (N ^ 2)

더 증가 시퀀스

세지 증분 시퀀스

무효화 셸 정렬 (ElementType에 A [], INT의 N)

{// 쉘 종류 - 증가 시퀀스 세지를 사용하여

　　INT 경우, D, P, 및;

　　ElementType에의 Tmp;

　　// 여기에서 우리는 증가의 단지 작은 부분

　　INT 세지 [] = {929, 505, 209, 109, 41, 19, 5, 1, 0};

　　Si를 0 = (대; 세지 [그것은]> = N; 그는 ++)　

　　　　// 초기 증분 세지 [시]는 시퀀스의 길이가 정렬 될 초과하지

　　로그 (D = 세지 [시] D> 0; D = 세지 [실리콘 ++])

　　　　대 (; P <N; P = D P ++) {// 삽입 정렬

　　　　　　TMP = A [P];

　　　　　　대 (P = I, i가> = D && A [내가 - D]>의 Tmp, I - = D)

　　　　　　　　- [D I] A [I]는이 =

　　　　　　A [I]의 Tmp =;

　　　　}

힙 정렬

선택 정렬

보이드 Selection_Sort (ElementType에 A [], INT의 N)

{

　　대해 INT (I = 0; i가 N을 <; 내가 ++) {

　　　　MinPosition ScanForMin = (A, I, N - 1);

　　　　// A로부터 [I]을 사용하여 [N은 - 1] 가장 작은 요소를 찾고, 상기 위치를 지정하는 MinPosition

　　　　스왑 (A [i]를, A [MinPosition]);

　　　　// 정렬 된 부분의 최종 위치에 최소 정렬되지 않은 트랜스 듀서

　　}

얼마나 빨리 최소한의 요소를 찾는 방법은? ? ? ?

힙 정렬 알고리즘

알고리즘 1

보이드 Heap_Sort (ElementType에 A [], INT의 N)

{

　　BuildHeap (A); // 의 위에)

　　대해 INT (I = 0; i가 N을 <; 내가 ++)

　　　　TMPA [I] = DeleteMin (A); // O (logN)

　　(0 = 1을 나타내는 int i가 N을 <; I ++) // O (N)

　　　　A [I]를 TMPA가 = [I];

}

T (N)는 O을 = (N logN)

추가 O (N) 공간 및 요소를 복사하는 데 필요한 시간을 필요로한다.

알고리즘 2 :

보이드 Heap_Sort (ElementType에 A [], INT의 N)

{

　　// BuildHeap - (; I> = 0 1 int로 난 - I = N / 2)에 대한

　　　　PerDown (A, I, N);

　　대해 INT (N = I - 1; I> 0; 난 ...) {

　　　　스왑 (A [0], A [I]); // DeleteMax

　　　　PerDown (A, 0, I);

　　}

정리 : 비교의 평균 수는 임의로 배치되어 힙 정렬 처리 N 다른 요소는

　　LogN 2 N - O (N logN 로그).

힙 종류의 최고의 평균 시간 복잡도 만 증가 세지 힐 정렬 순서와 같은 실제 효과를 제공하지만.

- 코드 -

보이드 스왑 (ElementType에 * A, ElementType에 * b)

{

　　ElementType에의 t = *는;

　　* * A = B;

　　* B에서의 t =;

}

무효화 PerDown (ElementType에 A [], INT의 P, N의 INT)

{

　　// 배열 A [P]에 대한 N 요소는 서브 - 스택의 루트 최대 스택으로 조정된다

　　INT 학부모, 어린이,

　　ElementType에 X;

　　X = A [P]; // 루트에 저장된 값을 취

　　대 (부모 = P (부모 + 1 * 2) <N; ParentType = 어린이) {

　　　　어린이 부모 = * 2 + 1;

　　　　경우 ((자식! = N-1) && (A [어린이] <A [어린이 + 1]))

　　　　　　아이 ++; // 왼쪽과 오른쪽 자식 노드를 가리키는 아이 큰

　　　　(X> = A [어린이]) 깨지면 // 것은 올바른 위치를 찾아

　　　　다른 // 고려

　　　　　　A [부모] A [아이] =;

　　}

　　A [부모 =의 X;

}