2. 程式人生 > >C++ 經典演算法 面試絕殺

C++ 經典演算法 面試絕殺

阿新 • • 發佈：2019-02-01

1.連結串列逆序

2.連結串列合併

3.一棵樹是否某條路徑結點之和等於給定值。並描述演算法複雜度

4.你熟悉的排序演算法並描述演算法複雜度。

         快速排序

         歸併排序

         堆排序

         選擇排序

         插入排序

        氣泡排序

        折半插入排序

以下程式碼都能成功通過。

1.連結串列逆序


[cpp] view plain copy print?
  1. #include <iostream>
  2. usingnamespace std;  
  3. struct node  
  4. {  
  5.     int value;  
  6.     node * next;  
  7. };  
  8. node* make_link(void);  
  9. node* reverse(node*);  
  10. void display(node *);  
  11. int main()  
  12. {  
  13.     node *head=make_link();  
  14.     display(head);  
  15.     head=reverse(head);  
  16.     display(head);  
  17.     return 0;  
  18. }  
  19. node* make_link(void)  
  20. {  
  21.     node *head=new node();  
  22.     node *cur=head;  
  23.     for
    (int i=0;i<10;i++)  
  24.     {  
  25.         cur->value=rand()%10;  
  26.         cur->next=new node();  
  27.         cur=cur->next;  
  28.     }  
  29.     return head;  
  30. }  
  31. node* reverse(node *head)  
  32. {  
  33.     node *pre,*post,*cur;  
  34.     if(!head && !head->next)  
  35.         return head;  
  36.     pre=head;  
  37.     cur=pre->next;  
  38.     while(cur)  
  39.     {  
  40.         post=cur->next;  
  41.         cur->next=pre;  
  42.         pre=cur;  
  43.         cur=post;  
  44.     }  
  45.     head->next=NULL;  
  46.     return pre;  
  47. }  
  48. void display(node * head)  
  49. {  
  50.     node * cur=head;  
  51.     while(cur)  
  52.     {  
  53.         cout<<cur->value<<" ";  
  54.         cur=cur->next;  
  55.     }  
  56.     cout<<endl;  
  57. }  
#include <iostream>
using namespace std;

struct node
{
    int value;
    node * next;
};

node* make_link(void);
node* reverse(node*);
void display(node *);

int main()
{
    node *head=make_link();
    display(head);
    head=reverse(head);
    display(head);

    return 0;
}

node* make_link(void)
{
    node *head=new node();
    node *cur=head;
    for(int i=0;i<10;i++)
    {
        cur->value=rand()%10;
        cur->next=new node();
        cur=cur->next;
    }

    return head;
}

node* reverse(node *head)
{
    node *pre,*post,*cur;
    if(!head && !head->next)
        return head;
    pre=head;
    cur=pre->next;
    while(cur)
    {
        post=cur->next;
        cur->next=pre;
        pre=cur;
        cur=post;
    }
    head->next=NULL;
    return pre;
}

void display(node * head)
{
    node * cur=head;
    while(cur)
    {
        cout<<cur->value<<" ";
        cur=cur->next;
    }
    cout<<endl;
}




2.連結串列合併
[cpp] view plain copy print?
  1. #include <iostream>
  2. usingnamespace std;  
  3. struct node  
  4. {  
  5.     int value;  
  6.     node *next;  
  7. };  
  8. node *make_list(void);  
  9. void display(node *);  
  10. void sort(node *);  
  11. node *merge(node *,node *);  
  12. int main()  
  13. {  
  14.     node *node1=make_list();  
  15.     display(node1);  
  16.     sort(node1);  
  17.     node *node2=make_list();  
  18.     display(node2);  
  19.     sort(node2);  
  20.     node *mnode=merge(node1,node2);  
  21.      display(mnode);  
  22.     return 0;  
  23. }  
  24. node *make_list(void)  
  25. {  
  26.     node *head=new node();  
  27.     node *cur=head;  
  28.     for(int i=0;i<10;i++)  
  29.     {  
  30.         cur->value=rand()%10;  
  31.         cur->next=new node();  
  32.         cur=cur->next;  
  33.     }  
  34.     return head;  
  35. }  
  36. void display(node *head)  
  37. {  
  38.     node *cur=head;  
  39.     while(cur)  
  40.     {  
  41.         cout<<cur->value<<" ";  
  42.         cur=cur->next;  
  43.     }  
  44.     cout<<endl;  
  45. }  
  46. void sort(node *head)  
  47. {  
  48.     node *cur=head;  
  49.     while(cur)  
  50.     {  
  51.         node *min=cur;  
  52.         node *cur2=cur->next;  
  53.         while(cur2)  
  54.         {  
  55.             if(cur2->value < min->value)  
  56.                 min=cur2;  
  57.             cur2=cur2->next;  
  58.         }  
  59.         int temp=cur->value;  
  60.         cur->value=min->value;  
  61.         min->value=temp;  
  62.         cur=cur->next;  
  63.     }  
  64. }  
  65. node *merge(node *h1,node *h2)  
  66. {  
  67.     node *mcur=new node();  
  68.     node *cur1=h1;  
  69.     node *cur2=h2;  
  70.     while(cur1&&cur2)  
  71.     {  
  72.         if(cur1->value < cur2->value)  
  73.         {  
  74.             mcur->next=cur1;  
  75.             mcur=mcur->next;  
  76.             cur1=cur1->next;  
  77.         }  
  78.         else
  79.         {  
  80.             mcur->next=cur2;  
  81.             mcur=mcur->next;  
  82.             cur2=cur2->next;  
  83.         }  
  84.     }  
  85.     if(cur1)  
  86.         mcur->next=cur1;  
  87.     else
  88.         mcur->next=cur2;  
  89.     return h1->value < h2->value ? h1:h2;  
  90. }  
