c++基本代码

最新推荐文章于 2024-08-04 11:55:00 发布
最新推荐文章于 2024-08-04 11:55:00 发布
阅读量563 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sdjasdaslk/article/details/27801467
版权 
 
 

  
  1
  
  .冒泡法：
这是最原始，也是众所周知的最慢的算法了。他的名字的由来因为它的工作看来象是冒泡：
#include 
  
  <
  
  iostream.h
  
  >
  
  


  
  void
  
   BubbleSort(
  
  int
  
  *
  
   pData,
  
  int
  
   Count)
{
    
  
  int
  
   iTemp;
    
  
  for
  
  (
  
  int
  
   i
  
  =
  
  1
  
  ;i
  
  <
  
  Count;i
  
  ++
  
  )
    {
        
  
  for
  
  (
  
  int
  
   j
  
  =
  
  Count
  
  -
  
  1
  
  ;j
  
  >=
  
  i;j
  
  --
  
  )
        {
            
  
  if
  
  (pData[j]
  
  <
  
  pData[j
  
  -
  
  1
  
  ])
            {
                iTemp 
  
  =
  
   pData[j
  
  -
  
  1
  
  ];
                pData[j
  
  -
  
  1
  
  ] 
  
  =
  
   pData[j];
                pData[j] 
  
  =
  
   iTemp;
            }
        }
    }
}


  
  void
  
   main()
{
    
  
  int
  
   data[] 
  
  =
  
   {
  
  10
  
  ,
  
  9
  
  ,
  
  8
  
  ,
  
  7
  
  ,
  
  6
  
  ,
  
  5
  
  ,
  
  4
  
  };
    BubbleSort(data,
  
  7
  
  );
    
  
  for
  
   (
  
  int
  
   i
  
  =
  
  0
  
  ;i
  
  <
  
  7
  
  ;i
  
  ++
  
  )
        cout
  
  <<
  
  data[i]
  
  <<
  
  "
  
   
  
  "
  
  ;
    cout
  
  <<
  
  "
  
  /n
  
  "
  
  ;
}
图示：
 
 

 
 


 
 

 
 

  
   before_compare|one_turn|two_turn|three_turn|four_turn|five_turn|six_turn
 
 

 
 

  
           10        10        10        10        10          10    
  
  4            
 
 

 
 

  
            9         9         9         9         9         
  
    4    10
 
 

 
 

  
            8         8         8         8      
  
     4           9    9
 
 

 
 

  
            7         7         7        
  
   4         8           8    8
 
 

 
 

  
            6         6         
  
  4         7         7           7    7
 
 

 
 

  
            5        
  
   4         6         6         6           6    6
 
 

 
 
         
  
   4         5         5         5         5           5    5
 
 

 
 

  
  通过上图可以看出，冒泡法形象的描述来，4这个元素就像一个气泡逐渐冒到上
 
 

 
 

  
  面来了。
 
 

 
 

  
   我们排序的有7个元素，最坏的情况全部倒序，4这个元素要冒上来需要6次。
 
 

 
 

  
  因此，n个元素，最坏的情况，需要移动：1+2+3+ ...+(n-1)=1/2*n(n-1)次。
 
 


 
 

  
  倒序(最糟情况)
第一轮：
  
  10
  
  ,
  
  9
  
  ,
  
  8
  
  ,
  
  7
  
  ->
  
  10
  
  ,
  
  9
  
  ,
  
  7
  
  ,
  
  8
  
  ->
  
  10
  
  ,
  
  7
  
  ,
  
  9
  
  ,
  
  8
  
  ->
  
  7
  
  ,
  
  10
  
  ,
  
  9
  
  ,
  
  8
  
  (交换3次)
第二轮：
  
  7
  
  ,
  
  10
  
  ,
  
  9
  
  ,
  
  8
  
  ->
  
  7
  
  ,
  
  10
  
  ,
  
  8
  
  ,
  
  9
  
  ->
  
  7
  
  ,
  
  8
  
  ,
  
  10
  
  ,
  
  9
  
  (交换2次)
第一轮：
  
  7
  
  ,
  
  8
  
  ,
  
  10
  
  ,
  
  9
  
  ->
  
  7
  
  ,
  
  8
  
  ,
  
  9
  
  ,
  
  10
  
  (交换1次)
循环次数：6次
交换次数：6次

其他：
第一轮：
  
  8
  
  ,
  
  10
  
  ,
  
  7
  
  ,
  
  9
  
  ->
  
  8
  
  ,
  
  10
  
  ,
  
  7
  
  ,
  
  9
  
  ->
  
  8
  
  ,
  
  7
  
  ,
  
  10
  
  ,
  
  9
  
  ->
  
  7
  
  ,
  
  8
  
  ,
  
  10
  
  ,
  
  9
  
  (交换2次)
