C++博客-绿-文章分类-常用算法

复制二叉树

chxzwj — Tue, 13 Dec 2011 08:29:00 GMT

chxzwj 2011-12-13 16:29 发表评论

统计二叉树叶子结点数目

chxzwj — Tue, 13 Dec 2011 08:15:00 GMT

chxzwj 2011-12-13 16:15 发表评论

把二叉树的叶子节点从左到右用链表链接起来

chxzwj — Sat, 10 Dec 2011 10:16:00 GMT

chxzwj 2011-12-10 18:16 发表评论

气泡排序

chxzwj — Thu, 08 Dec 2011 10:44:00 GMT

#include <iostream>
using namespace std;
void BubbleSort(int a[],int left,int right)
{
    bool exchange;
    int temp ;
    int i,j;
    for(i=left;i<right;i++)
    {
        exchange = false;
        for(j = right;j>=i+1;j--)
            if(a[j-1]>a[j])
            {
                temp = a[j-1];
                a[j-1] = a[j];
                a[j] = temp;
                exchange = true;
            }
            if(exchange == false)
                return ;
    }
}
int main()
{
    int arr[20];
    for(int i=19;i>=0;i--)
        arr[19-i] = i;

    BubbleSort(arr,0,19);

    for(int j=0;j<20;j++)
        cout<<arr[j]<<" ";
    getchar();
    return 0;
}

chxzwj 2011-12-08 18:44 发表评论

建立二叉树

chxzwj — Tue, 29 Nov 2011 04:48:00 GMT

chxzwj 2011-11-29 12:48 发表评论

输入广义表建立二叉树

chxzwj — Wed, 26 Oct 2011 04:48:00 GMT

chxzwj 2011-10-26 12:48 发表评论

二叉树遍历算法

chxzwj — Wed, 26 Oct 2011 04:46:00 GMT

#include <iostream>
using namespace std;
#define STACK_MAX_SIZE 50
typedef struct node
{
    char data;
    node * lchild;
    node * rchild;
}* BTreeNode;

void CreateBTree(BTreeNode &root,char * a)
{
    BTreeNode temp;
    BTreeNode Stack[STACK_MAX_SIZE];
    int top =-1;
    int k;
    int i=0;
    root = NULL;
    while(a[i]!='\0')
    {
        switch(a[i])
        {
        case '#':
            break;
        case '(':
            if(top == STACK_MAX_SIZE-1)
            {
                cout<<"栈溢出！程序自动退出！！"<<endl;
                exit(1);
            }
            else
            {
                top ++;
                Stack[top] = temp;
                k=1;
                break;
            }
        case ')':
            if(top ==-1)
            {
                exit(1);
            } else
            {
                top--;
                break;
            }
        case ',':
            k = 2;
            break;
        default:
            temp = new node();
            temp->data = a[i];
            temp->lchild = NULL;
            temp->rchild = NULL;
            if(root == NULL)
            {
                root = temp;
            }
            else
            {
                if(k==1)
                    Stack[top]->lchild = temp;
                else
                {
                    Stack[top]->rchild = temp;
                }
            }
        }
        i++;
    }
}
void PreSort(BTreeNode root)
{
    if(root == NULL)
    {
        return ;
    }
    else
    {
        cout<<root->data<<"   ";
        PreSort(root->lchild);
        PreSort(root->rchild);
    }
}
void NRPresort(BTreeNode root)
{
    BTreeNode temp = root;
    BTreeNode stack[STACK_MAX_SIZE];
    int top = -1;
    while(!(temp == NULL && top == -1))
    {
        while(temp!=NULL)
        {
            cout<<temp->data<<"   ";
            stack[++top] = temp;
            temp = temp->lchild;
        }
        if(top == -1)
            return ;
        else
        {
            temp = stack[top--];
            temp = temp->rchild;
        }
    }
}
void InSort(BTreeNode root)
{
    if(root == NULL)
    {
        return ;
    }
    else
    {
        InSort(root->lchild);
        cout<<root->data<<"   ";
        InSort(root->rchild);
    }
}
void NRInSort(BTreeNode root)
{
    BTreeNode temp = root;
    BTreeNode stack[STACK_MAX_SIZE];
    int top = -1;
    while(!(temp == NULL && top == -1))
    {
        while(temp!=NULL)
        {
            stack[++top] = temp;
            temp = temp->lchild;
        }
        if(top == -1)
            return ;
        else
        {
            temp = stack[top--];
            cout<<temp->data<<"   ";
            temp = temp->rchild;
        }
    }
}
void PostSort(BTreeNode root)
{
    if(root == NULL)
    {
        return ;
    }
    else
    {
        PostSort(root->lchild);
        PostSort(root->rchild);
        cout<<root->data<<"   ";
    }
}
void NRPostSort(BTreeNode root)
{
    typedef struct STACK
    {
        BTreeNode link;
        int flag;
    }Stack;
    Stack stack[STACK_MAX_SIZE];
    BTreeNode temp = root;
    int top = -1;
    int sign;
    while(!(temp == NULL && top == -1))
    {
        if(temp != NULL)
        {
            stack[++top].link = temp;
            stack[top].flag = 1;
            temp = temp->lchild;
        }
        else
        {
            temp = stack[top].link;
            sign = stack[top--].flag;
            if(sign != 2)
            {
                stack[++top].link = temp;
                stack[top].flag = 2;
                temp = temp->rchild;
            }
            else
            {
                cout<<temp->data<<"   ";
                temp = NULL;
            }

        }
    }
}
void LevelSort(BTreeNode root)
{
    BTreeNode queue[ STACK_MAX_SIZE];
    BTreeNode temp = root;
    int rear = 0;
    int front = -1;
    queue[rear] = temp;
    while(rear != front)
    {
        cout<<queue[++front]->data<<"   ";
        if(queue[front]->lchild != NULL)
            queue[++rear] = queue[front]->lchild;
        if(queue[front]->rchild != NULL)
            queue[++rear] = queue[front]->rchild;
    }
}
int main()
{
    char * a = "E(B(A,D(C,#)),I(G(F,H),J))";
    BTreeNode root;
    CreateBTree(root,a);
    cout<<"先序序列：  ";
    PreSort(root);
    cout<<"\n先序非递归：";
    NRPresort(root);
    cout<<"\n中序序列：  ";
    InSort(root);
    cout<<"\n中序非递归：";
    NRInSort(root);
    cout<<"\n后序序列：  ";
    PostSort(root);
    cout<<"\n后序非递归：";
    NRPostSort(root);
    cout<<"\n层次序列：  ";
    LevelSort(root);
    getchar();
    return 0;
}