#include <iostream>

using namespace std;

struct node
{
    int value;
    node *next;
};

node *make_list(void);
void display(node *);
void sort(node *);
node *merge(node *,node *);

int main()
{
    node *node1=make_list();
    display(node1);
    sort(node1);

    node *node2=make_list();
    display(node2);
    sort(node2);

    node *mnode=merge(node1,node2);
     display(mnode);

    return 0;
}


node *make_list(void)
{
    node *head=new node();
    node *cur=head;
    for(int i=0;i<10;i++)
    {
        cur->value=rand()%10;
        cur->next=new node();
        cur=cur->next;
    }

    return head;
}

void display(node *head)
{
    node *cur=head;
    while(cur)
    {
        cout<<cur->value<<" ";
        cur=cur->next;
    }
    cout<<endl;
}


void sort(node *head)
{
    node *cur=head;
    while(cur)
    {
        node *min=cur;
        node *cur2=cur->next;
        while(cur2)
        {
            if(cur2->value < min->value)
                min=cur2;
            cur2=cur2->next;
        }

        int temp=cur->value;
        cur->value=min->value;
        min->value=temp;
        cur=cur->next;
    }
}

node *merge(node *h1,node *h2)
{
    node *mcur=new node();
    node *cur1=h1;
    node *cur2=h2;
    while(cur1&&cur2)
    {
        if(cur1->value < cur2->value)
        {
            mcur->next=cur1;
            mcur=mcur->next;
            cur1=cur1->next;
        }
        else
        {
            mcur->next=cur2;
            mcur=mcur->next;
            cur2=cur2->next;
        }
    }
    if(cur1)
        mcur->next=cur1;
    else
        mcur->next=cur2;
    return h1->value < h2->value ? h1:h2;
}



3.一棵樹是否某條路徑結點之和等於給定值。並描述演算法複雜度
[cpp] view plain copy print?
  1. #include <iostream>
  2. usingnamespace std;  
  3. struct node  
  4. {  
  5.     int value;  
  6.     node *left;  
  7.     node *right;  
  8. };  
  9. node * build_tree(void);  
  10. bool find(node *,int);  
  11. int main()  
  12. {  
  13.     node *tree=build_tree();  
  14.     int t;  
  15.     cout<<"Enter your number:";  
  16.     cin>>t;  
  17.     cout<<endl;  
  18.     cout<<find(tree,t)<<endl;  
  19. }  
  20. node *build_tree()  
  21. {  
  22.     int a;  
  23.     cin>>a;  
  24.     if(a == 0)  
  25.         return NULL;  
  26.     node *root=new node();  
  27.     root->value=a;  
  28.     root->left=build_tree();  
  29.     root->right=build_tree();  
  30.     cout<<"build tree success"<<endl;  
  31.     return root;  
  32. }  
  33. bool find(node *root,int v)  
  34. {  
  35.     if(!root)  
  36.         returnfalse;  
  37.     if(root->value == v)  
  38.         returntrue;  
  39.     else find(root->left,v-root->value) || find(root->right,v-root->value);  
  40. }  
#include <iostream>
using namespace std;

struct node
{
    int value;
    node *left;
    node *right;
};

node * build_tree(void);
bool find(node *,int);

int main()
{
    node *tree=build_tree();
    int t;
    cout<<"Enter your number:";
    cin>>t;
    cout<<endl;
    cout<<find(tree,t)<<endl;
}

node *build_tree()
{
    int a;
    cin>>a;
    if(a == 0)
        return NULL;
    node *root=new node();
    root->value=a;
    root->left=build_tree();
    root->right=build_tree();

    cout<<"build tree success"<<endl;
    return root;
}