第二轮：
  
  7
  
  ,
  
  8
  
  ,
  
  10
  
  ,
  
  9
  
  ->
  
  7
  
  ,
  
  8
  
  ,
  
  10
  
  ,
  
  9
  
  ->
  
  7
  
  ,
  
  8
  
  ,
  
  10
  
  ,
  
  9
  
  (交换0次)
第一轮：
  
  7
  
  ,
  
  8
  
  ,
  
  10
  
  ,
  
  9
  
  ->
  
  7
  
  ,
  
  8
  
  ,
  
  9
  
  ,
  
  10
  
  (交换1次)
循环次数：6次
交换次数：3次

上面我们给出了程序段，现在我们分析它：这里，影响我们算法性能的主要部分是
 
 

 
 

  
  循环和交换，显然，次数越多，性能就越差。从上面的程序我们可以看出循环的
 
 

 
 

  
  次数是固定的，为1
  
  +
  
  2
  
  +
  
  ...
  
  +
  
  n
  
  -
  
  1
  
  。写成公式就是1
  
  /
  
  2
  
  *
  
  (n
  
  -
  
  1
  
  )
  
  *
  
  n。
 
 

 
 

  
  现在注意，我们给出O方法的定义：

    若存在一常量K和起点n0，使当n
  
  >=
  
  n0时，有f(n)
  
  <=
  
  K
  
  *
  
  g(n),则f(n) 
  
  =
  
   O(g(n))。（呵呵，不要说没学好数学呀，对于编程数学是非常重要的！！！）

现在我们来看1
  
  /
  
  2
  
  *
  
  (n
  
  -
  
  1
  
  )
  
  *
  
  n，当K
  
  =
  
  1
  
  /
  
  2
  
  ，n0
  
  =
  
  1
  
  ，g(n)
  
  =
  
  n
  
  *
  
  n时，
  
  1
  
  /
  
  2
  
  *
  
  (n
  
  -
  
  1
  
  )
  
  *
  
  n
  
  <=
  
  1
  
  /
  
  2
  
  *
  
  n
  
  *
  
  n
  
  =
  
  K
  
  *
  
  g(n)。所以f(n)
  
  =
  
  O(g(n))
  
  =
  
  O(n
  
  *
  
  n)。所以我们程序循环的复杂度为O(n
  
  *
  
  n)。
    再看交换。从程序后面所跟的表可以看到，两种情况的循环相同，交换不同。其实交换本身同数据源的有序程度有极大的关系，当数据处于倒序的情况时，交换次数同循环一样（每次循环判断都会交换），复杂度为O(n
  
  *
  
  n)。当数据为正序，将不会有交换。复杂度为O(
  
  0
  
  )。乱序时处于中间状态。正是由于这样的原因，我们通常都是通过循环次数来对比算法。
 
 

 
 


 
 

 
 

  
  pp.sohu.com/u/178199931/wTO0j8AeHbD/pTO0TNYBW3g
