Violent cracking of 408 code problems -- Summary of mixed scores

408 code questions are generally 2-3 questions, (1) algorithm design idea (2) code implementation (3) time and space complexity

Generally 408 considering the normal distribution of scores, this problem will generally have optimal solutions, suboptimal solutions, and barely calculate the functions that can be realized by the code you write. The design idea and complexity calculation are consistent with your code implementation. These solutions for 15 point problems generally have a maximum of about 15, 11 and 9 points respectively.

Generally, suboptimal solutions are the basic knowledge of data structure and the functions required by the problem. It is mainly related to sorting, tree traversal and the application of linked list. The probability of sorting is the highest.

Structure definition

There may be a question about defining the structure used.

Binary tree definition

typedef struct BiTNode{
int data;
struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;

typedef struct LNode{
int data;
struct LNode *next;

Mainly remember the format of structure definition

Quick row*****

Be sure to remember that when you take the exam, you are likely to sort it directly, and then you are almost finished. Just throw a shuttle directly.

Note that the time complexity is O(nlog2n) and the space complexity is O(log2n)

log is based on 2 n. Space complexity, because recursive stack will be used, just remember.

void QuickSort(ElemType A[],int low,int high){
if(low<high){//Recursive jump out condition
int p=Partition(A,low,high);//Divided into two sub tables
QuickSort(A,low,p-1);//Recursively sort the two sub tables in turn
QuickSort(A,p+1,high);
}
}
int Partition(ElemType A[],int low,int high){//One trip Division
ElemType p=A[low];//Set the first element in the current table as the pivot to divide the table
while (low<high){//Loop jump condition
while(low<high&&A[high]>=p) --high;
A[low]=A[high];//Move elements smaller than the pivot to the left
while(low<high&&A[low]<=p) ++low;
A[high]=A[low];//Move elements larger than the pivot to the left
}
A[low]=p;//Store pivot element in final position
return low;//Returns the final location where the pivot element is stored
}

When you write a sort function library, copy it down and use it directly.
It's good to understand the principle of fast platoon.

General topic arrays are of type int. you can directly change ElemType to int.

Tree traversal

The first, middle and last order traversals of the tree are almost the same. If you remember one, you'll remember it all. Level traversal is OK, because if you need to use level traversal, you can generally use preorder traversal instead.

• proorder traversal
void PreOrder(BiTree T){
if (T!=NULL){
visit(T);//Access root node
PreOrder(T.lchild); //Recursive traversal of left subtree
PreOrder(T.rchild); //Recursive traversal of right subtree
}
}

Used in the title

int xxx=0//(to accumulate recursive results, consider defining global variables)
void main(BiTree root){
PreOrder(root,0);
}
void PreOrder(BiTree t,int deep){
if(t.lchild==NULL and t.rchild==NULL){ //Judge whether it is a leaf node

}
if(t.lchild !=NULL){//If the left subtree is not empty, recursively traverse the left subtree
PreOrder(t.lchild，deep+1);
}
if(t.rchild !=NULL){//If the right subtree is not empty, recursively traverse the right subtree
PreOrder(t.rchild,deep+1);
}
}
• Middle order traversal of tree
void InOrder(BiTree T){
if (T!=NULL){
InOrder(T.lchild); //Recursive traversal of left subtree
visit(T);//Access root node
InOrder(T.rchild); //Recursive traversal of right subtree
}
}

Used in the title

int xxx=0//(to accumulate recursive results, consider defining global variables)
void main(BiTree root){
InOrder(root,0);
}
void InOrder(BiTree t,int deep){
if(t.lchild !=NULL){//If the left subtree is not empty, recursively traverse the left subtree
InOrder(t.lchild，deep+1);
}
if(t.lchild==NULL and t.rchild==NULL){ //Judge whether it is a leaf node

}
if(t.rchild !=NULL){//If the right subtree is not empty, recursively traverse the right subtree
InOrder(t.rchild,deep+1);
}
}
• Postorder traversal of tree
void PostOrder(BiTree T){
if (T!=NULL){
PostOrder(T.lchild); //Recursive traversal of left subtree
PostOrder(T.rchild); //Recursive traversal of right subtree
visit(T);//Access root node
}
}

Used in the title

int xxx=0//(to accumulate recursive results, consider defining global variables)
void main(BiTree root){
PostOrder(root,0);
}
void PostOrder(BiTree t,int deep){
if(t.lchild !=NULL){//If the left subtree is not empty, recursively traverse the left subtree
PostOrder(t.lchild，deep+1);
}
if(t.rchild !=NULL){//If the right subtree is not empty, recursively traverse the right subtree
PostOrder(t.rchild,deep+1);
}
if(t.lchild==NULL and t.rchild==NULL){ //Judge whether it is a leaf node

}
}
• The hierarchical traversal of the tree (including the declaration and use of the queue) is not recommended. It is generally not used. It is too troublesome

You can understand the use of the lower queue and the implementation of the hierarchical traversal code.

#define MaxSize 100 / / sets the maximum queue size
void fuc(BiTree root){
BiTree q[maxsize]; //Declare the queue. end1 is the head pointer and end2 is the tail pointer
int end1=0,end2=0;
int deep=0; //Initialization depth
BiTree lastNode; //lastNode records the last node of the current layer
BiTree newlastNode; //newlastNode records the last node of the next layer
lastNode=root;//The lastNode is initialized as the root node
newlastNode=NULL;//newlastNode initialization is null
q[end2++]=root;//Root node join
while(end1!=end2){//Level traversal. If it is not empty, it will loop
BiTree t=q[end1++]; //Take out the team head element
if(t.lchild==NULL and t.rchild==NULL){ //Judge whether it is a leaf node

}
if(t.lchild !=NULL){//If the left child exists, the left child is added to the queue
q[end2++]=t.lchild;
newlastNode=t.lchild;
}
if(t.rchild !=NULL){//If the right child exists, the right child will be added to the queue
q[end2++]=t.rchild;
newlastNode=t.rchild;
}
if(t==lastNode){//If this node is the last node of this layer
lastNode=newlastNode;
deep+=1//Number of layers plus one
}
}
}

Disconnect the head node in the original linked list from the first element node (make its pointer field empty), first form a new empty list, and then insert each node in the original linked list into the head of the new table from the first node (that is, make each inserted node become the new first element node)

void reverList(LNode *L){
LNode *temp=L.next;//Record the first node except the header node
LNode *q;//Used to record subsequent nodes
while(temp!=NULL){
q=temp.next;//The q node records the subsequent nodes of temp
temp.next=L.next;//Insert subsequent nodes into the new table header at one time
L.next=temp;
temp=q;
}
}

Joint search set

Take judging whether a graph has a ring as an example. Because the vertex elements of the graph are letters, we use an int array to represent and query the set (the order of letters corresponds to the subscript itself). Otherwise, we need to define the structure according to the question. I think this kind of question generally won't be tested. We should learn and query the set.

int hasCyclic(int g){//g is the adjacency matrix represented by two-dimensional array
int S;//Define, initialize, and query sets
for(int i=0;i<5;i++) s[i]=-1;
for(int i=0;i<5;i++)
for(int j=i+1;j<5;j++)
if(g[i][j]>0){//There are edges between nodes i and j
int iroot=Find(S,i);//Find the set i belongs to by merging and searching the set
int jroot=Find(S,j);//Find the set j belongs to by merging and searching the set
if(iroot!=jroot)//i. j is not in the same set
Union(S,iroot,jroot)
else //i. j is originally in the same set, that is, Unicom
return 1;
}
return 0;//There is no ring in the figure
}

Binary search

int binary_search(int A[],int key,int n){
int low=0,high=n-1,mid;
while(low<high){
mid=(low+high)/2;//Take the middle position
if(A[mid]==key)
return mid; //If the search is successful, the location will be returned
else if(A[mid]>key)
high=mid-1;//Keep looking from the front half
else
low=mid+1;//Keep looking from the second half
}
return -1;//Search failed, return - 1
}

Tags: Algorithm

Posted on Tue, 16 Nov 2021 09:03:12 -0500 by skali