数据结构基础算法整理

//结构化程序设计规定的三种基本控制结构是 顺序、选择、循环
//顺序栈---------------------------------------------------------
#define StackSize 100//假定栈分配的栈控件最多为100个元素
typedef char DataType;//假定栈元素的数据类型为字符
typedef struct{
    DataType data[StackSize];
    int top;
}SeqStack;

//置空栈
void InitStack(SeqStack *S)
{
    S->top=-1;
}
//判栈空
int StackEmpty(SeqStack *S)
{
    return S->top==-1;
}
//判栈满
int StackFull(SeqStack *S)
{
    return S->top==S->StackSize-1;
}
//进栈
void Push(SeqStack *S,DataType x)
{
    if(StackFull(s))
    {
        Error("Stack overflow");//上溢，退出运行
    }
    S->data[++S->top]=x;//栈顶指针加1后将x进栈
}
//退栈
DataType Pop(Seqstack *S)
{
    if(StackEmpty(S))
    {
        Error("Stack underflow");//下溢，退出运行
    }
    return S->data[S->top--];
}
//取栈顶元素
DataType StackTop(SeqStack *S)
{
    if(StackEmpty(S))
    {
        Error("Stack is empty");
    }
    return S->data[S->top];
}

//链栈------------------------------------------------
typedef struct stacknode{
    DataType data;
    struct stacknode *next;
}StackNode;
typedef struct{
    StackNode *top;//栈顶指针
}LinkStack;

void InitStack(LinkStack *S)
{
    S->top=NULL;
}

int StackEmpty(LinkStack *S)
{
    return S->top == NULL;
}

void Push(LinkStack *S,DataType x)
{
    //将元素x插入链栈头部
    StackNode *p=(StackNode *)malloc(sizeof(StackNode));
    p->data=x;
    p->next=S->top;//将新结点*p插入链栈头部
    S->top==p;
}

DataType Pop(ListStack *S)
{
    DataType *x;
    StackNode *p=S->top;    //保存栈顶指针
    if(StackEmpty(S))
    {
        Error("Stack underflow");    //下溢
    }
    x=p->data;        //保存栈顶结点数据
    S->top=p->next;//将栈顶结点从链下摘下
    free(p);        //释放原栈顶结点空间
    return x;
}

DataType StackTop(ListStack *S)
{
    if(StackEmpty(S))
    {
        Error("stack is empty");
    }
    return S->top->data;
}
//循环队列--------------
#define QueueSize 100    //应根据具体情况定义该值
typedef char DataType;    //DataTYpe的类型依赖于具体应用
typedef Sturet{
    int front;        //头指针，队非空时指向队头元素
    int rear;        //尾指针，队非空时指向队尾元素的下一位置
    int count;        //计数器，记录队中元素总数
    DataType data[QueueSize]
}CirQueue;

//置空队
void InitQueue(CirQueue *Q)
{
    Q->front=Q->rear=0;
    Q->count=0;        //计数器置0
}
//判队空
int QueueEmpty(CirQueue *Q)
{
    return Q->count==0;        //队列无元素为空
}
//判队满
int QueueFull(CirQueue *Q)
{
    return Q->count==QueueSize;    //队中元素个数等于QueueSize时队满
}
//入队
void EnQueue(CirQueue *Q,DataTye x)
{
    if(QueueFull(Q))
    {
        Error("Queue overflow");
    }
    Q->count++;
    Q->data[Q->rear]=x;
    Q->rear=(Q->rear+1)%QueueSize;    //循环意义下将尾指针加1
}
//出队
DataType DeQueue(CirQueue *Q)
{
    DataType temp;
    if(QueueEmpty(Q))
    {
        Error("Queue underflow");    //队空下溢
    }
    temp=Q->data[Q->front];
    Q->count--;
    Q->front=(Q->front+1)%QueueSize;    //循环意义下的头指针加1
    return temp;
}
//取队头元素
DataType QueueFront(CirQueue *Q)
{
    if(QueueEmpty(Q))
    {
        Error("Queue is empty.");
    }
    return Q->data[Q->front];
}
//链队列--------------------------------------------
typedef struct queuenode{
    DataType data;
    struct queuenode * next;
}QueueNode;
typedef struct{
    QueueNode * front;    //队头指针
    QueueNode * rear;    //队尾指针
}LinkQueue;