pp.sohu.com/u/178199931/wTO0j8AeHbD/pTO0TNYBW3g
pp.sohu.com/u/178199931/wTO0b5Rmxt2
pp.sohu.com/u/178199931/wTO0itWuwaq
pp.sohu.com/u/178199931/wTO02FejEIq
pp.sohu.com/u/178199931/wTO0BOlwkGH
pp.sohu.com/u/178199931/wTO0nSxqlkp
pp.sohu.com/u/178199931/wTO0wjCdY1d
pp.sohu.com/u/178199931/wTO0LDlFxQj
pp.sohu.com/u/178199931/wTOYANgxaIM
pp.sohu.com/u/178199931/wTOYYqFcVsG
pp.sohu.com/u/178199931/wTOY62SvKGE
pp.sohu.com/u/178199931/wTOYZPW3Rvk
pp.sohu.com/u/178199931/wTOYb7kkaX2
pp.sohu.com/u/178199931/wTOYipyU5aj
pp.sohu.com/u/178199931/wTOY9oRfl2p
pp.sohu.com/u/178199931/wTOYQ6T5wJj
pp.sohu.com/u/178199931/wTOYowLJMJn
pp.sohu.com/u/178199931/wTOYw1AGtxX
pp.sohu.com/u/178199931/wTOY7ijNYSt
pp.sohu.com/u/178199931/wTOkxyYDjkv
pp.sohu.com/u/178199931/wTOkc65wbtH
pp.sohu.com/u/178199931/wTOkNrOQQTg
pp.sohu.com/u/178199931/wTOkYVAj7Jf
pp.sohu.com/u/178199931/wTOkMjO3ys1
pp.sohu.com/u/178199931/wTOkT157y4d
pp.sohu.com/u/178199931/wTOktvFBJFg
pp.sohu.com/u/178199931/wTOkmdGLfDx
pp.sohu.com/u/178199931/wTOkUfQxeOG
pp.sohu.com/u/178199931/wTOkyDtYEWE
pp.sohu.com/u/178199931/wTOkVkF1RdD
pp.sohu.com/u/178199931/wTOkBC8qaoA
pp.sohu.com/u/178199931/wTOkHkIRFWD
pp.sohu.com/u/178199931/wTOkomxtN8z
pp.sohu.com/u/178199931/wTOkLy6jAwf
pp.sohu.com/u/178199931/wTOkERyFMLN
pp.sohu.com/u/178199931/wTOkunfLhLL
pp.sohu.com/u/178199931/wTOhSj1ZEFj
pp.sohu.com/u/178199931/wTOheZ0Ar1X
pp.sohu.com/u/178199931/wTOh0WJufcN
pp.sohu.com/u/178199931/wTOhMYiVEWx
pp.sohu.com/u/178199931/wTOhTHoC4ag
pp.sohu.com/u/178199931/wTOhDJLTn2E
pp.sohu.com/u/178199931/wTOh3hSxLAc
pp.sohu.com/u/178199931/wTOhmFQ8UO0
pp.sohu.com/u/178199931/wTOh8jDwmRf
pp.sohu.com/u/178199931/wTOhUcaw0Mk
pp.sohu.com/u/178199931/wTOh2fhccIq
pp.sohu.com/u/178199931/wTOhO2TeeTJ
pp.sohu.com/u/178199931/wTOhnH6z6R0
pp.sohu.com/u/178199931/wTOhwdqamCf

 
 

 
 

  
  
  
  
   
   

    
    2
    
    .交换法：
交换法的程序最清晰简单，每次用当前的元素一一的同其后的元素比较并交换。
#include 
    
    <
    
    iostream.h
    
    >
    
    

    
    void
    
     ExchangeSort(
    
    int
    
    *
    
     pData,
    
    int
    
     Count)
{
    
    
    int
    
     iTemp;
    
    
    for
    
    (
    
    int
    
     i
    
    =
    
    0
    
    ;i
    
    <
    
    Count
    
    -
    
    1
    
    ;i
    
    ++
    
    )
    {
        
    
    for
    
    (
    
    int
    
     j
    
    =
    
    i
    
    +
    
    1
    
    ;j
    
    <
    
    Count;j
    
    ++
    
    )
        {
            
    
    if
    
    (pData[j]
    
    <
    
    pData[i])
            {
                iTemp 
    
    =
    
     pData[i];
                pData[i] 
    
    =
    
     pData[j];
                pData[j] 
    
    =
    
     iTemp;
            }
        }
    }
}


    
    void
    
     main()
{
    
    
    int
    
     data[] 
    
    =
    
     {
    
    10
    
    ,
    
    9
    
    ,
    
    8
    
    ,
    
    7
    
    ,
    
    6
    
    ,
    
    5
    
    ,
    
    4
    
    };
    ExchangeSort(data,
    
    7
    
    );
    
    
    for
    
     (
    
    int
    
     i
    
    =
    
    0
    
    ;i
    
    <
    
    7
    
    ;i
    
    ++
    
    )
        cout
    
    <<
    
    data[i]
    
    <<
    
    "
    
     
    
    "
    
    ;
    cout
    
    <<
    
    "
    
    /n
    
    "
    
    ;
}
   
   

   
   

    
    
    
    
     
     

      
       before_compare|one_turn|two_turn|three_turn|four_turn|five_turn|six_turn
     
     

     
     

      
               10         
      
      9         
      
      8        
      
       7        
      
       6          
      
       5     
      
      4            
     
     

     
     

      
                9        
      
      10        10         10       10           10    10
     
     

     
     

      
                8         8        
      
       9         9         9           9     9
     
     

     
     

      
                7         7         7         
      
      8         8           8     8
     
     

     
     

      
                6         6         6         6        
      
       7           7     7
     
     

     
     

      
                5         5         5         5
      
            5        6   6
     
     

     
     

      
                4
      
               4         4         4         4           4     
      
      5 
     
     