chxzwj 2011-10-26 12:46 发表评论

基数排序LSD算法

chxzwj — Tue, 25 Oct 2011 07:32:00 GMT

#include <stdio.h>
#include <string.h>
/* 获取输入数字的索引值，dec指定数字的位数，3代表百位数，order指定需要获取哪一位的索引，1代表个位，2代表十位，3代表百位 */
int get_index(int num, int dec, int order)
{
    int i, j, n;
    int index;
    int div;
    /* 根据位数，循环减去不需要的高位数字 */
    for (i=dec; i>order; i--)
    {
        n = 1;
        for (j=0; j<dec-1; j++)
            n *= 10;
        div = num/n;
        num -= div * n;
        dec--;
    }
    /* 获得对应位数的整数 */
    n = 1;
    for (i=0; i<order-1; i++)
        n *= 10;
    /* 获取index */
    index = num / n;
    return index;
}
/* 进行基数排序 */
void radix_sort(int array[], int len, int dec, int order)
{
    int i, j;
    int index;     /* 排序索引 */
    int tmp[100];  /* 临时数组，用来保存待排序的中间结果 */
    int num[10];   /* 保存索引值的数组 */
    memset(num, 0, 10*sizeof(int));  /* 数组初始清零 */
    memset(tmp, 0, len*sizeof(int)); /* 数组初始清零 */
    if (dec < order) /* 最高位排序完成后返回 */
        return;
    for (i=0; i<len; i++) {
        index = get_index(array[i], dec, order);  /* 获取索引值 */
        num[index]++;  /* 对应位加一 */
    }
    for (i=1; i<10; i++)
        num[i] += num[i-1]; /* 调整索引数组 */
    for (i=len-1; i>=0; i--) {
        index = get_index(array[i], dec, order);  /* 从数组尾开始依次获得各个数字的索引 */
    j = --num[index];  /* 根据索引计算该数字在按位排序之后在数组中的位置 */
    tmp[j] = array[i]; /* 数字放入临时数组 */
    }
    for (i=0; i<len; i++)
        array[i] = tmp[i];  /* 从临时数组复制到原数组 */
    /* 继续按高一位的数字大小进行排序 */
    radix_sort(array, len, dec, order+1);
}
int main(int argc, char *argv[])