bool find(node *root,int v)
{
    if(!root)
        return false;
    if(root->value == v)
        return true;
    else find(root->left,v-root->value) || find(root->right,v-root->value);
}



4.你熟悉的排序演算法並描述演算法複雜度。
快速排序

[cpp] view plain copy print?
  1. #include <iostream>
  2. usingnamespace std;  
  3. int partition(int a[],int low,int high)  
  4. {  
  5.     int key=a[low]; //用子表的第一個記錄作杻軸記錄
  6.     while(low < high)   //從表的兩端交替地向中間掃描
  7.     {  
  8.         while(low < high && a[high] >= key)  
  9.             --high;  
  10.         {                  //將比杻軸記錄小的記錄交換到低端
  11.             int temp=a[low];  
  12.             a[low]=a[high];  
  13.             a[high]=temp;  
  14.         }  
  15.         while(low < high && a[low] <= key)  
  16.             ++low;  
  17.         {                 //將比杻軸記錄大的記錄交換到低端
  18.             int temp=a[low];  
  19.             a[low]=a[high];  
  20.             a[high]=temp;  
  21.         }  
  22.     }  
  23.     return low;   //返回杻軸所在的位置
  24. }  
  25. void qsort(int a[],int b,int e)  
  26. {  
  27.     if(b < e)  
  28.     {  
  29.         int m=partition(a,b,e);  
  30.         qsort(a,b,m-1);  
  31.         qsort(a,m+1,e);  
  32.     }  
  33. }  
  34. int main()  
  35. {  
  36.     int a[]={2,3,7,8,3,5};  
  37.     qsort(a,0,5);  
  38.     for(int i=0;i<6;i++)  
  39.         cout<<a[i]<<" ";  
  40.     cout<<endl;  
  41.     return 0;  
  42. }  
#include <iostream>
using namespace std;

int partition(int a[],int low,int high)
{
    int key=a[low]; //用子表的第一個記錄作杻軸記錄
    while(low < high)   //從表的兩端交替地向中間掃描
    {
        while(low < high && a[high] >= key)
            --high;
        {                  //將比杻軸記錄小的記錄交換到低端
            int temp=a[low];
            a[low]=a[high];
            a[high]=temp;
        }

        while(low < high && a[low] <= key)
            ++low;
        {                 //將比杻軸記錄大的記錄交換到低端
            int temp=a[low];
            a[low]=a[high];
            a[high]=temp;
        }
    }
    return low;   //返回杻軸所在的位置
}

void qsort(int a[],int b,int e)
{
    if(b < e)
    {
        int m=partition(a,b,e);
        qsort(a,b,m-1);
        qsort(a,m+1,e);
    }
}

int main()
{
    int a[]={2,3,7,8,3,5};
    qsort(a,0,5);
    for(int i=0;i<6;i++)
        cout<<a[i]<<" ";
    cout<<endl;

    return 0;
}



歸併排序
[cpp] view plain copy print?
  1. #include <iostream>
  2. usingnamespace std;  
  3. void display(int a[],int size)  
  4. {  
  5.     for(int i=0;i<size;i++)  
  6.         cout<<a[i]<<" ";  
  7.     cout<<endl;  
  8. }  
  9. void mmerge(int *a,int low,int middle ,int high )  
  10. {  
  11.     int fronArray[100],postArray[100];  
  12.     int front=middle-low+1;  
  13.     int post=high-middle;  
  14.     for(int i=0;i<front;i++)  
  15.         fronArray[i]=a[low+i];  
  16.     for(int j=0;j<post;j++)  
  17.         postArray[j]=a[middle+j+1];  
  18.     fronArray[front]=9999; //哨兵
  19.     postArray[post]=9999;  
  20.     int i=0,j=0;  
  21.     for(int k=low;k<=high;k++)  
  22.     {  
  23.         if(fronArray[i]<postArray[j])  
  24.             a[k]=fronArray[i++];  
  25.         else
  26.             a[k]=postArray[j++];  
  27.     }  
  28. }  
  29. void merge_sort(int *a,int low,int high)  
  30. {  
  31.     if(low<high)  
  32.     {  
  33.         int middle=(low+high)/2;  
  34.         merge_sort(a,low,middle);  
  35.         merge_sort(a,middle+1,high);  
  36.         mmerge(a,low,middle,high);  
  37.     }  
  38. }  
  39. int main()  
  40. {  
  41.     int a[]={9,3,5,7,6,8,10,22,21,34};  
  42.     display(a,10);  
  43.     merge_sort(a,0,9);  
  44.     display(a,10);  
  45.     return 0;  
  46. }  
#include <iostream>
using namespace std;

void display(int a[],int size)
{
    for(int i=0;i<size;i++)
        cout<<a[i]<<" ";
    cout<<endl;
}