从上面的算法来看，基本和冒泡法的效率一样。倒序(最糟情况)第一轮：
    
    10
    
    ,
    
    9
    
    ,
    
    8
    
    ,
    
    7
    
    ->
    
    9
    
    ,
    
    10
    
    ,
    
    8
    
    ,
    
    7
    
    ->
    
    8
    
    ,
    
    10
    
    ,
    
    9
    
    ,
    
    7
    
    ->
    
    7
    
    ,
    
    10
    
    ,
    
    9
    
    ,
    
    8
    
    (交换3次)第二轮：
    
    7
    
    ,
    
    10
    
    ,
    
    9
    
    ,
    
    8
    
    ->
    
    7
    
    ,
    
    9
    
    ,
    
    10
    
    ,
    
    8
    
    ->
    
    7
    
    ,
    
    8
    
    ,
    
    10
    
    ,
    
    9
    
    (交换2次)第一轮：
    
    7
    
    ,
    
    8
    
    ,
    
    10
    
    ,
    
    9
    
    ->
    
    7
    
    ,
    
    8
    
    ,
    
    9
    
    ,
    
    10
    
    (交换1次)循环次数：6次交换次数：6次其他：第一轮：
    
    8
    
    ,
    
    10
    
    ,
    
    7
    
    ,
    
    9
    
    ->
    
    8
    
    ,
    
    10
    
    ,
    
    7
    
    ,
    
    9
    
    ->
    
    7
    
    ,
    
    10
    
    ,
    
    8
    
    ,
    
    9
    
    ->
    
    7
    
    ,
    
    10
    
    ,
    
    8
    
    ,
    
    9
    
    (交换1次)第二轮：
    
    7
    
    ,
    
    10
    
    ,
    
    8
    
    ,
    
    9
    
    ->
    
    7
    
    ,
    
    8
    
    ,
    
    10
    
    ,
    
    9
    
    ->
    
    7
    
    ,
    
    8
    
    ,
    
    10
    
    ,
    
    9
    
    (交换1次)第一轮：
    
    7
    
    ,
    
    8
    
    ,
    
    10
    
    ,
    
    9
    
    ->
    
    7
    
    ,
    
    8
    
    ,
    
    9
    
    ,
    
    10
    
    (交换1次)循环次数：6次交换次数：3次从运行的表格来看，交换几乎和冒泡一样糟。事实确实如此。循环次数和冒泡一样也是1
    
    /
    
    2
    
    *
    
    (n
    
    -
    
    1
    
    )
    
    *
    
    n，所以算法的复杂度仍然是O(n
    
    *
    
    n)。由于我们无法给出所有的情况，所以只能直接告诉大家他们在交换上面也是一样的糟糕（在某些情况下稍好，在某些情况下稍差）。
   
   

   
   

    
    

   
   

   
   

    
    

   
   

   
   

    
    
    
    
     
     

      
      3
      
      .选择法：
现在我们终于可以看到一点希望：选择法，这种方法提高了一点性能（某些情况下）这种方法类似我们人为的排序习惯：
     
     

     
     

      
      从数据中选择最小的同第一个值交换，在从省下的部分中选择最小的与第二个交换，这样往复下去。