{
    int i;
    int a[11] = {101,258, 976, 515, 337, 359, 701, 916, 494, 303, 175};
    radix_sort(a, 11, 3, 3);
    for (i=0; i<11; i++)
        printf("%d  ", a[i]);
    printf("\n");
    getchar();
    return 0;
}

chxzwj 2011-10-25 15:32 发表评论

析取整数各位数字

chxzwj — Tue, 25 Oct 2011 07:19:00 GMT

#include <stdio.h>
#include <string.h>
#include <iostream>
using namespace std;
/* 获取输入数字的索引值，dec指定数字的位数，3代表百位数，order指定需要获取哪一位的索引，1代表个位，2代表十位，3代表百位 */
int get_index(int num, int dec, int order)
{
    int i, j, n;
    int index;
    int div;
    /* 根据位数，循环减去不需要的高位数字 */
    for (i=dec; i>order; i--)
    {
        n = 1;
        for (j=1; j<dec; j++)
            n *= 10;
        div = num/n;
        num -= div * n;
        dec--;
    }
    /* 获得对应位数的整数 */
    n = 1;
    for (i=0; i<order-1; i++)
        n *= 10;
    /* 获取index */
    index = num / n;
    return index;
}
int main(int argc, char *argv[])
{
    cout<<get_index(521, 3, 2)<<endl;
    getchar();
    return 0;
}

chxzwj 2011-10-25 15:19 发表评论

二路归并递归实现

chxzwj — Tue, 25 Oct 2011 02:43:00 GMT

#include <iostream>
using namespace std;
//参数：r表示待排序数组，s为r中第一个有序表的第一个下标，m为第一个有序表的最后一个下标；s是r中的最后一个下标
void merge( int r[],int s,int m,int t)
{
    int tempr[50];
    for(int k = s; k <= t; k++ )
        tempr[k] = r[k];
    int s1 = s;
    int s2 = m+1;
    int rs = s;
    while(s1 <= m && s2 <= t)
        if(tempr[s1]<=tempr[s2])
            r[rs++] = tempr[s1++];
        else
             r[rs++] = tempr[s2++];
    while(s1 <= m)
        r[rs++] = tempr[s1++];
    while(s2 <= t)
        r[rs++] = tempr[s2++];
}
void MSort(int r[],int s,int t)
{
    int m;
    if(s==t)
        ;
    else
    {
        m = (s+t)/2;
        MSort(r,s,m);
        MSort(r,m+1,t);
        merge(r,s,m,t);
    }
}
int main()
{
    int r[11] = {34,45,56,2,4,6,12,3,4567,78,11};
    MSort(r,0,10);
    for(int i=0;i<11;i++)
        cout<<r[i]<<endl;
    getchar();
    return 0;
}

chxzwj 2011-10-25 10:43 发表评论

希尔排序

chxzwj — Mon, 24 Oct 2011 18:55:00 GMT

1 #include <iostream>
2 using namespace std;
3 void ShellSort(int a[],int n)
4 {
5     int temp;
6     int dk = n;
7     do                                                 //调整步长循环
8     {
9         dk = dk/3+1;
10         for(int i=0; i<dk; i++)                        //对每一分组进行排序
11         {
12             for(int j=i+dk; j<n; j = j+dk)             //对指定分组进行直接插入排序
13             {
14                 for(int k=i;k<j;k=k+dk)                            // 寻找元素位置
15                 {
16                     if(a[j]<a[k])
17                     {
18                         temp = a[j];
19                         for(int h = j;h>k;h = h-dk)
20                             a[h] = a[h-dk];
21                         a[k] = temp;
22
23                     }
24                 }
25             }
26         }
27     }while(dk>1);
28 }
29 int main()
30 {
31     int a[10] = {4,10,9,8,7,6,5,4,3,2};
32     ShellSort(a,10);
33     for(int l=0;l<10;l++)
34         cout<<a[l]<<"   ";
35     getchar();
36     return 0;
37 }

chxzwj 2011-10-25 02:55 发表评论

折半插入排序

chxzwj — Mon, 24 Oct 2011 17:32:00 GMT

