C++博客-Aaron学习笔记-文章分类-算法设计与分析

归并排序的C语言实现

赞劲小子 — Thu, 24 Sep 2009 05:10:00 GMT

算法基本思想：将要排序的数组分成两部分，先对每部分进行排序，然后再将两部分已经排序好的子数组的元素按从小到大的顺序交替地摆放在一个新的数组中。这一过程时常需要多次分解和组合，因而是一个递归过程。

#include "stdio.h"
#include "malloc.h"

#define arraySize 11

void mergeSort(int a[], int low, int high);
void merge(int a[], int low, int mid, int high);
void print(int a[], int n);
static int count = 1;  //***************测试语句
int main(){
    int a[11] = {0,-1,5,6,2,8,10,3,56,32,43};
    int i;
    mergeSort(a,0,arraySize-1);
    for(i = 0; i < arraySize; i++)
        printf("%d ",a[i]);

    return 0;
}

void mergeSort(int a[], int low, int high){
    int mid;

    printf("mergeSort 进行了%d次\n",count);
    if(low < high){
        mid = (low + high) / 2;
        mergeSort(a,low,mid);
        mergeSort(a,mid+1,high);
        merge(a,low,mid,high); //将数组A[low:mid]和A[mid+1:high]进行合并。
    }
    count++;
}

void merge(int a[], int low, int mid, int high){
    /*
     *    将数组a[low : mid] 和数组a[mid+1 : high]进行有序合并
     */
    int *tempArray = (int *)malloc(sizeof(int) * (high + 1));
    int h,i,j,k;
    h = low;  //游离第一个数组的下标
    i = low;  //用于
    j = mid + 1; //用于要合并的第二个数组的出下标
    while(h <= mid && j <=high)
    {
        if(a[h] <= a[j]){
            tempArray[i] = a[h];
            h = h+1;
        }
        else
        {
            tempArray[i] = a[j];
            j = j+1;
        }
        i = i + 1;
    }
    /*
     *    元素没取尽时的处理
     */
    if(h > mid){  //第一个数组取尽，第二个数组未被取尽
        for(k = j; k <= high; k++){
            tempArray[i] = a[k];
            i++;
        }
    }
    else
    {
        for(k = h; k <= mid; k++){
            tempArray[i] = a[k];
            i++;
        }
    }
   /*
    *    最后将tempArray数组赋值给a
    */
    for( k = low; k <= high; k++)
    {
        a[k] = tempArray[k];
    }
/*    print(tempArray,10);*/
    free(tempArray);
}

void print(int a[], int n){
    int i;
    printf("数组是");
    for(i = 0; i < n ; i++){
        printf("%d ",a[i]);
    }
    printf("\n");
}

赞劲小子 2009-09-24 13:10 发表评论

快速排序算法的实现

赞劲小子 — Thu, 24 Sep 2009 03:03:00 GMT

快速排序是C.R.A.Hoare于1962年提出的一种划分交换排序。它采用了一种分治的策略，通常称其为分治法(Divide-and-ConquerMethod)。

分治法的基本思想是：将原问题分解为若干个规模更小但结构与原问题相似的子问题。递归地解这些子问题，然后将这些子问题的解组合为原问题的解。

快速排序算法的基本思想是：在待排序的n个记录中任取一个记录（通常先取第一个）为分区标准，把所有小于该排序码的记录移动到左边，把所有大于该排序码的记录移动到右边，中间放所选记录，称之为一趟排序；然后，对两个子序列分别重复上述过程
快速排序(QuickSort)的最坏时间复杂度应为0(n2)，最好时间复杂度为O(nlgn)，平均时间复杂度为O(nlgn)。快速排序(QuickSort)在系统内部需要一个栈来实现递归。若每次划分较为均匀，则其递归树的高度为O(lgn)，故递归后需栈空间为O(lgn)。最坏情况下，递归树的高度为O(n)，所需的栈空间为O(n)。

#include "stdio.h"

void qsort(int s[], int l, int r);

int main(){
    int array[10] = {2,4,6,1,8,7,9,10,0,3};
    int i;
    qsort(array,0,9);
    for(i = 0; i < 10; i++)
        printf("%d ",array[i]);
    return 0;
}
void qsort(int s[], int l, int r)  //l,r已经是数组的下标了，即最初的r = n-1
{
    int i, j, x;
    if (l < r)
    {
        i = l; //i代表从数组最左面开始的下标号
        j = r;  //j代表从数组最右开始的下标
        x = s[i]; /* 中间变量*/
        while (i != j)
        {
            while(i < j && s[j] > x)
                j--; /* 从右向左找第一个小于x的数 */
            if(i < j)
                s[i++] = s[j];
            while(i < j && s[i] < x)
                i++; /* 从左向右找第一个大于x的数 */
            if(i < j)
                s[j--] = s[i];
        }
        s[i] = x;
        qsort(s, l, i-1); /* 递归调用 */
        qsort(s, i+1, r);
    }
}