void mmerge(int *a,int low,int middle ,int high )
{
    int fronArray[100],postArray[100];
    int front=middle-low+1;
    int post=high-middle;
    for(int i=0;i<front;i++)
        fronArray[i]=a[low+i];

    for(int j=0;j<post;j++)
        postArray[j]=a[middle+j+1];

    fronArray[front]=9999; //哨兵
    postArray[post]=9999;

    int i=0,j=0;
    for(int k=low;k<=high;k++)
    {
        if(fronArray[i]<postArray[j])
            a[k]=fronArray[i++];
        else
            a[k]=postArray[j++];
    }
}

void merge_sort(int *a,int low,int high)
{
    if(low<high)
    {
        int middle=(low+high)/2;
        merge_sort(a,low,middle);
        merge_sort(a,middle+1,high);
        mmerge(a,low,middle,high);
    }
}

int main()
{
    int a[]={9,3,5,7,6,8,10,22,21,34};
    display(a,10);
    merge_sort(a,0,9);
    display(a,10);

    return 0;
}


堆排序

[cpp] view plain copy print?
  1. /* 
  2. 堆排序 
  3. (1)用大根堆排序的基本思想 
  4. ① 先將初始檔案R[1..n]建成一個大根堆，此堆為初始的無序區 
  5. ② 再將關鍵字最大的記錄R[1](即堆頂)和無序區的最後一個記錄R[n]交換， 
  6. 由此得到新的無序區R[1..n-1]和有序區R[n]，且滿足R[1..n-1].keys≤R[n].key 
  7. ③ 由於交換後新的根R[1]可能違反堆性質，故應將當前無序區R[1..n-1]調整為堆。 
  8. 然後再次將R[1..n-1]中關鍵字最大的記錄R[1]和該區間的最後一個記錄R[n-1]交換， 
  9. 由此得到新的無序區R[1..n-2]和有序區R[n-1..n]，且仍滿足關係R[1..n- 2].keys≤R[n-1..n].keys， 
  10. 同樣要將R[1..n-2]調整為堆。 
  11. …… 
  12. 直到無序區只有一個元素為止。 
  13. (2)大根堆排序演算法的基本操作： 
  14. ① 初始化操作：將R[1..n]構造為初始堆； 
  15. ② 每一趟排序的基本操作：將當前無序區的堆頂記錄R[1]和該區間的最後一個記錄交換，然後將新的無序區調整為堆(亦稱重建堆)。 
  16. 注意： 
  17. ①只需做n-1趟排序，選出較大的n-1個關鍵字即可以使得檔案遞增有序。 
  18. ②用小根堆排序與利用大根堆類似，只不過其排序結果是遞減有序的。 
  19. 堆排序和直接選擇排序相反：在任何時刻，堆排序中無序區總是在有序區之前， 
  20. 且有序區是在原向量的尾部由後往前逐步擴大至整個向量為止。 
  21. */
  22. #include <iostream>
  23. usingnamespace std;  
  24. //生成大根堆
  25. void HeapAdjust(int SortData[],int StartIndex, int Length)  
  26. {  
  27.     while(2*StartIndex+1 < Length)  
  28.     {  
  29.         int MaxChildrenIndex = 2*StartIndex+1 ;  
  30.         if(2*StartIndex+2 < Length )  
  31.         {  
  32.             //比較左子樹和右子樹，記錄最大值的Index
  33.             if(SortData[2*StartIndex+1]<SortData[2*StartIndex+2])  
  34.             {  
  35.                 MaxChildrenIndex = 2*StartIndex+2;  
  36.             }  
  37.         }  
  38.         if(SortData[StartIndex] < SortData[MaxChildrenIndex])  
  39.         {  
  40.             //交換i與MinChildrenIndex的資料
  41.             int tmpData =SortData[StartIndex];  
  42.             SortData[StartIndex] =SortData[MaxChildrenIndex];  
  43.             SortData[MaxChildrenIndex] =tmpData;  
  44.             //堆被破壞，需要重新調整
  45.             StartIndex = MaxChildrenIndex ;  
  46.         }  
  47.         else
  48.         {  
  49.             //比較左右孩子均大則堆未破壞，不再需要調整
  50.             break;  
  51.         }  
  52.     }  
  53. }  
  54. //堆排序
  55. void HeapSortData(int SortData[], int Length)  
  56. {  
  57.     int i=0;  
  58.     //將Hr[0,Length-1]建成大根堆
  59.     for (i=Length/2-1; i>=0; i--)  
  60.     {  
  61.         HeapAdjust(SortData, i, Length);  
  62.     }  
  63.     for (i=Length-1; i>0; i--)  
  64.     {  
  65.         //與最後一個記錄交換
  66.         int tmpData =SortData[0];  
  67.         SortData[0] =SortData[i];  
  68.         SortData[i] =tmpData;  
  69.         //將H.r[0..i]重新調整為大根堆
  70.         HeapAdjust(SortData, 0, i);  
  71.     }  
  72. }  
  73. //TestCase
  74. int main()  
  75. {  
  76.     int SortData[] ={12,36,24,85,47,30,53,91};  
  77.     HeapSortData(SortData, 8);  
  78.     for (int i=0; i<8; i++)  
  79.     {  
  80.         cout<<SortData[i]<<" ";  
  81.     }  
  82.     cout<<endl;  
  83.     return 0;  
  84. }  