#include <iostream>
using namespace std;
void BinarySort(int a[],int n)
{
    int high ;
    int low ;
    int m;
    int temp;
    for(int i=1;i<n;i++)
    {
        low = 0;
        high = i-1;
        temp = a[i];
        while(low<=high)
        {
            m = (low+high)/2;
            if(temp<a[m])
                high = m-1;
            else
                low = m+1;
        }
        for(int j=i-1;j>=low;j--)
            a[j+1] = a[j];
        a[low] = temp;
     }
}
int main()
{
     int r[14] = {10,2,12,3,4,89,5,45,21,7,90,112,78,91};
     BinarySort(r,14);
     for(int i=0;i<14;i++)
     {
         cout<<r[i]<<endl;
     }
     getchar();
     return 0;
}

chxzwj 2011-10-25 01:32 发表评论

直接插入排序

chxzwj — Mon, 24 Oct 2011 16:56:00 GMT

#include <iostream>
using namespace std;
void InsertSort(int a[],int n)
{
    int temp;
    int j;
    for(int i=1;i<n;i++)
    {
        if(a[i]<a[i-1])
        {
            temp = a[i];
            j = i-1;
            do
            {
                a[j+1] = a[j];
                j--;
            }while(temp<a[j] && j>=0);
        }
        a[j+1] = temp;
    }

}
int main()
{
    int r[14] = {10,2,12,3,4,89,5,45,21,7,90,112,78,91};
    InsertSort(r,14);
    for(int i=0;i<14;i++)
    {
        cout<<r[i]<<endl;
    }
    getchar();
    return 0;
}

chxzwj 2011-10-25 00:56 发表评论

二路归并迭代算法

chxzwj — Mon, 24 Oct 2011 16:43:00 GMT

#include <iostream>
using namespace std;
//有序表归并算法
void merge( int r[],int s,int m,int t)
{
    int tempr[50];
    for(int k = s; k <= t; k++ )
        tempr[k] = r[k];
    int s1 = s;
    int s2 = m+1;
    int rs = s;
    while(s1 <= m && s2 <= t)
        if(tempr[s1]<=tempr[s2])
            r[rs++] = tempr[s1++];
        else
            r[rs++] = tempr[s2++];
    while(s1 <= m)
        r[rs++] = tempr[s1++];
    while(s2 <= t)
        r[rs++] = tempr[s2++];
}
// 一趟归并排序算法
void MergePass(int r[],int len,int n)
{
    int i;
    for(i=0;i+2*len-1<=n;i=i+2*len)
        merge(r,i,i+len-1,i+2*len-1);
    if(i+len-1<n)
        merge(r,i,i+len-1,n);
}
// 归并迭代算法
// 函数名：MergeSort；
// 参数：r[]表示想要排序的数组；tempr[]表示临时数组；n表示数组元素个数
void MergeSort(int r[],int n)
{
     int len;
     len = 1;
     while(len<n)
     {
         MergePass(r,len,n);
         len = 2*len;
         MergePass(r,len,n);

     }
}
int main()
{
    int r[14] = {10,2,12,3,4,89,5,45,21,7,90,112,78,91};
    MergeSort(r,13);
    for(int i=0;i<14;i++)
        cout<<r[i]<<endl;

    getchar();
    return 0;
}

chxzwj 2011-10-25 00:43 发表评论

有序表归并

chxzwj — Mon, 24 Oct 2011 16:41:00 GMT

#include <iostream>
using namespace std;
//参数：r表示待排序数组，s为r中第一个有序表的第一个下标，m为第一个有序表的最后一个下标；s是r中的最后一个下标
void merge( int r[],int s,int m,int t)
{
    int tempr[50];
    for(int k = s; k <= t; k++ )
        tempr[k] = r[k];
    int s1 = s;
    int s2 = m+1;
    int rs = s;
    while(s1 <= m && s2 <= t)
        if(tempr[s1]<=tempr[s2])
            r[rs++] = tempr[s1++];
        else
             r[rs++] = tempr[s2++];
    while(s1 <= m)
        r[rs++] = tempr[s1++];
    while(s2 <= t)
        r[rs++] = tempr[s2++];
}

int main()
{
     int r[6] = {34,45,56,2,4,6};
     merge(r,0,2,5);
     for(int i=0;i<6;i++)
         cout<<r[i]<<endl;
     getchar();
     return 0;
}

chxzwj 2011-10-25 00:41 发表评论