Java面试题--数据结构

今天药忘吃喽~ 2021-09-28 10:10 303阅读 0赞

**排序算法对比**

**算法         时间复杂度(平均)   最好     最坏    稳定性**

冒泡排序         o(n^2)                           n             o(n^2)      稳定

插入排序         o(n^2)                           n             o(n^2)      稳定

选择排序         o(n^2)                          o(n^2)     o(n^2)      不稳定

**数组和链表的区别**

从逻辑结构上来看，数组必须实现定于固定的长度，不能适应数据动态增减的情况，即数组的大小一旦定义就不能改变。当数据增加是，可能超过原先定义的元素的个数；当数据减少时，造成内存浪费；链表动态进行存储分配，可以适应数据动态地增减的情况，且可以方便地插入、删除数据项。

从内存存储的角度看；数组从栈中分配空间（用new则在堆上创建），对程序员方便快速，但是自由度小；链表从堆中分配空间，自由度大但是申请管理比较麻烦。

从访问方式类看，数组在内存中是连续的存储，因此可以利用下标索引进行访问；链表是链式存储结构，在访问元素时候只能够通过线性方式由前到后顺序的访问，所以访问效率比数组要低。

**简述快速排序过程**

1）选择一个基准元素,通常选择第一个元素或者最后一个元素,

2）通过一趟排序将待排序的记录分割成独立的两部分，其中一部分记录的元素值均比基准元素值小。另一部分记录的元素值比基准值大。

3）此时基准元素在其排好序后的正确位置

4）然后分别对这两部分记录用同样的方法继续进行排序，直到整个序列有序。

**快速排序的改进**

只对长度大于k的子序列递归调用快速排序,让原序列基本有序，然后再对整个基本有序序列用插入排序算法排序。实践证明，改进后的算法时间复杂度有所降低，且当k取值为 8 左右时,改进算法的性能最佳。

选择基准元的方式

对于分治算法，当每次划分时，算法若都能分成两个等长的子序列时，那么分治算法效率会达到最大。也就是说，基准的选择是很重要的。选择基准的方式决定了两个分割后两个子序列的长度，进而对整个算法的效率产生决定性影响。最理想的方法是，选择的基准恰好能把待排序序列分成两个等长的子序列。

方法1 固定基准元

如果输入序列是随机的，处理时间是可以接受的。如果数组已经有序时，此时的分割就是一个非常不好的分割。

方法2 随机基准元

