分治算法上

分治策略

对于一个规模为n的问题，若该问题可以容易地解决（比如说规模n较小）则直接解决，否则将其分解为k个规模较小的子问题，这些子问题互相独立且与原问题形式相同，递归地解这些子问题，然后将各子问题的解合并得到原问题的解。 这种算法设计策略叫做分治法

1）快速排序：定义一个数组，使用快速排序算法将其中的元素按照从小到大的顺序进行排序。

    算法输出：排好序的数组

#include<stdio.h>

#include<stdlib.h>

#include<time.h>

#define NUMBER 10 //NUMBER为数组的大小

int partition(int [],int ,int);

void quickSort(int [],int,int);

void display(int [],int);

int main()

{

  int num[NUMBER];

  int randValue = 0;

  int i,temp;

  

  srand(time(NULL));

  //随机生成NUMBER个1-100的随机数

  for(i=0;i<NUMBER;i++)

  {

        randValue=1+(int)rand()%100;

        num[i]=randValue;

  }

  srand(time(NULL));

  printf("使用快速排序算法\n");

  printf("排序前：");

  display(num,NUMBER);//打印数组内容

  quickSort(num,0,NUMBER-1);//调用快速排序算法

  printf("排序后：");

  display(num,NUMBER);

  return 0;

}

void quickSort(int num[],int lower,int upper)

{

    int pivot;

//递归调用

    pivot=partition(num,lower,upper);

    if(lower < pivot)

        quickSort(num,lower,pivot-1);

    if(pivot < upper)

        quickSort(num,pivot+1,upper);

}

int partition(int num[],int left,int right)

{

     int pivot,temp;

     

     pivot = num[left];

     while(left<right)

     {

      //从右往左扫描

        while(num[right]>=pivot && left<right)

            right--;

        if(right!=left)

        {

            num[left]=num[right];

            left++ ;

        }

        

        //从左往右扫描

        while(num[left]<=pivot && left<right)

            left++;

        if(right!=left)

        {

            num[right]=num[left];

            right--;

        }

     }

     num[left]=pivot;

     return(left);

}

//打印数组

void display(int num[],int count)

{

    int i;

    for(i=0;i<count;i++)

    {

         printf("%d\t",num[i]);

    }

    printf("\n");

}

2）归并排序：定义一个数组，使用快速排序算法将其中的元素按照从小到大的顺序进行排序。

算法输出：排好序的数组。

#include<iostream>

using namespace std;

void mergeAdd(int* a, int begin, int middle, int end,int *b) {

int index = begin;

int left = begin;

int right = middle;

while (left <= middle - 1 && right <= end)

b[index++] = (a[left] > a[right] ? a[right++] : a[left++]);//取小值

while (left <= middle - 1)

b[index++] = a[left++];

while (right <= end)

b[index++] = a[right++];

memcpy(a+begin, b+begin, sizeof(int) * (end - begin + 1));

}

void mergeSort(int* a, int begin, int end, int* b){

if (end > begin) {

int index = begin + (end - begin) / 2;

mergeSort(a, begin, index,b);

mergeSort(a, index+1, end, b);

mergeAdd(a, begin, index+1, end, b);

}

}

int main() {

int a[] = {163,161,158,165,171,170,163,159,162};

int len = sizeof(a) / sizeof(int);

int* b = new int[len];

int middle = len / 2;

mergeSort(a, 0, len - 1,b);

for (int i = 0; i < len; i++)

cout << a[i] << endl;

system("pause");

return 0;