/*
堆排序
(1)用大根堆排序的基本思想
① 先將初始檔案R[1..n]建成一個大根堆，此堆為初始的無序區
② 再將關鍵字最大的記錄R[1](即堆頂)和無序區的最後一個記錄R[n]交換，
由此得到新的無序區R[1..n-1]和有序區R[n]，且滿足R[1..n-1].keys≤R[n].key
③ 由於交換後新的根R[1]可能違反堆性質，故應將當前無序區R[1..n-1]調整為堆。
然後再次將R[1..n-1]中關鍵字最大的記錄R[1]和該區間的最後一個記錄R[n-1]交換，
由此得到新的無序區R[1..n-2]和有序區R[n-1..n]，且仍滿足關係R[1..n- 2].keys≤R[n-1..n].keys，
同樣要將R[1..n-2]調整為堆。
……
直到無序區只有一個元素為止。
(2)大根堆排序演算法的基本操作：
① 初始化操作：將R[1..n]構造為初始堆；
② 每一趟排序的基本操作：將當前無序區的堆頂記錄R[1]和該區間的最後一個記錄交換，然後將新的無序區調整為堆(亦稱重建堆)。
注意：
①只需做n-1趟排序，選出較大的n-1個關鍵字即可以使得檔案遞增有序。
②用小根堆排序與利用大根堆類似，只不過其排序結果是遞減有序的。
堆排序和直接選擇排序相反：在任何時刻，堆排序中無序區總是在有序區之前，
且有序區是在原向量的尾部由後往前逐步擴大至整個向量為止。
*/

#include <iostream>

using namespace std;

//生成大根堆
void HeapAdjust(int SortData[],int StartIndex, int Length)
{
    while(2*StartIndex+1 < Length)
    {
        int MaxChildrenIndex = 2*StartIndex+1 ;
        if(2*StartIndex+2 < Length )
        {
            //比較左子樹和右子樹，記錄最大值的Index
            if(SortData[2*StartIndex+1]<SortData[2*StartIndex+2])
            {
                MaxChildrenIndex = 2*StartIndex+2;
            }
        }
        if(SortData[StartIndex] < SortData[MaxChildrenIndex])
        {
            //交換i與MinChildrenIndex的資料
            int tmpData =SortData[StartIndex];
            SortData[StartIndex] =SortData[MaxChildrenIndex];
            SortData[MaxChildrenIndex] =tmpData;
            //堆被破壞，需要重新調整
            StartIndex = MaxChildrenIndex ;
        }
        else
        {
            //比較左右孩子均大則堆未破壞，不再需要調整
            break;
        }
    }
}

//堆排序
void HeapSortData(int SortData[], int Length)
{
    int i=0;

    //將Hr[0,Length-1]建成大根堆
    for (i=Length/2-1; i>=0; i--)
    {
        HeapAdjust(SortData, i, Length);
    }

    for (i=Length-1; i>0; i--)
    {
        //與最後一個記錄交換
        int tmpData =SortData[0];
        SortData[0] =SortData[i];
        SortData[i] =tmpData;
        //將H.r[0..i]重新調整為大根堆
        HeapAdjust(SortData, 0, i);
    }
}

//TestCase
int main()
{
    int SortData[] ={12,36,24,85,47,30,53,91};

    HeapSortData(SortData, 8);

    for (int i=0; i<8; i++)
    {
        cout<<SortData[i]<<" ";
    }
    cout<<endl;

    return 0;
}



選擇排序
[cpp] view plain copy print?
  1. //每一趟在n-i+1(i=1,2,...,n-1)個記錄中選取關鍵字最小的記錄作為有序序列中第i個記錄
  2. #include <iostream>
  3. usingnamespace std;  
  4. void selectSort(int a[],int size)  
  5. {  
  6.     for(int i=0;i<size-1;i++)  
  7.     {  
  8.         int lowIndex =i;  
  9.         for(int j=size-1;j>i;j--)  
  10.             if(a[j]<a[lowIndex])  
  11.                 lowIndex=j;  
  12.         int temp=a[i];  
  13.         a[i]=a[lowIndex];  
  14.         a[lowIndex]=temp;  
  15.     }  
  16. }  
  17. int main()  
  18. {  
  19.     int a[]={12,36,24,85,47,30,53,91};  
  20.     for(int i=0;i<8;i++)  
  21.         cout<<a[i]<<" ";  
  22.     cout<<endl;  
  23.     selectSort(a,8);  
  24.     for(int i=0;i<8;i++)  
  25.         cout<<a[i]<<" ";  
  26.     cout<<endl;  
  27.     return 0;  
  28. }  
