【2019】递归/冒泡排序/二分查找

递归/冒泡排序/二分查找

递归

      /// <summary>
      /// 递归 1+2+3+4+5
      /// </summary>
      /// <param name="arr"></param>
      /// <param name="value"></param>
      /// <returns></returns>
      [Description("//https://www.cnblogs.com/lfxiao/p/6742477.html")]
      public static int GetRecursion(int Index)
      {
          while (true)
          {
              if (Index == 1)
	            {
                  return 1;
	            }
              return Index + GetRecursion(Index - 1);
          }
      }

      /// <summary>
      /// 递归 1+1+2+3+4+5
      /// </summary>
      /// <param name="Index"></param>
      /// <returns></returns>
      public static int GetRecursion2(int Index)
      {
          //while (true)
          {
              if (Index == 1)
              {
                  return 1;
              }
              else if (Index <= 0)
              {
                  return 0;
              }
              else if (Index == 2)
              {
                  return 2;
              }
              return Index + GetRecursion2(Index - 1);
          }
      }

          int value = GetRecursion(4);
          int value2 = GetRecursion2(5);
          Console.WriteLine(value);

冒泡排序

      /// <summary>
      /// 冒泡排序 从大到小
      /// </summary>
      /// <param name="data"></param>
      public void BubbleSort(double[] data)
      {
          for (int i = 0; i < data.Length - 1; i++)
          {
              for (int j = data.Length - 1; j > i; j--)
              {
                  if (data[j] > data[j - 1])
                  {
                      data[j] = data[j] + data[j - 1];
                      data[j - 1] = data[j] - data[j - 1];
                      data[j] = data[j] - data[j - 1];
                  }
              }
          }
      }

      /// <summary>
      /// 冒泡排序 从小到大
      /// </summary>
      /// <param name="data"></param>
      /// <returns></returns>
      public static void GetBubbleSort(double[] data)
      {
          for (int i = 0; i < data.Length - 1; i++)
          {
              for (int j = 0; j < data.Length - 1 - i; j++)
              {
                  if (data[j] > data[j + 1])
                  {
                      data[j] = data[j] + data[j + 1];
                      data[j + 1] = data[j] - data[j + 1];
                      data[j] = data[j] - data[j + 1];
                  }
              }
          }
      }

      /// <summary>
      /// 效率低
      /// </summary>
      /// <param name="list"></param>
      public void PopSort(int[] list)
      {
          int i, j, temp;  //先定义一下要用的变量
          for (i = 0; i < list.Length - 1; i++)
          {
              for (j = i + 1; j < list.Length; j++)
              {
                  if (list[i] > list[j]) //如果第二个小于第一个数
                  {
                      //交换两个数的位置，在这里你也可以单独写一个交换方法，在此调用就行了
                      temp = list[i]; //把大的数放在一个临时存储位置
                      list[i] = list[j]; //然后把小的数赋给前一个，保证每趟排序前面的最小
                      list[j] = temp; //然后把临时位置的那个大数赋给后一个
                  }
              }
          }
      }

          double[] data = new double[5] { 3.1,2.1,4.1,5.1,3.5};
          BubbleSort(data); 

二分查找

      /// <summary>
      /// 二分法查找
      /// </summary>
      /// <param name="arr"></param>
      /// <param name="key">要查找的对象</param>
      public static int GetBinarySearch(int[] arr, int value)
      {
          int low = 0;
          int high = arr.Length - 1;
          while (low <= high)
          {
              int middle = (low + high) / 2;
              if (value == arr[middle])
              {
                  return middle;//如果找到了就直接返回这个元素的索引
              }
              else if (value > arr[middle])
              {
                  low = middle + 1;
              }
              else
              {
                  high = middle - 1;
              }
          }
          return -1;//如果找不到就返回-1；
      }

          int[] arr = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
          int value = GetBinarySearch(arr, 4);
          Console.WriteLine(arr[value]);