数据结构面试汇总

stack

堆栈的全部功能，——也就是说实现了一个先进后出（FILO）的数据结构

操作 比较和分配堆栈

栈的应用——括号匹配问题

empty() 堆栈为空则返回真

pop() 移除栈顶元素

push() 在栈顶增加元素

size() 返回栈中元素数目

top() 返回栈顶元素

#include <iostream> 

#include <stack> 

using namespace std; 

  

int main () 

{ 

  stack<int> mystack; 

  

  for (int i=0; i<5; ++i) mystack.push(i); 

  

  cout << "Popping out elements..."; 

  while (!mystack.empty()) 

  { 

     cout << " " << mystack.top(); 

     mystack.pop(); 

  } 

  cout << endl; 

  

  return 0; 

}

Queue

队列(Queue)是一个数据集合，仅允许在列表的一端进行插入，另一端进行删除。

　　进行插入的一端称为队尾(rear)，插入动作称为进队或入队

　　进行删除的一端称为队头(front)，删除动作称为出队

队列的性质：先进先出(First-in, First-out)

双向队列：队列的两端都允许进行进队和出队操作

queue 的基本操作有：
入队，如例：q.push(x); 将x 接到队列的末端。
出队，如例：q.pop(); 弹出队列的第一个元素，注意，并不会返回被弹出元素的值。
访问队首元素，如例：q.front()，即最早被压入队列的元素。
访问队尾元素，如例：q.back()，即最后被压入队列的元素。
判断队列空，如例：q.empty()，当队列空时，返回true。
访问队列中的元素个数，如例：q.size()

#include <cstdlib>

#include <iostream>

#include <queue>

using namespace std;

int main()

{

    int e,n,m;

    queue<int> q1;

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

       q1.push(i);

    if(!q1.empty())

    cout<<"dui lie  bu kong ";

    n=q1.size();

    cout<<n<<endl;

    m=q1.back();

    cout<<m<<endl;

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

    {

       e=q1.front();

       cout<<e<<" ";

       q1.pop();

    }

    cout<<endl;

    if(q1.empty())

    cout<<"dui lie  bu kong ";

    system("PAUSE");

    return 0;

}

List

Lists将元素按顺序储存在链表中. 与 向量(vectors)相比, 它允许快速的插入和删除，但是随机访问却比较慢

assign() 给list赋值 
back() 返回最后一个元素 
begin() 返回指向第一个元素的迭代器 
clear() 删除所有元素 
empty() 如果list是空的则返回true 
end() 返回末尾的迭代器 
erase() 删除一个元素 
front() 返回第一个元素 
get_allocator() 返回list的配置器 
insert() 插入一个元素到list中 
max_size() 返回list能容纳的最大元素数量 
merge() 合并两个list 
pop_back() 删除最后一个元素 
pop_front() 删除第一个元素 
push_back() 在list的末尾添加一个元素 
push_front() 在list的头部添加一个元素 
rbegin() 返回指向第一个元素的逆向迭代器 
remove() 从list删除元素 
remove_if() 按指定条件删除元素 
rend() 指向list末尾的逆向迭代器 
resize() 改变list的大小 
reverse() 把list的元素倒转 
size() 返回list中的元素个数 
sort() 给list排序 
splice() 合并两个list 
swap() 交换两个list 
unique() 删除list中重复的元素

 

实例：

[cpp] view plaincopy

1. #include <iostream>   
2. #include <list>   
3. #include <numeric>   
4. #include <algorithm>   
5. using namespace std;   
6.   
7. //创建一个list容器的实例LISTINT   
8. typedef list<int> LISTINT;   
9. //创建一个list容器的实例LISTCHAR   
10. typedef list<int> LISTCHAR;   
11.   
12. void main()   
13. {   
14.     //用list容器处理整型数据    
15.     //用LISTINT创建一个名为listOne的list对象   
16.     LISTINT listOne;   
17.     //声明i为迭代器   
18.     LISTINT::iterator i;   
19.       
20.     //从前面向listOne容器中添加数据   
21.     listOne.push_front (2);   
22.     listOne.push_front (1);   
23.       
24.     //从后面向listOne容器中添加数据   
25.     listOne.push_back (3);   
26.     listOne.push_back (4);   
27.       
28.     //从前向后显示listOne中的数据   
29.     cout<<"listOne.begin()--- listOne.end():"<<endl;   
30.     for (i = listOne.begin(); i != listOne.end(); ++i)   
31.         cout << *i << " ";   
32.     cout << endl;   
33.       
34.     //从后向后显示listOne中的数据   
35.     LISTINT::reverse_iterator ir;   
36.     cout<<"listOne.rbegin()---listOne.rend():"<<endl;   
37.     for (ir =listOne.rbegin(); ir!=listOne.rend();ir++) {   
38.         cout << *ir << " ";   
39.     }   
40.     cout << endl;   
41.       
42.     //使用STL的accumulate(累加)算法   
43.     int result = accumulate(listOne.begin(), listOne.end(),0);   
44.     cout<<"Sum="<<result<<endl;   
45.     cout<<"------------------"<<endl;   
46.       
47.     //--------------------------   
48.     //用list容器处理字符型数据   
49.     //--------------------------   
50.       
51.     //用LISTCHAR创建一个名为listOne的list对象   
52.     LISTCHAR listTwo;   
53.     //声明i为迭代器   
54.     LISTCHAR::iterator j;   
55.       
56.     //从前面向listTwo容器中添加数据   
57.     listTwo.push_front ('A');   
58.     listTwo.push_front ('B');   
59.       
60.     //从后面向listTwo容器中添加数据   
61.     listTwo.push_back ('x');   
62.     listTwo.push_back ('y');   
63.       
64.     //从前向后显示listTwo中的数据   
65.     cout<<"listTwo.begin()---listTwo.end():"<<endl;   
66.     for (j = listTwo.begin(); j != listTwo.end(); ++j)   
67.         cout << char(*j) << " ";   
68.     cout << endl;   
69.       
70.     //使用STL的max_element算法求listTwo中的最大元素并显示   
71.     j=max_element(listTwo.begin(),listTwo.end());   
72.     cout << "The maximum element in listTwo is: "<<char(*j)<<endl;   
73. }   

单链表的基本操作

https://www.cnblogs.com/leaver/p/6718421.html

排序

 

 

冒泡

function bubbleSort(arr) {

    var len = arr.length;

    for (var i = 0; i < len - 1; i++) {

        for (var j = 0; j < len - 1 - i; j++) {

            if (arr[j] > arr[j+1]) {       // 相邻元素两两对比

                var temp = arr[j+1];       // 元素交换

                arr[j+1] = arr[j];

                arr[j] = temp;

            }

        }

    }

    return arr;

}

快排

void Qsort(int a[], int low, int high)

{

    if(low >= high)

    {

        return;

    }

    int first = low;

    int last = high;

    int key = a[first];/*用字表的第一个记录作为枢轴*/

    while(first < last)

    {

        while(first < last && a[last] >= key)

        {

            --last;

        }

        a[first] = a[last];/*将比第一个小的移到低端*/

        while(first < last && a[first] <= key)

        {

            ++first;

        }

         

        a[last] = a[first];    

/*将比第一个大的移到高端*/

    }

    a[first] = key;/*枢轴记录到位*/

    Qsort(a, low, first-1);

    Qsort(a, first+1, high);

}

冒泡

它重复地走访过要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。

选择

首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾

插入

构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。

希尔

优先比较距离较远的元素

归并

将已有序的子序列合并，得到完全有序的序列

快排

通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小

堆

堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。