//每一趟在n-i+1(i=1,2,...,n-1)個記錄中選取關鍵字最小的記錄作為有序序列中第i個記錄
#include <iostream>
using namespace std;

void selectSort(int a[],int size)
{
    for(int i=0;i<size-1;i++)
    {
        int lowIndex =i;
        for(int j=size-1;j>i;j--)
            if(a[j]<a[lowIndex])
                lowIndex=j;
        int temp=a[i];
        a[i]=a[lowIndex];
        a[lowIndex]=temp;
    }
}

int main()
{
    int a[]={12,36,24,85,47,30,53,91};
    for(int i=0;i<8;i++)
        cout<<a[i]<<" ";
    cout<<endl;

    selectSort(a,8);
    for(int i=0;i<8;i++)
        cout<<a[i]<<" ";
    cout<<endl;

    return 0;
}


插入排序
[cpp] view plain copy print?
  1. //將一個記錄插入到已經排好序的有序表中，從而得到一個新的 、記錄數增1的有序表
  2. #include <iostream>
  3. usingnamespace std;  
  4. void insertSort(int a[],int size)  
  5. {  
  6.     for(int i=1;i<size;i++)  
  7.         for(int j=i;(j>0)&&(a[j]<a[j-1]);j--)  
  8.         {  
  9.             int temp=a[j];  
  10.             a[j]=a[j-1];  
  11.             a[j-1]=temp;  
  12.         }  
  13. }  
  14. int main()  
  15. {  
  16.     int a[]={12,36,24,85,47,30,53,91};  
  17.     for(int i=0;i<8;i++)  
  18.         cout<<a[i]<<" ";  
  19.     cout<<endl;  
  20.     insertSort(a,8);  
  21.     for(int i=0;i<8;i++)  
  22.         cout<<a[i]<<" ";  
  23.     cout<<endl;  
  24.     return 0;  
  25. }  
//將一個記錄插入到已經排好序的有序表中，從而得到一個新的 、記錄數增1的有序表
#include <iostream>
using namespace std;

void insertSort(int a[],int size)
{
    for(int i=1;i<size;i++)
        for(int j=i;(j>0)&&(a[j]<a[j-1]);j--)
        {
            int temp=a[j];
            a[j]=a[j-1];
            a[j-1]=temp;
        }
}

int main()
{
    int a[]={12,36,24,85,47,30,53,91};
    for(int i=0;i<8;i++)
        cout<<a[i]<<" ";
    cout<<endl;

    insertSort(a,8);
    for(int i=0;i<8;i++)
        cout<<a[i]<<" ";
    cout<<endl;

    return 0;
}



氣泡排序
[cpp] view plain copy print?
  1. //在氣泡排序的過程中，關鍵字較小的記錄好比水中的氣泡逐趟向上漂浮，而關鍵字較大的記錄好比石塊往下沉，每一趟有一塊“最大”的石頭沉到水底。
  2. #include <iostream>
  3. usingnamespace std;  
  4. void busort(int a[],int size)  
  5. {  
  6.     for(int i=0;i<size-1;i++)  
  7.         for(int j=size-1;j>i;j--)  
  8.         if(a[j]<a[j-1])  
  9.         {  
  10.             int temp=a[j];  
  11.             a[j]=a[j-1];  
  12.             a[j-1]=temp;  
  13.         }  
  14. }  
  15. int main()  
  16. {  
  17.     int a[]={12,36,24,85,47,30,53,91};  
  18.     for(int i=0;i<8;i++)  
  19.         cout<<a[i]<<" ";  
  20.     cout<<endl;  
  21.     busort(a,8);  
  22.     for(int i=0;i<8;i++)  
  23.         cout<<a[i]<<" ";  
  24.     cout<<endl;  
  25.     return 0;  
  26. }  
//在氣泡排序的過程中，關鍵字較小的記錄好比水中的氣泡逐趟向上漂浮，而關鍵字較大的記錄好比石塊往下沉，每一趟有一塊“最大”的石頭沉到水底。
#include <iostream>
using namespace std;

void busort(int a[],int size)
{
    for(int i=0;i<size-1;i++)
        for(int j=size-1;j>i;j--)
        if(a[j]<a[j-1])
        {
            int temp=a[j];
            a[j]=a[j-1];
            a[j-1]=temp;
        }
}

