C/C++ 排序&&查找算法(面试)

一、排序

1.冒泡排序

 1 void BubbleSort(int array[],int n)
 2 {
 3     int i=0;
 4     int j=0;
 5     int temp=0;
 6     int flag = 0;
 7     for(i=0;i<n - 1 ;i++)   /*外循环控制排序的总趟数*/
 8     {
 9         flag = 0;   /*本趟排序开始前,交换标志应为假*/
10        for(j=n-1;j > i;j--) /*内循环控制一趟排序的进行*/
11        {
12            if(array[j] < array[j-1] ) /*相邻元素进行比较,若逆序就交换*/
13            {
14              temp =array[j];
15              array[j] = array[j-1];
16              array[j-1] = temp;
17              flag = 1;                  /*发生了交换,故将交换标志置为真*/
18            }
19
20        }
21         if (flag == 0)  /*本趟排序未发生交换,提前终止算法*/
22            break;
23     }
24 }

冒泡排序--递归实现

 1  void SortByRecursion( int *array, int n )
 2  {
 3       int i;
 4       if(1 == n)
 5       {
 6           return;
 7       }
 8       for(i = 0; i < n - 1; i++)
 9       {
10          if(array[i] > array[i + 1])
11               swap( &array[i], &array[i + 1]);
12      }
13      SortByRecursion( array, n - 1 );
14  }

2.插入排序

 1 void InsertSort(int arr[], int count)
 2 {
 3      for (int i = 1; i < count; ++i)
 4      {
 5          if (arr[i] < arr[i - 1])
 6          {
 7              int j = 0;
 8              int key= arr[i];
 9              arr[i] = arr[i - 1];
10              for (j = i - 2; ((j >= 0) && (key< arr[j])); --j)
11              {
12                      arr[j + 1] = arr[j];
13              }
14              arr[j + 1] = key;
15          }
16      }
17 }

插入排序---递归实现

 1 void Insert(int *a,int n)//把数组a的第n个数插入前n-1个数中,注意前n-1个数已经是排好序的了
 2  {
 3      int i=n-1;
 4       int key=a[n];
 5       while((i>=0)&&(key<a[i]))
 6       {
 7           a[i+1]=a[i];
 8           i--;
 9       }
10      a[i+1]=key;
11      return;
12  }
13
14  void InsertionSort(int *a,int n)//递归插入,跟求阶乘的思想一样,前n-1个排好序的数组,是建立在前n-2个排好序的数组的基础上插出来的
15  {
16      if(n>0)
17      {
18          Insert(a,n);
19          InsertionSort(a,n-1);
20      }
21      else
22          return;
23  }

3.快速排序

 1 int PartSort(int arr[],int low, int high)
 2 {
 3     int key = arr[low];
 4     while(low < high)
 5     {
 6         while(low < high && arr[high] >= key)
 7             --high;
 8         arr[low] = arr[high];
 9         while(low < high && arr[low] <= key)
10           ++low;
11         arr[high] = arr[low];
12     }
13     arr[low] = key;
14     return low;
15 }
16 void QuickSort(int arr[],int low, int high)
17 {
18      if(low < high)
19      {
20          int pos = PartSort(arr, low, high);
21          QuickSort(arr, pos+1, high);
22          QuickSort(arr, low, pos-1);
23      }
24 }

二、查找

1.折半查找

 1 int  HalfFind(int arr[], int count,int key)
 2 {
 3     int low = 0;
 4     int high = count - 1;
 5     while(low <= high)
 6     {
 7         int mid = (low + high)/2;
 8         if (arr[mid] == key)
 9         {
10             return mid;
11         }
12         else if(arr[mid] > key)
13         {
14             high = mid - 1 ;
15         }
16         else
17         {
18             low = mid + 1;
19         }
20     }
21 }

C/C++ 排序&&查找算法(面试)

时间: 2024-10-22 17:46:48

C/C++ 排序&&查找算法(面试)的相关文章

Java数据结构 遍历 排序 查找 算法实现