赞劲小子 2009-09-24 11:03 发表评论

选择排序

赞劲小子 — Thu, 26 Mar 2009 03:16:00 GMT

直接选择排序的基本思想
   　 n个记录的文件的直接选择排序可经过n-1趟直接选择排序得到有序结果：
①初始状态：无序区为R[1..n]，有序区为空。
②第1趟排序
    　在无序区R[1..n]中选出关键字最小的记录R[k]，将它与无序区的第1个记录R[1]交换，使R[1..1]和R[2..n]分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区。
……
③第i趟排序
第i趟排序开始时，当前有序区和无序区分别为R[1..i-1]和R[i..n](1≤i≤n-1)。该趟排序从当前无序区中选出关键字最小的记录 R[k]，将它与无序区的第1个记录R[i]交换，使R[1..i]和R[i+1..n]分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区。
    　这样，n个记录的文件的直接选择排序可经过n-1趟直接选择排序得到有序结果。

#include "iostream.h"

void selectionSort(int array[], const int size);

int main(){
    const int size = 10;
    int array[size] = {3,5,1,8,7,4,2,9,6,10};
    selectionSort(array,size);
    for(int i = 0; i < size; i++){
        cout << array[i] << "  ";
    }
    return 0;
}

void selectionSort(int array[], const int size){
    int min; // 最小值的位置
    int pass,j; //循环控制
    int temp;
    for(pass = 0; pass < size - 1; pass++){
        min = pass;
        for(j = pass + 1; j < size; j++){
            if(array[j] < array[min])
                min = j;
        }
        if(min != pass){
            temp = array[pass];
            array[pass] = array[min];
            array[min] = temp;
        }
    }
}

赞劲小子 2009-03-26 11:16 发表评论

折半查找

赞劲小子 — Tue, 24 Mar 2009 07:47:00 GMT

折半查找时，先得将数组排序。

/**
  * 将数列按有序化(递增或递减)排列，查找过程中采用跳跃式方式查找，即先以有序数列的中点位置
  * 为比较对象，如果要找的元素值小于该中点元素，则将待查序列缩小为左半部分，否则为右半部分。
  * 通过一次比较，将查找区间缩小一半。折半查找是一种高效的查找方法。它可以明显减少比较次数，
  * 提高查找效率。但是，折半查找的先决条件是查找表中的数据元素必须有序。
**/
#include "iostream.h"

void bubble(int array[], int size);
int binarysearch(int array[], int searchkey, int low, int high, int size);

int main(){
    int array[10] = {7,6,8,5,10,9,2,4,3,1};
    int array1[9] = {7,6,8,5,10,9,2,4,3};
    bubble(array,10); // 数组元素为偶数
    bubble(array1,9); // 数组元素为奇数
    cout << binarysearch(array,1,0,9,10);
    cout << binarysearch(array,4,0,8,9);
    return 0;
}

void bubble(int array[], int size){
    bool tag;
    for(int pass = 0; pass < size - 1; pass++ ){
        tag = true;
        for(int j = 0 ; j < size - 1; j++)
        {

            int temp;
            if(array[j] > array[j + 1]){
                temp = array[j];
                array[j] = array[j+1];
                array[j+1] = temp;
                tag = false;
            }
        }
        if(tag == true)
            return ;
    }
}
int binarysearch(int array[], int searchkey, int low, int high, int size){
    int middle;
    while(low <= high){
        middle = (low + high) / 2;
        if(searchkey == array[middle])
            return middle;
        else if(searchkey > array[middle])
            low = middle + 1;
        else
            high = middle - 1;
    }
    return -1;
}

赞劲小子 2009-03-24 15:47 发表评论

冒泡排序以及改进

赞劲小子 — Tue, 24 Mar 2009 07:02:00 GMT

#include "iostream.h"
/**
  *冒泡排序
   冒泡排序（Bubble Sorting）的基本思想是：设待排序n个元素存放在数组a[n]中,无序区范围
   初始为(a(0),a(1),a(2),,a[n-1]),冒泡排序方法是在当前无序区内,从最上面的元素a[0]开
   始,对每两个相邻的元素a[i+1]和a[i](i=0,1,,n-1)进行比较,且使值较小的元素换至值较大
   的元素之上(若a[i]>a[i+1],则a[i]和a[i+1]的值互换),这样经过一趟冒泡排序后,假设最后下移
   的元素为a[k],则无序区中值较大的几个元素到达下端并从小到大依次存放在a[k+1],a[k+2],a[n-1]中,
   这样无序区范围变为(a[0],a[1],a[2],,a[k])。在当前无序区内进行下一趟冒泡排序。这个过
   程一直到某一趟排序中不出现元素交换的动作，排序结束。整个排序过程最多执行n-1遍。这种排序
   方法是通过相邻元素之间的比较与交换，使值较小的元素逐渐从后部移向前部（从下标较大的单元
   移向下标较小的单元），就象水底下的气泡一样逐渐向上冒。故称为冒泡排序法。
**/
void bubble(int array[], int size);