int main()
{
    int a[]={12,36,24,85,47,30,53,91};
    for(int i=0;i<8;i++)
        cout<<a[i]<<" ";
    cout<<endl;

    busort(a,8);
    for(int i=0;i<8;i++)
        cout<<a[i]<<" ";
    cout<<endl;

    return 0;
}



折半插入排序
[cpp] view plain copy print?
  1. #include <iostream>
  2. usingnamespace std;  
  3. void BInsertSort(int a[],int size)  
  4. {  
  5.     for(int i=1;i<size;i++)  
  6.     {  
  7.         int temp=a[i];               //暫存a[i]
  8.         int low=0;  
  9.         int high=i-1;  
  10.         while(low<=high)  
  11.         {  
  12.             int middle=(low+high)/2;  
  13.             if(temp<=a[middle])  
  14.                 high=middle-1;  
  15.             else
  16.                 low=middle+1;  
  17.         }  
  18.         for(int j=i-1;j>=high+1;--j)   //記錄後移
  19.             a[j+1]=a[j];  
  20.         a[high+1]=temp;                //插入，注意沒有補齊的地方要注意，不然是野指標指向莫名的值。
  21.     }  
  22. }  
  23. int main()  
  24. {  
  25.     int a[]={12,36,24,53,53,30,53,91};  
  26.     for(int i=0;i<8;i++)  
  27.         cout<<a[i]<<" ";  
  28.     cout<<endl;  
  29.     BInsertSort(a,8);  
  30.     for(int i=0;i<8;i++)  
  31.          cout<<a[i]<<" ";  
  32.     cout<<endl;  
  33.     return 0;  
  34. }  
#include <iostream>
using namespace std;

void BInsertSort(int a[],int size)
{
    for(int i=1;i<size;i++)
    {
        int temp=a[i];               //暫存a[i]
        int low=0;
        int high=i-1;
        while(low<=high)
        {
            int middle=(low+high)/2;
            if(temp<=a[middle])
                high=middle-1;
            else
                low=middle+1;
        }

        for(int j=i-1;j>=high+1;--j)   //記錄後移
            a[j+1]=a[j];
        a[high+1]=temp;                //插入，注意沒有補齊的地方要注意，不然是野指標指向莫名的值。
    }
}

int main()
{
    int a[]={12,36,24,53,53,30,53,91};
    for(int i=0;i<8;i++)
        cout<<a[i]<<" ";
    cout<<endl;

    BInsertSort(a,8);
    for(int i=0;i<8;i++)
         cout<<a[i]<<" ";
    cout<<endl;

    return 0;
}


相關推薦

C++ 經典演算法 面試絕殺

1.連結串列逆序 2.連結串列合併 3.一棵樹是否某條路徑結點之和等於給定值。並描述演算法複雜度 4.你熟悉的排序演算法並描述演算法複雜度。          快速排序          歸併排序          堆排序          選擇排序          插入排序         氣泡排序  

經典演算法面試題目-判斷s2是否是s1的旋轉字串（1.8）

題目 Assume you have a method isSubstring which checks if one word is a substring of another. Given two strings, s1 and s2, write co

回顧C#經典演算法氣泡排序