这是一种相对安全的策略。由于基准元的位置是随机的，那么产生的分割也不会总是会出现劣质的分割。在整个数组数字全相等时，仍然是最坏情况，时间复杂度是O(n^2）。实际上，随机化快速排序得到理论最坏情况的可能性仅为1/(2^n）。所以随机化快速排序可以对于绝大多数输入数据达到O(nlogn）的期望时间复杂度。

方法3 三数取中

引入的原因：虽然随机选取基准时，减少出现不好分割的几率，但是还是最坏情况下还是O(n^2），要缓解这种情况，就引入了三数取中选取基准。

分析：最佳的划分是将待排序的序列分成等长的子序列，最佳的状态我们可以使用序列的中间的值，也就是第N/2个数。可是，这很难算出来，并且会明显减慢快速排序的速度。这样的中值的估计可以通过随机选取三个元素并用它们的中值作为基准元而得到。事实上，随机性并没有多大的帮助，因此一般的做法是使用左端、右端和中心位置上的三个元素的中值作为基准元。

**各类排序算法对比**

时间复杂度来说：

(1)平方阶(O(n2))排序

各类简单排序:直接插入、直接选择和冒泡排序；

(2)线性对数阶(O(nlog2n))排序

快速排序、堆排序和归并排序；

(3)O(n1+§))排序,§是介于0和1之间的常数。

希尔排序

(4)线性阶(O(n))排序

基数排序，此外还有桶、箱排序。

说明：

当原表有序或基本有序时，直接插入排序和冒泡排序将大大减少比较次数和移动记录的次数，时间复杂度可降至O（n）；

而快速排序则相反，当原表基本有序时，将蜕化为冒泡排序，时间复杂度提高为O（n2）；

原表是否有序，对简单选择排序、堆排序、归并排序和基数排序的时间复杂度影响不大。

稳定性：

排序算法的稳定性:若待排序的序列中，存在多个具有相同关键字的记录，经过排序，这些记录的相对次序保持不变，则称该算法是稳定的；若经排序后，记录的相对次序发生了改变，则称该算法是不稳定的。

稳定的排序算法：冒泡排序、插入排序、归并排序和基数排序

不是稳定的排序算法：选择排序、快速排序、希尔排序、堆排序

选择排序算法准则：

一般而言，需要考虑的因素有以下四点：

设待排序元素的个数为n.

1）当n较大，则应采用时间复杂度为O(nlog2n)的排序方法：快速排序、堆排序或归并排序序。

2）当n较大，内存空间允许，且要求稳定性：归并排序

3）当n较小，可采用直接插入或直接选择排序。

直接插入排序：当元素分布有序，直接插入排序将大大减少比较次数和移动记录的次数。

直接选择排序 ：元素分布有序，如果不要求稳定性，选择直接选择排序

5）一般不使用或不直接使用传统的冒泡排序。

6）基数排序

它是一种稳定的排序算法，但有一定的局限性：

1、关键字可分解。

2、记录的关键字位数较少，如果密集更好

3、如果是数字时，最好是无符号的

**冒泡排序算法的改进**

1．设置一标志性变量pos,用于记录每趟排序中最后一次进行交换的位置。由于pos位置之后的记录均已交换到位,故在进行下一趟排序时只要扫描到pos位置即可。

2．传统冒泡排序中每一趟排序操作只能找到一个最大值或最小值,我们考虑利用在每趟排序中进行正向和反向两遍冒泡的方法一次可以得到两个最终值(最大者和最小者) , 从而使排序趟数几乎减少了一半。

邻接矩阵与邻接表

邻接矩阵表示法：在一个一维数组中存储所有的点，在一个二维数组中存储顶点之间的边的权值

邻接表表示法：图中顶点用一个一维数组存储，图中每个顶点vi的所有邻接点构成单链表

对比

1）在邻接矩阵表示中，无向图的邻接矩阵是对称的。矩阵中第 i 行或 第 i 列有效元素个数之和就是顶点的度。

在有向图中 第 i 行有效元素个数之和是顶点的出度，第 i 列有效元素个数之和是顶点的入度。

2）在邻接表的表示中，无向图的同一条边在邻接表中存储的两次。如果想要知道顶点的度，只需要求出所对应链表的结点个数即可。

有向图中每条边在邻接表中只出现一次，求顶点的出度只需要遍历所对应链表即可。求入度则需要遍历其他顶点的链表。

3）邻接矩阵与邻接表优缺点：

邻接矩阵的优点是可以快速判断两个顶点之间是否存在边，可以快速添加边或者删除边。而其缺点是如果顶点之间的边比较少，会比较浪费空间。因为是一个 n∗n 的矩阵。

而邻接表的优点是节省空间，只存储实际存在的边。其缺点是关注顶点的度时，就可能需要遍历一个链表。

**用循环比递归效率高吗？**

递归和循环两者完全可以互换。不能完全决定性地说循环地效率比递归的效率高。

2.1递归算法：

优点：代码简洁、清晰，并且容易验证正确性。

缺点：它的运行需要较多次数的函数调用，如果调用层数比较深，需要增加额外的堆栈处理（还有可能出现堆栈溢出的情况），比如参数传递需要压栈等操作，会对执行效率有一定影响。但是，对于某些问题，如果不使用递归，那将是极端难看的代码。在编译器优化后，对于多次调用的函数处理会有非常好的效率优化，效率未必低于循环。

2.2循环算法：

优点：速度快，结构简单。

缺点：并不能解决所有的问题。有的问题适合使用递归而不是循环。如果使用循环并不困难的话，最好使用循环。

**解决哈希冲突的方法**

哈希表（Hash table，也叫散列表），是根据关键码值(Key value)而直接进行访问的数据结构。

1） 线性探测法

2） 平方探测法

3） 伪随机序列法

4） 拉链法

9、KMP算法：在一个字符串中查找是否包含目标的匹配字符串。其主要思想是每趟比较过程让子串先后滑动一个合适的位置。当发生不匹配的情况时，不是右移一位，而是移动（当前匹配的长度– 当前匹配子串的部分匹配值）位。

**B树**

根据B类树的特点，构造一个多阶的B类树，然后在尽量多的在结点上存储相关的信息，保证层数尽量的少，以便后面我们可以更快的找到信息，磁盘的I/O操作也少一些，而且B类树是平衡树，每个结点到叶子结点的高度都是相同，这也保证了每个查询是稳定的。

B树和B+树的区别，以一个m阶树为例。

关键字的数量不同；B+树中分支结点有m个关键字，其叶子结点也有m个，其关键字只是起到了一个索引的作用，但是B树虽然也有m个子结点，但是其只拥有m-1个关键字。

存储的位置不同；B+树中的数据都存储在叶子结点上，也就是其所有叶子结点的数据组合起来就是完整的数据，但是B树的数据存储在每一个结点中，并不仅仅存储在叶子结点上。

分支结点的构造不同；B+树的分支结点仅仅存储着关键字信息和儿子的指针（这里的指针指的是磁盘块的偏移量），也就是说内部结点仅仅包含着索引信息。

查询不同；B树在找到具体的数值以后，则结束，而B+树则需要通过索引找到叶子结点中的数据才结束，也就是说B+树的搜索过程中走了一条从根结点到叶子结点的路径。

冒泡排序

for(int i=0;i<arr.length-1;i++){//外层循环控制排序趟数
    
    　　　　　　for(int j=0;j<arr.length-1-i;j++){//内层循环控制每一趟排序多少次
    
    　　　　　　　　if(arr[j]>arr[j+1]){
    
    　　　　　　　　　　int temp=arr[j];
    
    　　　　　　　　　　arr[j]=arr[j+1];
    
    　　　　　　　　　　arr[j+1]=temp;
    
    　　　　　　　　}
    
    　　　　　　}
    
    　　　　}

快速排序

public void sort(int[] a,int low,int high){
    
             int start = low;
    
             int end = high;
    
             int key = a[low];
    
             
    
             
    
             while(end>start){
    
                 //从后往前比较
    
                 while(end>start&&a[end]>=key)  //如果没有比关键值小的，比较下一个，直到有比关键值小的交换位置，然后又从前往后比较
    
                     end--;
    
                 if(a[end]<=key){
    
                     int temp = a[end];
    
                     a[end] = a[start];
    
                     a[start] = temp;
    
                 }
    
                 //从前往后比较
    
                 while(end>start&&a[start]<=key)//如果没有比关键值大的，比较下一个，直到有比关键值大的交换位置
    
                    start++;
    
                 if(a[start]>=key){
    
                     int temp = a[start];
    
                     a[start] = a[end];
    
                     a[end] = temp;
    
                 }
    
             //此时第一次循环比较结束，关键值的位置已经确定了。左边的值都比关键值小，右边的值都比关键值大，但是两边的顺序还有可能是不一样的，进行下面的递归调用
    
             }
    
             //递归
    
             if(start>low) sort(a,low,start-1);//左边序列。第一个索引位置到关键值索引-1
    
             if(end<high) sort(a,end+1,high);//右边序列。从关键值索引+1到最后一个
    
         }

选择排序

public void selectSort(int[]a){
    
            int len=a.length;
    
            for(int i=0;i<len;i++){//循环次数
    
                int value=a[i];
    
                int position=i;
    
                for(int j=i+1;j<len;j++){//找到最小的值和位置
    
                    if(a[j]<value){
    
                        value=a[j];
    
                        position=j;
    
                    }
    
                }
    
                a[position]=a[i];//进行交换
    
                a[i]=value;
    
            }
    
        }

创建一棵树

public class Node {  
    
        private int data;  
    
        private Node leftNode;  
    
        private Node rightNode;  
    
        public Node(int data, Node leftNode, Node rightNode){  
    
            this.data = data;  
    
            this.leftNode = leftNode;  
    
            this.rightNode = rightNode;  
    
        }  
    
      
    
        public int getData() {  
    
            return data;  
    
        }  
    
        public void setData(int data) {  
    
            this.data = data;  
    
        }  
    
        public Node getLeftNode() {  
    
            return leftNode;  
    
        }  
    
        public void setLeftNode(Node leftNode) {  
    
            this.leftNode = leftNode;  
    
        }  
    
        public Node getRightNode() {  
    
            return rightNode;  
    
        }  
    
        public void setRightNode(Node rightNode) {  
    
            this.rightNode = rightNode;  
    
        }  
    
    }

遍历二叉树

public class BinaryTree {  
    
        /**
    
         * @author yaobo
    
         * 二叉树的先序中序后序排序
    
         */  
    
        public Node init() {//注意必须逆序建立，先建立子节点，再逆序往上建立，因为非叶子结点会使用到下面的节点，而初始化是按顺序初始化的，不逆序建立会报错  
    
            Node J = new Node(8, null, null);  
    
            Node H = new Node(4, null, null);  
    
            Node G = new Node(2, null, null);  
    
            Node F = new Node(7, null, J);  
    
            Node E = new Node(5, H, null);  
    
            Node D = new Node(1, null, G);  
    
            Node C = new Node(9, F, null);  
    
            Node B = new Node(3, D, E);  
    
            Node A = new Node(6, B, C);  
    
            return A;   //返回根节点  
    
        }
    
        
    
        public void printNode(Node node){  
    
            System.out.print(node.getData());  
    
        }  
    
        public void theFirstTraversal(Node root) {  //先序遍历  
    
            printNode(root);  
    
            if (root.getLeftNode() != null) {  //使用递归进行遍历左孩子  
    
                theFirstTraversal(root.getLeftNode());  
    
            }  
    
            if (root.getRightNode() != null) {  //递归遍历右孩子  
    
                theFirstTraversal(root.getRightNode());  
    
            }  
    
        }  
    
        public void theInOrderTraversal(Node root) {  //中序遍历  
    
            if (root.getLeftNode() != null) {  
    
                theInOrderTraversal(root.getLeftNode());  
    
            }  
    
            printNode(root);  
    
            if (root.getRightNode() != null) {  
    
                theInOrderTraversal(root.getRightNode());  
    
            }  
    
        }
    
        
    
        
    
        public void thePostOrderTraversal(Node root) {  //后序遍历  
    
            if (root.getLeftNode() != null) {  
    
                thePostOrderTraversal(root.getLeftNode());  
    
            }  
    
            if(root.getRightNode() != null) {  
    
                thePostOrderTraversal(root.getRightNode());  
    
            }  
    
            printNode(root);  
    
        }  
    
          
    
        public static void main(String[] args) {  
    
            BinaryTree tree = new BinaryTree();  
    
            Node root = tree.init();  
    
            System.out.println("先序遍历");  
    
            tree.theFirstTraversal(root);  
    
            System.out.println("");  
    
            System.out.println("中序遍历");  
    
            tree.theInOrderTraversal(root);  
    
            System.out.println("");  
    
            System.out.println("后序遍历");  
    
            tree.thePostOrderTraversal(root);  
    
            System.out.println("");  
    
        }  
    
    }

对链表的操作

**
    
    * Created by Administrator on 2017-10-27.
    
    */
    
    public class linkedListFuns {
    
    
    
        public static void main(String[] arg) {
    
            Node head = new Node(1);
    
            for(int i=2;i<10;i++){
    
                insertFromTail(head,new Node(i));
    
            }
    
            printList(head);
    
            deleteFromIndex(head,3);
    
            printList(head);
    
    
    
        }
    
        
    
        static class Node {
    
            int data;
    
            Node next;
    
    
    
            public  Node(int d) {
    
                data = d;
    
                next = null;
    
            }
    
        }
    
    
    
        //从头节点插入，比较简单不用遍历链表
    
        public static void insetFromHead(Node head,Node newNode){
    
            newNode.next=head;
    
            head = newNode;
    
        }
    
    
    
        //在尾部插入，要遍历链表
    
        public static void insertFromTail(Node head1, Node newNode){
    
            if(head1 == null){ //如果是个空链表，直接把新节点赋值给head，然后结束，要先判断null的情况    其实这是一段错误代码，大家可以查看我另外一篇文章，Java参数引用传递之例外：null
    
                head1 =newNode;
    
                return;
    
            }
    
            Node temp = head1; //用temp代替head去遍历找到最后一个节点，一定不要用head自己去遍历，不然就找不到链表头了
    
            while (temp.next!=null){
    
                temp=temp.next;
    
            }
    
            temp.next=newNode;
    
        }
    
    
    
        //计算链表的长度
    
        public  static int length(Node head){
    
            int len =0;
    
            Node temp = head;
    
            while(temp!=null){
    
                len++;
    
                temp=temp.next;
    
            }
    
            return len;
    
        }
    
    
    
        //从特定位置删除一个节点
    
        public static boolean deleteFromIndex(Node head,int index){
    
            if(index<1||index>length(head)){ //先判断是否越界
    
                return false;
    
            }
    
            if(index ==1){//如果是删除第一个元素，因为直接涉及到了head所以只能单独处理
    
                head = head.next;
    
                return true;
    
            }
    
            Node curNode = head;
    
            for(int curIndex =1;curIndex<index-1;curIndex++){ //删除顺序为index的node只能将curNode停在index-1的位置
    
                curNode = curNode.next;
    
            }
    
            curNode.next=curNode.next.next;
    
            return true;
    
        }
    
    
    
        //按照顺序输出一个列表
    
        public static void printList(Node head){
    
            Node temp = head;
    
            while(temp != null){
    
                System.out.print(temp.data+" ");
    
                temp = temp.next;
    
            }
    
            System.out.println();
    
        }
    
        //对链表进行冒泡排序
    
        public static void orderList(Node head){
    
    
    
        }
    
    
    
    }

二分查找法

// 二分查找普通循环实现   
    
            public static int binSearch(int srcArray[], int key) {   
    
                int mid = srcArray.length / 2;   
    
                if (key == srcArray[mid]) {   
    
                    return mid;   
    
                }   
    
    
                int start = 0;   
    
                int end = srcArray.length - 1;   
    
                while (start <= end) {   
    
                    mid = (end - start) / 2 + start;   
    
                    if (key < srcArray[mid]) {   
    
                       end = mid - 1;   
    
                    } else if (key > srcArray[mid]) {   
    
                        start = mid + 1;   
    
                    } else {   
    
                        return mid;   
    
                    }   
    
                }   
    
                return -1;   
    
            }
    
        }

斐波那契数列（Fibonacci sequence）的定义：斐波那契数列指的是这样一个数列 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233，377，610，987，1597，2584，4181，6765，10946，17711，28657，46368........，这个数列从第3项开始，每一项都等于前两项之和。

public class PrintFib {
    
        public static void main(String[] args) {
    
            
    
            //定义第一个加数a，初始值为1；定义第二个加数b，初始值为1；定义两个加数之和为c，初始值为0
    
            int a = 1;
    
            int b = 1;
    
            int c = 0;
    
            //首先在控制台打印出数列中第一个数和第二个数的值
    
            System.out.print(a + "\t" + b + "\t");
    
            //建立一个for循环，用于循环输出数列中第三位至第十位的数字
    
            for (int i = 3; i <= 10; i++) {
    
                //第三个数即为c，a+b等于c的值
    
                c = a + b;
    
                //将第一个加数a赋值为数列中的第二个数b的值
    
                a = b;
    
                //将第二个加数b赋值为数列中的第三个数c的值
    
                b = c;
    
                //在第二次循环打印时，将打印数列中的第四个数为：b + c = b + (a + b)
    
                System.out.print(c + "\t");
    
            }
    
        }
    
    }