数据结构考前复习

Posted 2022-06-30 钟钟终

链表

插入

int Ins_(int i,int x)

    Node *p=NULL;
    int cnt=0;
    while(cnt<i-1&&p!=NULL)
    
        p=p->nxt;cnt++;
    
    if(p==NULL)
        return -1;
    else
    
        Node *s=new Node;
        s->data=x;
        s->nxt=p->nxt;
        p->nxt=s;
    

删除

int del_(int i)

    Node *p;
    int cnt=0;
    while(p!=NULL&&cnt<i-1)
    
        p=p->nxt;cnt++;
    
    if(p==NULL)
        return -1;
    else
    
        Node *q=p->nxt;
        int x=q->data;
        p->nxt=q->nxt;
        delete q;
        return x;
    

查找

int Locate(int x)

    Node *p=fs->nxt;
    int cnt=1;
    while(p!=NULL)
    
        if(p->data==x)
            return cnt;
        else
            cnt++,p=p->nxt;
    
    if(p==NULL)
        return -1;

栈和队列

//10进制转任意进制
void Change(int num,int r)

    int top=-1;
    while(num!=0)
    
        d[++top]=num%r;
        num/=r;
    
    while(top!=-1)
        cout<<d[top--]<<" ";
    cout<<endl;


//以不带头结点的循环链表表示队列，并且只设一个结点指向队尾节点，不设头指针
void Enqueue(Node *re,int x)

    Node *s=new Node;
    s->data=x;
    if(re==NULL)
    
        re=s;
        re->nxt=re;
    
    else
    
        s->nxt=re->nxt;
        re->nxt=s;
        re=s;
    


int Dequeue(Node *re)

    if(re==NULL)
        return -1;
    if(re->nxt=re)
        re=NULL;
    else
    
        Node *p=re->nxt;
        re->nxt=p->nxt;
        delete p;
    

二叉树

层 次遍历

void Levelorder(Binode * root)

    int fr=-1,re=-1;
    Binode Q[N];
    if(root==NULL)
        return;
    Q[++re]=root;
    while(fr!=re)  
    
        Binode *p=Q[++fr];
        cout<<p->data<<" ";
        if(p->lc!=NULL)
            Q[++re]=p->lc;
        if(p->rc!=NULL)
            Q[++re]=p->rc;
    

后序遍历打印树的叶子节点

void Postleaf(Binode *root)

    if(root!=NULL)
    
        Postleaf(root->lc);
        Postleaf(root->rc);
        if(root->lc==NULL&&root->rc==NULL)
        
            cout<<root->data<<" ";
        
        

查找技术

//到哨兵的顺序查找
int Locate(int x)

    d[0]=x;
    int i=len;
    while(d[i]!=x)
        i--;
    return i;

//折半查找
int Binsearch(int x)

    int low=1,high=len,mid;
    while(low<=high)
    
        mid=low+high>>1;
        if(d[mid]>x)
            high=mid-1;
        else if(d[mid]<x)
            low=mid+1;
        else
            return mid;
    
    return -1;


//二叉排序树的插入
Binode InsertBST(Binode *bt,int x)

    if(bt==NULL)
    
        Binode *s=new Binode;
        s->data=x;
        s->lc=s->rc=NULL;
        bt=s;
        return bt;
    
    if(bt->data>x)
        bt->lc=InsertBST(bt->lc,x); //要指向插入的结点
    else if(bt->data<x)
        bt->rc=InsertBST(bt->rc,x);


//二叉排序树的搜索
Binode SearchBST(Binode *bt,int x)

    if(bt==NULL) return;
    if(bt->data==x)
        return bt;
    if(bt->data>x)
        SearchBST(bt->lc,x);
    else if(bt->data<x)
        SearchBST(bt->rc,x);

排序技术

插入排序

int d[N];
int len;
//直接插入排序
void Insert()

    for(int i=1;i<len;i++)
    
        int tmp=d[i];
        for(int j=i-1;j>=0&&tmp<d[j];j--)
        
            d[j+1]=d[j];
        
        d[j+1]=tmp;
    


//希尔排序
void Shellsort()

    for(int d=len/2;i>=1;d/=2)
    
        for(int i=d;i<len;i++)
        
            int tmp=d[i];
            for(int j=i-d;j>=0&&tmp<d[j];j-=d)
                d[j+d]=d[j];
            d[j+d]=tmp;
        
    

交换排序

//冒泡排序
void BubbleSort()

    int exchange=len-1,bound,tmp;
    while(exchange!=0)
    
        bound=exchange;exchange=0;
        for(int i=0;i<bound;i++)
            if(d[i+1]>d[i])
        
            swap(d[i+1],d[i]);
            exchange=j;
        
    


//快速排序
int Partition(int fs,int ls)

    int i=fs,j=ls;
    while(i<j)
    
        while(i<j&&d[i]<=d[j])  j--;
        if(i<j)
        
            int tmp=d[i];d[i]=d[j];d[j]=tmp;i++;
        
        while(i<j&&d[i]<=d[j]) i++;
        if(i<j)
        
            int tmp=d[i];d[i]=d[j];d[j]=tmp;j--;
        
    
    return i;

void QuickSort(int fs,int ls)

    if(fs>=ls)
        return;
    int k=Partition(fs,ls);
    QuickSort(fs,k-1);
    QuickSort(k+1,ls);

选择排序

//选择排序
void SeleSort()

    for(int i=0;i<len-1;i++)
    
        int tmp=i;
        for(int j=i+1;j<len;j++)
        
            if(d[tmp]>d[j]) tmp=j;    
        
        if(tmp!=i)
            swap(d[tmp],d[i]);
    


//堆排序
void Sift(int k,int ls)

    int i=k,j=2*k+1;
    while(j<=ls)
    
        if(j<ls&&d[j]<d[j+1]) j++;
        if(d[i]>d[j])
            break;
        else
        
            int tmp=d[i];
            d[i]=d[j];
            d[j]=tmp;
            i=j;
            j=2*i+1;
        
    

void HeapSort()

    for(int i=len/2;i>=0;i--)
        Sift(i,len-1);
    for(int i=1;i<len;i++)
    
        int tmp=d[0];
        d[0]=d[len-i];
        d[len-i]=tmp;
        Sift(0,len-i-1);
    

归并排序

//归并排序
int Merge(int fs1,int ls1,int ls2)

    int *tmp=d[len];
    int i=fs1,j=ls1+1,k=fs1;
    while(i<=ls1&&j<=ls2)
    
        if(d[i]<=d[j])
            tmp[k++]=d[i++];
        else
            tmp[k++]=d[j++];
    
    while(i<=ls1)
        tmp[k++]=d[i++];
    while(j<=ls2)
        tmp[k++]=d[j++];
    for(int i=fs1;i<=ls2;i++)
        d[i]=tmp[i];
    delete[] tmp;

void MergeSort(int fs,int ls)

    if(fs==ls) return;
    else
    
        int mid=(fs+ls)/2;
        MergeSort(fs,mid-1);
        MergeSort(mid+1,ls);
        Merge(fs,mid,ls);