蛮力法

蛮力法：是一种简单直接地解决问题的方法，常常直接给予问题的描述和所涉及的概念定义。

1.       选择排序

算法：

SelectionSort(Array a)

//该算法用选择排序对给定数组排序

//输入：一个可排序数组 A[0,1,….n-1]

//输出：一个已排序数组 A[0,1,….n-1](升序)

for  i <—0 to n-1 do

           min<— i

           for  j <—i to n-1

            if(A[j]<A[min])

                    min=j

           swapA[i] and A[min]

实现：

void selectionSort(double a[],int iLen)

{

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

     {

         int min=i;

         for(int j=i;j<iLen;++j)

              if(a[j]<a[min])

                   min=j;

         {

              double temp=a[i];

              a[i]=a[min];

              a[min]=temp;

         }

     }

}

2.     冒泡排序

算法：

BubbleSort(Array a)

//该算法用冒泡排序对给定数组排序

//输入：一个可排序数组A[0,…..n-1]

//输出：一个已排序数组 A[0,…..n-1]

for i<- n-1 to 1

     forj<- 0 to i-1

          ifa[j]>a[j+1]

               swapa[j] and a[j+1]

实现：

void bubleSort(double a[],int iLen)

{

     for(int i=iLen-1;i>0;--i)

     {

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

         {

              if(a[j]>a[j+1])

              {

                   double temp=a[j];

                   a[j]=a[j+1];

                   a[j+1]=temp;

              }

         }

     }

}

3.       顺序查找

算法：

seqSearch(Array a, Key k)

//该算法用顺序查找来找出某个键值时候在数组中

//输入：一个n元素的数组a和一个查找键k

//输出：第一个键值等于k的元素的位置，否则返回-1

for i<— 0 to n-1do

           if  a[i]=k

                    returni

return -1

实现：

int seqSearch(inta[],int iLen,int iKey)

{

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

         if(a[i]==iKey)

              return i;

     return-1;

}

4.     蛮力字符串匹配

算法：

bruteForeStringMatch(Array a , Array b)

//该算法用蛮力法对字符串进行匹配

//输入：一个由n个字符的数组 a[0,….n-1]代表一段文本

       一个有m个字符的数组 b[0,…m-1]代表一个模式

//输出：成功就返回第一个匹配子串的第一个字符的位置，失败返回-1

for i<- 0 to n-1 do

     j<-0

     whilej<m and a[i+j]=b[j] do

          j<-j+1

     ifj=m

          returni

return -1

实现：

int bruteForceStringMatch(char a[],int iLenA,char b[],int iLenB)

{

  for(int i=0;i<iLenA-iLenB;++i)

  {

       int j=0;

       while(j<iLenB&&a[i+j]==b[j])

            ++j;

       if(j==iLenB)

            return i;

  }

  return -1;

}

5.     最近对问题

算法：

bruteForceClosestPoint( P)

//使用蛮力算法求出最近的两个点

//输入：包含n个点的点集P={(x0,y0),(x1,y1)…..(xn-1,yn-1)}

//输出：距离最近的顶点对的索引 index1，index2

dmin<- ∞

index1<- 0

index2<-0

for i<- 0 to n-2 do

     forj<-i+1 to n-1 do

          dTemp<-(xi-xj)^2+(yi-yj)^2

          if(dTemp<dmin)

               dmin<-dTemp

               index1<-i

               index2<-j

return (index1,index2)

6.     凸包问题

算法：

bruteForceOuter(Vertexs)

//使用蛮力法求出凸包的边（顶点对）

//输入：包含n个点的点集V={(x0,y0),(x1,y1)…..(xn-1,yn-1)}

//输出：无（打印出顶点对）

for i<-0 to n-2 do

     forj<-i+1 to n-1 do

          a<-yj-yi

          b<-xi-xj

          c<-xj*yi-xi*yj   //ax+by+c=0

          k<-0

          flag<- 0

          tempFlag<-0

          fork<-0 to n-1 do

               tempFlag<-a*xk+b*yk+c

               ifflag=0 and tempFlag!=0

                   flag<-tempFlag

               elseif flag!=0 and tempFlag!=0

                   flag*tempFlag<0

                        break;

          ifk=n

               print(xi,yi),(xj,yj)

//下面3个问题都可以通过穷举法来解决

7.     旅行商问题

8.     背包问题

9.     分配问题