int main(){
    int array[10] = {7,6,8,5,10,9,2,4,3,1};
    bubble(array,10);
    for(int i = 0; i < 10; i++)
        cout << array[i] << ' ';
    return 0;
}

void bubble(int array[], int size){
    for(int pass = 0; pass < size - 1 ; pass++ )
        for(int j = 0 ; j < size - 1; j++)
        {
            int temp;
            if(array[j] > array[j + 1]){
                temp = array[j];
                array[j] = array[j+1];
                array[j+1] = temp;
            }

        }
}

改进后的冒泡排序
改进思想：比如用冒泡排序将4、5、7、1、2、3这6个数排序。在该列中，第二趟排序结束后，数组已排好序，但计算机此时并不知道已经反排
好序，计算机还需要进行一趟比较，如果这一趟比较，未发生任何数据交换，则知道已排序好，可以不再进行比较了。因而第三趟比较还需要
进行，但第四、五趟比较则是不必要的。为此，我们可以考虑程序的优化。
　为了标志在比较中是否进行了，设一个布尔量flag。在进行每趟比较前将flag置成true。如果在比较中发生了数据交换，则将flag置为false，在
一趟比较结束后，再判断flag，如果它仍为true（表明在该趟比较中未发生一次数据交换）则结束排序，否则进行下一趟比较。

#include "iostream.h"
void bubble(int array[], int size);

int main(){
    int array[10] = {7,6,8,5,10,9,2,4,3,1};
    bubble(array,10);
    for(int i = 0; i < 10; i++)
        cout << array[i] << ' ';
    return 0;
}

void bubble(int array[], int size){
    bool tag;
    for(int pass = 0; pass < size - 1; pass++ )
    {
        tag = true;
        for(int j = 0 ; j < size - 1; j++)
        {

            int temp;
            if(array[j] > array[j + 1]){
                temp = array[j];
                array[j] = array[j+1];
                array[j+1] = temp;
                tag = false;
            }
        }
        if(tag == true)
            return ;
     }
}

赞劲小子 2009-03-24 15:02 发表评论

汉诺塔（递归形式）

赞劲小子 — Mon, 23 Mar 2009 13:00:00 GMT

/**
  * 汉诺塔问题将N个盘子从第一个柱子移动到第三个柱子，第二个柱子可以作为临时用的，
  *具体题目可以在网上搜到
  *算法：
  *****当N== 1时，可以直接将盘子从第一移动到第三
  *****否则：(1)  将 n-1 个塔牌从 one 经过 three 全部移动到 two // 此过程结束后，塔牌数量为 [1, n-1, 0]
  *****(2)  将 one 移动到 three // 过过程结束后，塔牌数量为 [0, n-1, 1]
  *****(3)  将 n-1 个塔牌从 two 经过 one 全部移动到 three // 过过程结束后，塔牌数量为 [0, 0, n]
**/
#include "stdio.h"
#include "stdlib.h"
#include "iostream.h"

void hanoi(int n, char one, char two, char three);
void move(char x, char y);

void main(){
    int num;
    cin >> num;
    hanoi(num,'A','B','C');
}

void hanoi(int n, char one, char two, char three)
{
     if(n == 1)
         move(one,three);
     else
     {
         hanoi(n-1, one, three, two);
         move(one,three);
         hanoi( n-1, two, one, three);
     }
}
void move(char x, char y){
    printf("%c---->%c\n",x,y);
}

赞劲小子 2009-03-23 21:00 发表评论

求阶乘n！和 Fibnoacci函数的递归与非递归

赞劲小子 — Sun, 18 Jan 2009 05:19:00 GMT

求N的阶乘，对于阶乘，一般的递归运算的函数可以为

long factorial(int n){
    if(n <= 1)
        return 1;
    else
        return n * factorial(n-1);
}

而非递归的运算函数可以表示为

long factorial( int n )
{
    int    result = 1;

    while( n > 1 ){
        result *= n;
        n -= 1;
    }

    return result;
}

菲波那锲数列的定义都知道吧，是这样子的
它的递归函数都会写

long
fibonacci( int n )
{
   if( n <= 2 )
      return 1;
   else
      return fibonacci( n - 1 ) + fibonacci( n - 2 );
}

但是它的递归函数实在效率太低，重复计算的值相当的多，所以我们需要改进，使用循环

long
fibonacci( int n )
{
   long    next_older_result = 0;
   long    previous_result = 1;
    long    result = 1;

   if( 1 == n)
        return 0;
   else if( 2 == n)
        return 1;
   int i = 2;
   while(i < n){
        i++;
        next_older_result = previous_result;
        previous_result = result;
        result = previous_result + next_older_result;
   }
    return result;
}

如果你仔细观察一下，你会发现以上两个的递归调用都是函数所执行的最后一项任务。这个函数是尾部递归
尾部递归很容易也成非递归的形式。

赞劲小子 2009-01-18 13:19 发表评论