void InitQueue(LinkQueue *Q)
{
    Q->front=NULL;
    Q->rear=NULL;
}
int QueueEmpty(LinkQueue *Q)
{
    return Q->front==NULL&&Q->rear==NULL;
    //实际上只需判队头指针是否为空即可
}
void EnQueue(LinkQueue *Q,DataType x)
{
    //将元素x插入链队列尾部
    QueueNode *p=(QueueNode *)malloc(sizeof(QueueNode));    //申请新结点
    p->data=x;
    p->next=NULL;
    if(QueueEmpty(Q))
    {
        Q->front=Q->rear=p;
    }
    else{
        //x插入非空队列的尾
        Q->rear->next=p;    //*p链到原队尾结点后
        Q->rear=p;            //队尾指针指向新的尾
    }
}

DataType DeQueue(LinkQueue *Q)
{
    DataType x;
    QueueNode *p;
    if(QueueEmpty(Q))
    {
        Error("Queue underflow");    //下溢
    }
    p=Q->front;        //指向队头结点
    x=p->data;        //保存队头结点的数据
    Q->front=p->next;    //    将队头结点从链下摘下
    if(Q->rear==p)    //原队中只有一个结点，删去后队列变空，此时队头指针已为空
    {
        Q->rear=NULL;
    }
    free(p);        //释放被删队头结点
    return x;    //返回队头数据
}

//二叉树链式存储结构----------------------------------
typedef char DataType;        //应由用户定义DataType的实际类型
typedef struct node{
    DataType data;
    Struct node * lchild,rchild;    //左右孩子指针
}BinTNode;    //结点类型
typedef BinTNode * BinTree;

//中序遍历二叉树
void Inorder(BinTree T)
{
    if(T)
    {
        Inorder(T->lchild);
        printf("%c",T->data);    //访问结点
        Inorder(T->rchild);
    }
}

//构造二叉树链表
void CreateBinTree(BinTree * T)
{
    //T是指向跟指针的指针，故修改*T就修改了实参（跟指针）本身
    char ch;
    if((ch=getchar())==' ')
    {
        *T=NULL;    //读入空格，将相应指针置空        
    }
    else{
        //读入非空格
        *T=(BinTNode *)malloc(sizeof(BinTNode));    //生成结点
        (*T)->data=ch;
        CreateBinTree(&(*T)->lchild);    //构造左子树
        CreateBinTree(&(*T)->rchild);    //构造右子树
    }
}

//201404带头结点单链表L中删除数据值最小的结点??
void f34(LinkList L)
{
    ListNode *p,*pre;  //*pre指向删除数据值的前一个结点
    if(L->next==NULL)return;
    pre=L;
    p=L->next;
    while(p->next!=NULL)
    {
        if(pre->next->data > p->next->data)
        {
            pre=p;
        }
        p=p->next;
    }
    p=pre->next;
    pre->next=p->next;
    free(p);
}

typedef struct node{
    int data;
    struct node *next;
}ListNode;
typedef ListNode *List_ptr;
//201410单链表逆转
List_ptr InvertList(List_ptr head)    //原地逆转单链表head
{
    List_ptr middle,p;
    middle=head->next;            //middle指向待反序链表的第一个结点
    head->next=NULL:
    while(middle!=NULL){
        p=middle;                //p指向待处理链表中的第一个结点
        middle=middle->next;    //middle指向待处理链表的下一个结点
        p->next=head->next;        //将p所指结点插入到链头
        head->next=p;
    }
    return head;
}


