久久精品国产第一区二区,久久精品草草草,aaa级精品久久久国产片

Sun, 24 Jan 2010 06:36:00 GMT

摘要: Quicksort是一个很好的比较排序��法�Q�但是其最坏情况运行时间是O(n^2), �q�不如Mergesort的O(nlgn),
如何改进Quicksort? �{�案是：引进随机化思想�?
一�U�方法：对给定的待排序序列，随机地重排列
另一�U�方法：随机选取pivot

�l�出�W�二�U�方法的代码阅读全文

�q�运�?/a> 2010-01-24 14:36 发表评论

Order Statistics ��序�l�计�Q�找出第i��元素）

Thu, 21 Jan 2010 08:29:00 GMT

摘要:
Order Statistics ��序�l�计
Select(int* a, int n, int ith): 从给定的n个元素中扑և��W�i个小的元�?
思想�Q�QuickSort的Partition�Ҏ��q�行分割
如果 i = rank(pivot), 则返回a[k]
如果 i < rank(pivot), 则从前半部分中找�W�i个小的元�?
如果 i > rank(pivot), 则从后半部分中找�W�i-rank(pivot)个小的元�?
最坏运行时间O(n^2)
�q�_��q�行旉��O(nlgn) 阅读全文

�q�运�?/a> 2010-01-21 16:29 发表评论

基本排序�Ҏ��及分析（八）�Q�CoungtingSort 计数排序

Mon, 18 Jan 2010 07:50:00 GMT

摘要:
计数排序对a[0],...,a[n-1]�q�行排序�Q�其�? <= a[i] <= m
计数排序不是��Z��比较的排序方法，从而最坏情形下的运行时间也不受比较的排序方法最快O(nlgn)的限制�?
计数排序的运行时间是O(n+m) 阅读全文

�q�运�?/a> 2010-01-18 15:50 发表评论

Mon, 18 Jan 2010 07:45:00 GMT

1/*
2 * 堆排�?br> 3 * O(nlgn)
4 */
5
6#include <iostream>
7#include <cstdlib>
8
9#define LEFT(i) (2*i+1)
10#define RIGHT(i) (2*i+2)
11#define PARENT(i) ( (i-1)/2 )
12
13using namespace std;
14
15//交换两个元素�?nbsp;
16void swap(int& a, int& b);
17//输出数组元素
18void print(int*a, int n);
19
20//保持堆性质�Q�当左右子树都是堆时�Q�但a[i]可能�q�反堆性质�Ӟ��调整成堆
21void MaxHeapify(int *a, int i, int n)
22{
23     int left = LEFT(i);
24     int right = RIGHT(i);
25     int largest = i;
26
27     if(left < n && a[left] > a[largest] )
28             largest = left;
29     if(right < n && a[right] > a[largest])
30              largest = right;
31     if(largest != i)
32     {
33                swap(a[i],a[largest]);
34                MaxHeapify(a,largest,n);
35     }
36}
37
38//创徏�?nbsp;
39void BuildMaxHeap(int* a, int n)
40{
41     //从有子树的开�?nbsp;
42     for(int i = PARENT(n-1); i >= 0; i--)
43     {
44             MaxHeapify(a,i,n);
45     }
46}
47
48void HeapSort(int *a, int n)
49{
50     //创徏�?nbsp;
51     BuildMaxHeap(a, n);
52     for(int i = n -1; i >= 1; i--)
53     {
54             //把最大元素放在最后，下一步不予考虑
55             swap(a[i],a[0]);
56             MaxHeapify(a,0,i); //�q�里不是MaxHeapify(a,0,i-1);
57     }
58}
59
60
61//交换两个元素�?nbsp;
62void swap(int& a , int& b)
63{
64     int temp = a;
65     a = b;
66     b = temp;
67}
68
69//打印数组
70void print(int* a , int n)
71{
72     for(int i = 0; i < n ; i++)
73             cout << a[i] << ",";
74     cout << endl;
75}
76
77
78int main()
79{
80    const int N = 10;
81    int a[N] = {4,1,3,2,16,9,10,14,8,7};
82
83    print(a,N);
84
85    HeapSort(a,N);
86
87    print(a,N);
88
89    system("pause");
90    return 0;
91}

�q�运�?/a> 2010-01-18 15:45 发表评论

Thu, 07 May 2009 13:15:00 GMT

另外一�U�思�\�Q�这个比�?.5N�ơ）�Q?a href="http://www.shnenglu.com/liyuxia713/archive/2009/04/14/79855.html">http://www.shnenglu.com/liyuxia713/archive/2009/04/14/79855.html

** 对用戯��入的��L��一�l�序列，计算其最大值和最��?br>** �q�不是用vector�q�类容器存储整个序列中的数据
** 思想�Q�定义min�Q�max�Q�用输入序列的第一个元素初始化
** 若输入流中元素小于min�Q�则用该值替换min�Q�若大于max,则替换掉 max
** 重复输入 �Q�比�?N��?br>

#include <iostream>
using std::cin;
using std::cout;
using std::endl;

int main()
{
    int v = 0;
    int min, max;

    cout << "Enter numbers: ";

    cin >> v;
    min = max = v;

    while(cin >> v)
    {
        if(v < min) min = v;
        else if(v > max) max = v;
        else;
    }
    cout << "min  = " << min << ", max = " << max <<endl;

    return 0;
}

�q�运�?/a> 2009-05-07 21:15 发表评论

Thu, 23 Apr 2009 11:03:00 GMT

摘要: 桶式排序是对一个有n个整型元素的数组a[n],其中对�Q意i�Q? <= a[i] <= m的特�D�排序算法�?
可以�?n==m, n != m分别处理。写代码旉��要注意的的是a[i]是访问第i-1个元素，而非�W�i个�?
n != m�Ӟ��q�行旉��为O(m+n),辅助�I�间为O(m)
n == m时特�D�处理，�q�行旉��为O(N), 辅助�I�间为O(1) 阅读全文

�q�运�?/a> 2009-04-23 19:03 发表评论

Thu, 23 Apr 2009 02:50:00 GMT

摘要: 归�ƈ排序思�\�Q�将序列从中间分割成两部分，分别递归归�ƈ排序�Q�后��两个子序列合�ƈ�?
归�ƈ排序虽然是经典排序里比较最��的��法�Q�但有大量的复制操作�Q�还需要O(N)的辅助空��_��从而一般不用于��d��Q�也不利于c++�~�程�?
Java中比较操作耗时多，而复制则耗时��，从而归�q�排序是Java中主要排序方法�?
而在C++ STL中快速排序是基本排序�Ҏ��?nbsp; 阅读全文

�q�运�?/a> 2009-04-23 10:50 发表评论

Wed, 22 Apr 2009 08:56:00 GMT

摘要: 快速排�?��定一个枢�U�元�Q�一�ơ遍历后��数�l�划分成两个部分�Q�第一部分均比枢纽元小�Q�第二部分都比枢�U�元大，然后对这两个数组�q�行快速排序，是一�U�递归的方�?
�q�_��q�行旉��O(Nlog(N)),最坏运行时间O(N^2)
最坏情形：对于预排序的序列�?
对与枢纽元相�{�的元素处理�Q?
i,j都停止：会比较相�{�元素，但是可以划分成长度相当的两个子数�l?
i,j都不停止�Q�不会比较相�{�元素，但是可能产生长度不��^衡的两个子数�l?与枢�U�元相等的元素较多时)枢纽元的选取�Q?
1. 选取�W�一个元素做枢纽元：对于�Q�部分）预排序的序列�q�行旉��O(N^2)
2. 随机生成枢纽元：能避免上�q�问题，但是产生枢纽元的代�h�?
3. 三数中值分割法�Q�选取左端�Q�右端，中间位置三个元素的中�?nbsp; 阅读全文

�q�运�?/a> 2009-04-22 16:56 发表评论

基本排序��法及分析（三）�Q�shell排序

Wed, 22 Apr 2009 08:50:00 GMT

shell排序是对直接插入�Ҏ��的改�q�方�?

1/*-------------------------------------------------------------------------------------
2Shell_sort.h
3shell排序是对直接插入�Ҏ��的改�q�，它�ƈ不是对相��d��素进行比较，而是对一定间隔的元素比较.
4选择增量序列的几�U�方法：(为方便，本例采用�W�一�U�增量序�?
51. h[1]=size�Q?nbsp;h[k] = h[k-1]/2.
6    最坏运行时间�ؓO(N^2).
7    最坏情形：数组长度�?^n,数组的偶��C��|�上同是一个数�Q�奇��C��|�上也同是一个数�Q?br> 8              且比偶数位置的小。此时到最后一�ơ遍历前shell排序实际上什么也没做�?br> 9              最后一�ơ遍历相当于直接插入�Ҏ��?br>102. Hibbard增量序列�Q?nbsp;h = 1,3,7,,2^k-1
11    �q�个的区别于上的主要的特�Ҏ��盔R��增量没有公因�?br>12    最坏运行时间�ؓO(n^{1.5});
133. Sedgewick增量序列�Q�{1�Q?�Q?9�Q?1�Q?09�Q?img src="http://www.shnenglu.com/Images/dot.gif">}
14-------------------------------------------------------------------------------------*/
15
16#ifndef SHELL_SORT_H
17#define SHELL_SORT_H
18
19#include "typedef.h"
20
21void Shell_sort(T* a, int n)
22{
23
24    for(int gap = n; gap > 0; gap = gap/2)
25    {
26        for(int i = 0; i != n; ++i)
27        {
28            T temp = a[i];
29            int j = i - gap;
30            for( ; j >= 0 && a[j] > temp; j = j-gap)
31                a[j+gap] = a[j];
32            a[j+gap] = temp;
33        }
34    }
35}
36
37#endif

�q�运�?/a> 2009-04-22 16:50 发表评论

Wed, 22 Apr 2009 08:46:00 GMT

冒��排序和改�q�的冒��排序

1/*-------------------------------------------------------------------------------------------
2Bubble_sort.h
3冒��排序�Q?nbsp;旉��复杂度�ؓO(N^2)
4改进的冒泡排序：旉��复杂度仍为O(N^2)
5    一般的冒��排序�Ҏ��有可能会在已�l�排好序的情况下�l�箋比较�Q�改�q�的冒��排序
6    讄��了一个哨兵flag�Q�如果一�ơfor循环没有�q�行交换�Q�则元素已经排好序，由哨光|��刉��出��@环�?br> 7-------------------------------------------------------------------------------------------*/
8#ifndef BUBBLE_SORT_H
9#define BUBBLE_SORT_H
10
11#include "typedef.h"
12#include "swap.h"
13
14//冒��排序
15void Bubble_sort(T *a, int n)
16{
17    for(int i=n-1; i != 0; --i)
18        for(int j=0; j != i; ++j)
19            if(a[j+1] < a[j]) swap(a[j+1],a[j]);
20}
21
22//改进的冒泡排�?/span>
23void Improved_Bubble_sort(T *a, int n)
24{
25    for(int i=n-1; i != 0; --i)
26    {
27        bool flag = true;
28        for(int j=0; j != i; ++j) //�q�一��遍历如果没有交换，则已完成排序
29            if(a[j+1] < a[j])  { swap(a[j+1],a[j]); flag = false; }
30        if(flag == true) break;
31    }
32}
33
34#endif

�q�运�?/a> 2009-04-22 16:46 发表评论

基本排序��法及分析（一�Q�：插入排序�Q�直接选择排序

Wed, 22 Apr 2009 08:44:00 GMT

声明待排序元素类�?br>

1/*--------------------------
2typedef.h
3方便修改待排序元素类�?br> 4-------------------------------------*/
5#ifndef TYPEDEF_H
6#define TYPEDEF_H
7
8typedef int T;
9
10#endif

插入排序�Q?

1/*---------------------------------------------------------------------------------------
2Insertion_sort.h
3直接插入排序
4对以数组形式�l�出的元素排�?br> 5旉��复杂度�ؓ(逆序�?N(N-1)/4 = O(N^2),�q�且在最坏情形下辑ֈ��q�个�?br> 6最好情形下�q�行N�ơ，最坏情形下�q�行2+3+…+N
7------------------------------------------------------------------------------------------------*/
8
9#ifndef INSERTION_SORT_H
10#define INSERTION_SORT_H
11
12#include "typedef.h"
13//直接插入排序
14void Insertion_sort(T *a, int n)
15{
16    for(int i = 1; i != n; ++i)
17    {
18        T temp = a[i];
19        int j = i - 1;
20        for(; j >= 0 && temp < a[j]; --j )
21            a[j + 1] = a[j];
22        a[j + 1] = temp;
23    }
24}
25
26#endif

直接选择排序�Q?br>

1/*----------------------------------------------
2DirectSelection_sort.h
3直接选择排序
4旉��复杂度O(N^2)
5--------------------------------------------------------*/
6#ifndef DIRECTSELECTION_SORT_H
7#define DIRECTSELECTION_SORT_H
8
9#include "typedef.h"
10#include "swap.h"
11
12//直接选择法排�?/span>
13void DirectSelection_sort(T*a, int n)
14{
15    for(int i = 0; i != n; ++i)
16    {
17        int k = i;
18        for(int j = i; j != n; ++j)
19            if(a[j] < a[k]) k = j;
20        swap(a[k],a[i]);
21    }
22}
23
24#endif

�q�运�?/a> 2009-04-22 16:44 发表评论

Tue, 14 Apr 2009 02:11:00 GMT

��法思想�Q�先盔R��两个两个比较�Q�较大的攑օ�数组max[],较小的放入数�l�min[],然后从max[]数组求出最大，min[]数组求出最��即可�?br>比较n+[(n+1)/2] =1.5n��?br>

1#include <iostream>
2#define n 11
3#define m ((n+1)/2)
4using namespace std;
5
6void main(void)
7{
8    int num[] = {11,2,3,4,6,5,7,8,9,10,20};
9    //int n = sizeof(num)/sizeof(num[0]);
10    //int m = (n+1)/2;
11    int max[m] , min[m];
12    int k = 0, j = 0;
13
14    if(n/2 != 0) max[m-1] = min[m-1] = num[n-1];
15
16    for (int i=0; i < n-1; i = i+2)
17    {
18        if (num[i] >= num[i+1])
19        {
20            max[j++] = num[i];
21            min[k++] = num[i+1];
22        }
23        else
24        {
25            max[j++] = num[i+1];
26            min[k++] = num[i];
27        }
28
29    }
30
31    for( i=0; i< m; i++)
32    {
33        cout << "max[" << i << "] = " << max[i] << "\t";
34        cout << "min[" << i << "] = " << min[i] <<endl;
35    }
36
37    int MAX = max[0];
38    int MIN = min[0];
39
40     for ( j = 1; j < m; j++)
41    {
42        if (max[j] > MAX) MAX = max[j];
43        if (min[j] < MIN) MIN = min[j];
44    }
45
46    cout << "MAX = " << MAX << ", MIN = " << MIN <<endl;
47}

�q�运�?/a> 2009-04-14 10:11 发表评论

Fri, 10 Apr 2009 03:12:00 GMT

Technorati 标签: 八皇后问�?/a>

//8queen.cpp
//eight queens problem�Q��d��?2个解.
//八皇后问题：�?*8的方格棋盘上安置8个棋子（皇后�Q?br>//要求�Q��Q何两个棋子都不能在棋盘的同一行，同一列或同一对角�U�上�?/font>

#include
using namespace std;

const int N = 8;
static int num = 0;

int a[N][N] = {0};

//输出矩阵
void print(int a[][N],int row); //注意二维数组如何调用
//判断步骤是否有效
bool is_valid(int i, int j);
//探烦�Q�遍�?/font>
void traversal(int i);

int main()
{
    traversal(0);
    cout << "There are " << num << " solutions for eight queens problems" <    return 0;
}

//探烦�Q�遍�?核心部分)
void traversal(int i)
{
    if(i >= 8)
    {
        print(a, N);
    }
    for(int j = 0; j != N; ++j)
    {
        a[i][j] = 1;
        if(is_valid(i,j)) traversal(i+1);
        a[i][j] = 0;
    }
}

//判断步骤是否有效
bool is_valid(int i, int j)
{
    bool b = true;
    for(int i1 = 0; i1 != i; ++i1)
        for(int j1 = 0; j1 != N; ++j1)
        {
            if(a[i1][j1] == 1)
                if((j1 == j) || ( abs(i1 - i) == abs(j1 - j)) ) b = false;
        }
    return b;
}

//输出矩阵
void print(int a[][N],int row)
{
    ++num;
    for(int i = 0; i != row; ++i)
    {
        for(int j = 0; j != N; ++j)
            cout << a[i][j] << " ";
        cout << endl;
    }

cout << "--------------------" <}
文章来源:http://liyuxia-life.spaces.live.com/Blog/cns!DA1B364675ACF35!272.entry

�q�运�?/a> 2009-04-10 11:12 发表评论

[导入]用��@环队列输出杨辉三角�Ş

Fri, 10 Apr 2009 02:12:00 GMT

用��@环队列输出杨辉三角�Ş貌似有点��题大做�Q�但主要是�ؓ了练习队列应用嘛。说实在�q�个��程序也让我调试了很长时�?

用这个程序用户就可以自行输入惌��的杨辉三角�Ş的行��C��?

//YHTriangle.cpp
//输出杨辉三角�?br>//��法思想�Q�首先在循环队列中存攄��三行�?1�Q?�Q?和第四行�?.
//若��@环队列队头元素和队头�W�二个元素均�?�Q�则从队头删除一�?�Q�在队尾插入两个1.
//若不�Ӟ��队对头元素和队头第二个元素相加�Q�将和值插入到队尾�Q�删除对头一个元素�?br>//若想输出杨辉三角形n行，��@环队列长度设�|�成 n+2�?br>//输出�Q�前两行直接输出。定义了print函数控制后面每行输出的元素个�?br>#include "Queue.h"
#include "CycQueue.h"
#include
using namespace std;

//输出n个空�?/font>
void print_space(int n);
//n行杨辉三角�Ş的输出格�?/font>
void print(int k, int n);

int main()
{
    int n;
    cout << "Please enter the YangHui Triangle row number n:";
    cin >> n;

CycQueue YHTri(n+2);

    YHTri.push(1);
    YHTri.push(2);
    YHTri.push(1);
    YHTri.push(1);
   //输出前两�?/font>
    print(1,n);
    print(1,n);
    print(1,n);
    while( !YHTri.full())
    {
        int a,b;
        //若队头元素和队头�W�二个元素均�?
        if( (YHTri.top() == 1) && (YHTri.second() == 1))
        {
            a = YHTri.pop_top();
            YHTri.push(1);
            YHTri.push(1);
            print(a,n);
        }
        //若不�?/font>
        else
        {
            a = YHTri.pop_top();
            b = YHTri.top();
            YHTri.push(a + b);
            print(a,n);
        }
    }

    //输出循环队列中留存的元素
    while( !YHTri.empty())
    {
        print(YHTri.pop_top(),n);
    }

system("pause");
return 0;
}

void print_space(int n) //输出n个空�?br>{
while(n--) cout << " ";
}

int i = 1, j = 0;
void print(int k, int n) //n行杨辉三角�Ş的输出格�?br>{
    if( i==1 ) print_space(n);
    if(j++ != i) ;
    else
    {
        cout << endl;
        print_space(n-i);
        ++i;
        j = 1;
    }
    cout << k <<" ";
}

//循环队列的模板类声明

#ifndef CYCQUEUE_H
#define CYCQUEUE_H

#include
using namespace std;

template
class CycQueue:public Queue
{
public:
    CycQueue(int maxsz = 100):len(maxsz)
    {
        elems = new T[maxsz];
        front = rear = 0;
    };
    ~CycQueue(){delete[] elems;    };

    void clear() {rear = front = 0;};
    int size()const
    bool full()const
    bool empty()const
    bool push(const T& item);
    bool pop();
    T top()const;
    T pop_top();
    T second()const;
protected:
private:
    int front;
    int rear;
    int len;
    T* elems;
};

#include "CycQueue.cpp"
#endif

循环队列主要注意不要忘记%len�Q�不然就都是莫名错误啦！
文章来源:http://liyuxia-life.spaces.live.com/Blog/cns!DA1B364675ACF35!271.entry

�q�运�?/a> 2009-04-10 10:12 发表评论

[导入]一�l�数�l�输出杨辉三角�Ş

Fri, 10 Apr 2009 01:58:00 GMT

优点�Q�只需要与杨辉三角形行数相同的存储�I�间�?

�~�点�Q�因为数�l�长度不能在�q�行时确定，所以杨辉三角�Ş的长度不能通过用户自行输入��定�?

#include

using namespace std;

const int N = 10;
int main()
{
      int a[N]={0};
      a[0]=1;
      for(int i=1; i!=N;++i)
        {
            int m = N - i;
           //输出�I�格
               while(m != 0 )
            {
                cout << " ";
                --m;
            }
            //输出
            for(int j=0;j != i;++j)
               cout << a[j] << " ";
            cout << endl;
            //赋�?/font>
            a[i]=1; //最后一个元素赋�?
            for(int j=i-1;j!=0;--j)
               a[j]=a[j]+a[j-1];
        }
       return 0;
}
文章来源:http://liyuxia-life.spaces.live.com/Blog/cns!DA1B364675ACF35!270.entry

�q�运�?/a> 2009-04-10 09:58 发表评论