#include 
      
      <
      
      iostream.h
      
      >
      
      

      
      void
      
       SelectSort(
      
      int
      
      *
      
       pData,
      
      int
      
       Count)
{
    
      
      int
      
       iTemp;
    
      
      int
      
       iPos;
    
      
      for
      
      (
      
      int
      
       i
      
      =
      
      0
      
      ;i
      
      <
      
      Count
      
      -
      
      1
      
      ;i
      
      ++
      
      )
    {
        iTemp 
      
      =
      
       pData[i];
        iPos 
      
      =
      
       i;
        
      
      for
      
      (
      
      int
      
       j
      
      =
      
      i
      
      +
      
      1
      
      ;j
      
      <
      
      Count;j
      
      ++
      
      )
        {
            
      
      if
      
      (pData[j]
      
      <
      
      iTemp)
            {
                iTemp 
      
      =
      
       pData[j];
                iPos 
      
      =
      
       j;
            }
        }
        pData[iPos] 
      
      =
      
       pData[i];
        pData[i] 
      
      =
      
       iTemp;
    }
}
sdjasdaslk
关注
C++基础学习代码
u013445609的博客
02-20 822
#include <iostream> using namespace std; //父类 class Father { public: //函数重载 void work(int num) { std::cout << "This is Father @ " << num << endl; } ...
html代码大全：常常会遇到的问题
怀公子的博客
12-24 983
　点击关闭窗口 　　&lt;a href="javascript.:top.window.close();"&gt;点击关闭窗口&lt;/a&gt;！ 　　请问如何去掉主页右面的滚动条？ 　　&lt;body scroll="no"&gt; 　　&lt;body style="overflow-y:hidden"&gt; 　　如何做到让一个网页自动关闭. 　　&lt;htm
C++基础代码
热门推荐
pursuit_zhangyu的博客
09-27 1万+
文件操作 https://www.cnblogs.com/xiximayou/p/12102781.html c++对文件进行操作需要使用头文件<fstream> 文本文件：文件以文本的ASCII码形式存储在计算机中； 二进制文件：文件以文件的二进制存储在计算机中，用户一般不能直接读取它们 操作文件的三大类： ofstream：写 ifstream：读 fstream：读写 写文本文件步骤：包含头文件：#include<ftream>、创建流对象：ofstream o
C++ | （一）C++入门基础
最新发布
李龙蛋Seabiscuit380的博客
08-04 1059
本文主要对C++的基础部分进行讲解，包括命名空间namespace，C++的输入与输出，缺省参数，函数重载，引用及其特性，const修饰引用，inline修饰函数，以及NULL在C与C++中的不同意义与nullptr
C++基础代码1
pursuit_zhangyu的博客
10-07 448
STL C++ STL（标准模板库）是一套功能强大的 C++ 模板类。 STL从广义上分为：容器（container）算法（algorithm）迭代器（iterator） STL的六大组件 Container(容器) 各种基本数据结构，如vector、list、deque、set、map等，用来存放数据 Algorithm(算法) 各种基本算法，如sort、find、copy、for_each…等 Iterator(迭代器) 连接containers和algorithms Adapter(适配
C++类基础代码
Fatestay_DC的专栏
08-02 636
include using namespace std;pragma onceclass Sale_items { friend Sale_items add(const Sale_items&,const Sale_items&); friend ostream &print(ostream&,const Sale_items&); friend istream &
C++基本代码
07-17
给新手入门写Hello World的框架
C++常用代码
SylarChonna的博客
10-14 7112
C++手撕代码
(完整版)C++经典程序代码大全.doc
11-23
本资源提供了多个C++程序代码示例，涵盖了基本数据类型、变量声明、函数定义、输入输出操作等多方面的知识点。 1. 变量声明和赋值 在C++中，变量声明需要指定变量的数据类型，例如`float r,l,s;`声明了三个浮点数...
C++玫瑰代码，画出一朵玫瑰
04-24
1. C++语言的基本语法和数据类型 2. 结构体的定义和使用 3. 数学运算符和函数的使用 4. 条件语句和循环语句的使用 5. Graphics.h头文件提供的图形绘制函数 6. Conio.h头文件提供的控制台输入/输出函数 7.玫瑰图形的...
C++经典代码大全（超级详细）
03-02
根据提供的文件信息，本文将基于“C++经典代码大全（超级详细）”这一主题展开，深入探讨C++语言中的经典代码实例以及相关的编程知识点。由于原文档内容并未给出具体的知识点，以下内容将综合C++的基本概念、常用...
C++编程基础代码
06-14
C++基础，对C++的基础代码源文件和一些例子
C/C++基础部分代码
03-21
本压缩包里面包含作者博客上C/C++学习笔记--基础部分的所有代码； 解压即可逐个文件夹以项目形式用VS打开； 有些项目里面包含多个cpp文件，由于一个项目只允许有一个main函数， 所以可能需要手动来进行注释/取消注释相关部分代码才能运行 另外，由于本作者能力有限，有些代码可能有误如发现错误可以私信我提出改进，谢谢！
学习C++的一些基础代码
05-25
好好学习，天天向上：）
C++基础代码--20余种数据结构和算法的实现
11-22
这个C++实现的基础数据结构和算法，分享出来供大家学习使用！
c++ 基础代码使用
我壮着胆子再问一遍冬雪枫花
02-28 1025
C++ 继承，多态，虚函数等概念的简化整理和举例分析
c++的一些基础代码
qq_41358574的博客
12-19 5502
标题输入一个八位二进制 化为十进制 if include < iostream> using namespace std; //计算x 的口次方 double power (double x , int n) ; int main () { int value=O; cout<< "Enter an 8 bi t binary number: "; for (int i=7; i>=O; i--) { char ch; cin>>ch; if (ch== '1')
c++基础定义
比雅尼·斯特劳斯特鲁普（Bjarne Stroustrup）曾说过：如果你没看过这些博客，那么你的编程不会拥有智慧，你的代码不可能附有灵魂。
09-19 267
c++ 引用，const，函数重载基础定理
c++基础代码
hshsggvv的博客
04-18 257
这就是今天的内容啦，如果喜欢的话，请关注一下小编吧！c++定义变量用到通常用（整形）
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值