//201510顺序表冒泡降序排序    key    otherinfo    RecType
int f34(SeqList R,int n)
{
    int i,j,flag;
    for(i=1;i<n;i++){
        flag=0;
        for(j=1;j<=n-i;j++)
        {
            if(R[j]->key<R[j+1]->key)
            {
                flag=1;
                R[0]=R[j];
                R[j]=R[j+1];
                R[j+1]=R[0];
            }
            if(flag=0) return 0;
        }
    }
    return 0;
}

//201610判定单链表L是否是斐波那契序列，是返回1，否返回0，L中结点数不少于2
//f0=0,f1=1,fn=(fn-1)+(fn-2)
int IsF(List_ptr head)
{
    ListNode *pre1=head->next,*pre2=head->next->next,*current=pre2->next;
    if(pre1->data!=0||pre2->data!=1)return 0;
    while(current!=NULL)
    {
        if(current->data==pre1->data+pre2->data)
        {
            pre1=pre2;
            pre2=current;
            current=current->next;
        }
        else break;
    }
    if(current==NULL)return 1;
    else return 0;
}
//201704//返回二叉树T中数据域的值大于或等于x的结点的个数
int SearchXNum(BinTree *T,int x)
{
    int sum;
    if(T==NULL) return 0;
    if(T->data>=x)sum=1;
    else sum=0;
    return sum+SearchXNum(T->lchild,x)+SearchXNum(T->rchild,x);
}

//201710转换镜像二叉树
void f34(BinTree T)
{
    BinNode *temp;
    if(T)
    {    
        temp=T->lchild;
        T->lchild=T->rchild;
        T->rchild=temp;
        f34(T->lchild);
        f34(T->rchild);
    }
}
//201810 n个单链表表头指针保存在数组A中
//多链表查找值为key的数据元素，查找成功返回1，查找失败返回0
int f34(SeqList A,int n,int key)
{
    int i;
    Node *p;
    for(i=0;i<n;i++)
    {
        p=A[i];
        while(p!=NULL)
        {
            if(p->data==key)return 1;
            p=p->next;
        }
    }
    return 0;
}

//顺序表查找算法    平均查找长度:(n+1)/2
int SeqSearch(Seqlist R,KeyType K)
{
    //在顺序表R[1..n]中顺序查找关键字为K的结点
    //成功时返回找到的结点位置，失败时返回0
    int i;
    R[0].key=K;//设置哨兵
    for(i=n;R[i].key!=K;i--);//从表后往前找
    return i;//若i为0，表示查找失败，否则R[i]是要找的结点
}

//矩阵转换
#define MAX 100
typedef struct{
    int i,j;        //非零元素的行号、列号(下标)
    int v;            //非零元素值
}TriTupleNode;
typedef struct{
    TriTupleNode data[MAX];        //存储三元组的数组
    int m,n,t;                    //矩阵的行数、列数和非零元素的个数
}TSMatrix;                        //稀疏矩阵类型
//稀疏矩阵转换，列转换成行
int f31(TSMatrix a,TSMatrix *b)    //返回1表示出错，0表示正确
{
    //a和*b分别是矩阵M、T的三元组表，T为稀疏矩阵M的转置
    int p,q,col;    //col列    ?p    ?q
     b->m=a.n;b->n=a.m;
    b->t=a.t;//非零元总数
    if(b->t<0)return 1;
    else{
        q=0;
        for(col=0;col<a.n;++col)//对A的每一列
        {
            for(p=0;p<a.t;++p)//扫描A的三元组表
            {
                if(a.data[p].j==col)//找到列号为col的三元组
                {
                    b->data[q].i=a->data[p].j;
                    b->data[q].j=a->data[p].i;
                    b->data[q].v=a.data[p].v;
                    ++q;
                }
            }
        }
    }
    return 0;
}

//带头结点双链表，将值为x新结点插入*p之前，设p!=NULL
void DInsertBefore(DListNode *p,DataType x)
{
    DlistNode * s=malloc(sizeof(DListNode));
    s->data=x;
    s->prior=p->prior;
    s->next=p;
    p->prior->next=s;
    p->prior=s;
}