63.如何对单链表进行快排？和数组快排的分析与对比[quicksort of array and linked list]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

/*

     version: 1.0

     author: hellogiser

     blog: http://www.cnblogs.com/hellogiser

     date: 2014/5/30
*/


// i from left,j from right

// i------------>p<-----------------j
int Partition(int a[], int left, int right)
{

    // partition so that a[left..p-1]<=a[p] and a[p+1..right]>a[p]

    int pivot = a[left], i = left , j = right;

    while (i < j)

     {

        while (a[i] <= pivot) i++;

        while (a[j] > pivot) j--;

        if (i < j)

             myswap(a[i], a[j]);

     }

     myswap(a[left], a[j]);

    return j;

}

void QuickSort(int a[], int left, int right)
{

    if(left < right) // less
    {

        int p = Partition(a, left, right);

         QuickSort(a, left, p - 1);

         QuickSort(a, p + 1, right);

     }
}

void  QuickSort(int a[], int n)
{

     QuickSort(a, 0, n - 1);

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

/*

     version: 1.0

     author: hellogiser

     blog: http://www.cnblogs.com/hellogiser

     date: 2014/5/30
*/


// i and j both from left

// i,j---------------->
int Partition2(int a[], int left, int right)
{

    // partition so that a[left..p-1]<=a[p] and a[p+1..right]>a[p]

    // left----i<=pivot, i----j>=pivot

    int pivot = a[left], i = left , j = left + 1;
    while (j <= right)

     {

        if (a[j] < pivot)

         {

             i++;

             myswap(a[i], a[j]);

         }

         j++;

     }

     myswap(a[left], a[i]);

    return i;

}

void QuickSort2(int a[], int left, int right)
{

    if(left < right) // less
    {

        int p = Partition2(a, left, right);

         QuickSort2(a, left, p - 1);

         QuickSort2(a, p + 1, right);

     }
}

void  QuickSort2(int a[], int n)
{

     QuickSort2(a, 0, n - 1);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

/*

     version: 1.0

     author: hellogiser

     blog: http://www.cnblogs.com/hellogiser

     date: 2014/5/30
*/


// i and j both from left

// i,j---------------->
node *Partition2_List(node *left, node *right)

{
    // partition so that a[left..p-1]<=a[p] and a[p+1..right]>a[p]

    // left----i<=pivot, i----j>=pivot

    node *pivot = left, *i = left , *j = left->next;

    while (j != right)

     {

        if (j->value < pivot->value)

         {

             i = i->next;

             myswap(i->value, j->value);

         }

         j = j->next;

     }

     myswap(left->value, i->value);

    return i;

}

void QuickSort2_List(node *left, node *right)

{
    if(left != right) // less
    {

         node *p = Partition2_List(left, right);

         QuickSort2_List(left, p);

         QuickSort2_List(p->next, right);

     }
}

void  QuickSort2_List(node *head)

{
     QuickSort2_List(head, NULL);

}