1. 遍历算法(遍历二叉树6种方法) 1.1. 概述 遍历算法针对二叉树而言的,主要有先序.中序.后序三种遍历顺序,三种顺序又分别有递归和常规算法,二叉树遍历的主要思想是:遍历左子树,遍历右子树,访问根节点,由这三者的遍历顺序来确定是先序.中序还是后序.下面只要求掌握递归遍历算法,常规遍历算法见附录一. 1.2. 先序遍历算法 遍历顺序:访问根节点,遍历左子树,遍历右子树.代码如下: void preOrder(BinaryTreeNode bt) { if (bt == null)// 如果当

面试常见算法-排序查找算法

算法是程序员必被的一个技能,在面试中常常出现,下面总结了面试中出现的常见算法,这些算法程序员应该牢记在心中,要非常熟练. 插入排序算法 原理:将数组分为无序区和有序区两个区,然后不断将无序区的第一个元素按大小顺序插入到有序区中去,最终将所有无序区元素都移动到有序区完成排序. 要点:设立哨兵,作为临时存储和判断数组边界之用. public class InsertSort { private static void insertSort(int[] a) { int j; int tmp; for

深入JDK源码之Arrays类中的排序查找算法(转)

原文出处: 陶邦仁 binarySearch()方法 二分法查找算法,算法思想:当数据量很大适宜采用该方法.采用二分法查找时,数据需是排好序的. 基本思想:假设数据是按升序排序的,对于给定值x,从序列的中间位置开始比较,如果当前位置值等于x,则查找成功:若x小于当前位置值,则在数列的前半段中查找:若x大于当前位置值则在数列的后半段中继续查找,直到找到为止. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 //针对int类型数组的二分法查找,key为要查找数的下

Java排序查找算法——二分法与递归的应用实例

问题描述: 对数组元素进行查找与排序,利用二分法与递归实现. 完整实例1: public class SortDemo {    public static void main(String[] args)    {       int[] arr={10,2,300,41,15,6};       for(int a:arr)       {          System.out.print("["+a+"]");           }      // new

Python 实现二分查找算法

最近在学习python,由于在面试中,二分查找算法面试率极高,所以使用python做了一个实现. def search1(sequence, number): lower = 0 upper = len(sequence) - 1 while lower <= upper: mid = (lower + upper) // 2 if number > sequence[mid]: lower = mid + 1 elif number < sequence[mid]: upper = m

排序、查找算法

1> 插入排序 //插入排序(把第一个当作也排好序,然后对后面的依次插入到已排好序的队列中)平均时间复杂度0(n^2) public void insertSort(int[] a){ for(int i = 1;i<a.length;i++){ for(int j = i;j > 0;j--){ if(a[j] < a[j-1]){ int tmp = a[j]; a[j] = a[j-1]; a[j-1] = tmp; } } } } 2> 希尔排序 /*希尔排序:平均时

Java学习 (七)、数组,查找算法,二分查找法,冒泡排序,选择排序,插入排序

一.常用数组查找算法 工作原理:它又称为顺序查找,在一列给定的值中进行搜索,从一端的开始逐一检查每个元素,知道找到所需元素的过程. 例1:查找指定的数在数组中出现的位置,找到返回下标,找不到返回-1 1 import java.util.Scanner; 2 public class LinearSearch{ 3 public static void main(String []argas) 4 { 5 int [] array={10,100,90,65,80,92}; 6 System.o

所有的排序、查找算法

import javax.mail.Part; /** * 顺序查找.排序 * * @author 曾修建 * @version 创建时间:2014-7-30 下午04:15:10 */ public class SequentialSearch { public static void main(String[] args) { Integer[] a = {1,2,3,4,5,7,6,88}; //二分查找非递归 System.out.println( "二分查找非递归实现 位置 : &qu

排序和查找算法的使用

TBOX提供了各种常用算法,对容器中的元素进行各种操作,这里主要介绍下排序和查找算法. 排序算法目前支持如下几种: 快速排序:tb_quick_sort 堆排序: tb_heap_sort 插入排序:tb_bubble_sort 冒泡排序:tb_insert_sort 并且提供通用的tb_sort接口,对各种排序算法进行自动适配,使得任何情况下,性能都是最优的. 例如: 对具有随机迭代特性的容器,采用库快速排序来优化 对具有随机迭代特性,并且是超大规模的容器,采用堆排序 对只能线性迭代的容器采用