冒泡演算法的原理： 比較相鄰的兩個數字，如果第一個數字比第二個數字大，則交換它們位置 從開始第一對比較到結尾最後一對，最後一個數字就是最大數 除了最後一個數字，再次從開始第一對比較到最後一對，得出第二大的數字 重複上面操作，直到沒有任何一對數字需要比較 舉例說明：要排序陣列：int[

C++經典面試演算法題

#include <assert.h> #include <string.h> #include <stack> /////////////////////////////////////////////////////////////

C語言經典演算法（九）——遞迴實現二分查詢的兩種方法

後繼續整理演算法並寫出自己的理解和備註。 C++實現的：遞迴實現二分查詢演算法 1、 遞迴實現二分查詢 <1> 題目描述:針對資料，進行二分查詢(要求:資料的排列有序) <2> 方法一:概念法 <3> 方法二:遞迴法 原始碼: 一、 遞迴實現

C語言經典演算法（八）——遞迴實現斐波那契數列的兩種方法

後繼續整理演算法並寫出自己的理解和備註。 C++實現的：遞迴實現斐波那契數列 1、 遞迴實現斐波那契數列Fib(n) <1> 題目描述:輸入n值，求解第n項的斐波那契數列值 <2> 方法一:概念法 <3> 方法二:遞迴法 斐波那契數列值是值1

C語言經典演算法（七）——遞迴實現階乘演算法的兩種方法

今後繼續整理演算法並寫出自己的理解和備註。 C++實現的：遞迴實現階乘演算法N! 1、 遞迴實現n! <1> 題目描述:輸入n值，求解n的階乘 <2> 方法一:累乘法 <3> 方法二:遞迴法 原始碼: 一、 遞迴實現n! 1、 累乘法 #

C++_樹的經典演算法

目錄： 1.有序連結串列轉換成平衡二叉樹 2.二叉搜尋樹轉化成有序雙鏈表 3.判斷是否為平衡二叉樹 4.二叉樹的最近公共祖先 1.有序連結串列轉換成平衡二叉樹 #include <iostream> using namespace std; struct Li

C語言經典演算法練習一（氣泡排序）

本次練習總結： 1.  函式宣告在初次編碼時忘記，教訓一； 2.  不知道不知長度的陣列空間該如何操作，學會了動態分配，知道了malloc函式在<stdlib.h>標頭檔案中，收穫一； 3.  又忘記double型別在printf()和是scanf()中用%

面試經典演算法題集錦——《劍指 offer》小結

從今年 3 月份開始準備找實習，到現在校招結束，申請的工作均為機器學習／資料探勘演算法相關職位，也拿到了幾個 sp offer。經歷這半年的洗禮，自己的綜合能力和素質都得到了一個質的提升。 實話說對於未來去哪裡，即將如何發展還沒有清晰的規劃。迷茫總是會有的，但這並不是停止腳步的理由。找工作是在漫

C語言經典演算法 輸入某年某月某日 判斷這一天是這一年的第幾天

                題目：輸入某年某月某日，判斷這一天是這一年的第幾天？1.程式分析：以3月5日為例，應該先把前兩個月的加起來，然後再加上5天即本年的第幾天，特殊　　　　　　情況，閏年且輸入月份大於3時需考慮多加一天。2.程式原始碼：main(){int day,month,year,sum,le

C語言經典演算法題目——列印水仙花數

 “水仙花”數指的是一個3位數，它的每個位數字的三次冪之和等於它本身 舉一個例子： 153=1x1x1+5x5x5+3x3x3 我們先來看看執行的結果 下面是程式實現的程式碼 #include<stdio.h> int main() {

C#面試題：一群小孩圍成一個圈的經典演算法

一群小孩圍成一個圈，從第一個開始報數，報到5的小孩退出圈，繼續，求剩下的最後一個小孩的編號。 程式碼如下： public static int count = 0;//計數器         public static int target = 5;//指定編號   

【C/C++】回溯經典演算法之-->八皇后問題

一、八皇后問題 八皇后問題，是一個古老而著名的問題，是回溯演算法的典型案例。該問題是國際西洋棋棋手馬克斯·貝瑟爾於1848年提出：在8×8格的國際象棋上擺放八個皇后，使其不能互相攻擊，即任意兩個皇后都不能處於同一行、同一列或同一斜線上，問有多少種擺法。高斯認為有76種方案。

C語言計算日期間隔天數的經典演算法解析

C語言計算日期間隔天數的經典演算法解析 網上看到一個計算日期間隔的方法，很高深，很巧妙。程式碼如下： #include <stdio.h> #include <stdlib.h>   int day_diff(int year_start,

經典演算法之歸併排序的C實現方法

以前寫過歸併排序的演算法，但是時間過了好久，忘記怎麼寫的了，（也是醉了）。正好複習演算法的時候遇到這個問題，就重新寫了一下，把遇到的一些問題順便記錄一下。 核心就是用兩個子陣列記錄分割後的兩個陣列中的變數， 然後依次比較大小即可。 這裡有個細節需要注意一下，

C語言經典演算法：求1-100之間素數

#include<stdio.h> #include<stdlib.h> #include<assert.h> #include<math.h> in

C語言經典演算法：輸入某年某月某日，判斷這一天是這一年的第幾天？

題目：輸入某年某月某日，判斷這一天是這一年的第幾天？1.程式分析：以3月5日為例，應該先把前兩個月的加起來，然後再加上5天即本年的第幾天，特殊　　　　　　情況，閏年且輸入月份大於3時需考慮多加一天。2.程式原始碼：main(){int day,month,year,sum,l

經典演算法：紅黑樹的C語言實現 ( 插入 、刪除 )

紅黑樹這個東西可以說是傳說中的“牛刀”了，一般的小場合是用不上滴，但是我覺得還是很重要，所以花了將近三天，對照著演算法導論，把紅黑樹給實現出來了，有關紅黑樹的資料很多，大家可以在網上先搜一下，最好是能親自看看演算法導論，把其中的case之間的轉換弄清楚，弄清楚後看演算法就很簡

C語言經典演算法100例-030-判斷一個數是否為迴文數

所謂迴文數，即是正序與逆序相等的一個數，如121，12321,10501等。寫程式判斷輸入的數是否為迴文數。 1.分析：表面上看，我們似乎要這麼做，把各個位分離，然後把第一個數跟最後一個數比較，第二個跟倒數第二個....等等。注意，這樣做太複雜了，迴文數的條件是正序等於逆序