数据结构笔记

系列文章目录

数据结构

一、第五节 单链表操作

1.尾插入法建表

LNode *create_Linklist(void)
/*  尾插法创建单链表，链表得头结点head作为返回值 */
{
    int data;
    LNode *head,*p,*q;
    head = p =(LNode *)malloc(sizeof(LNode));
    p->next = NULL;     /*创建单链表得表头结点head*/
    while(1)
    {
        scanf("%d",&data);
        if(data == NULL) break;
        q = (LNode *)malloc(sizeof(LNode));
        q->data = data;  /*数据域赋值*/
        q->next = p->next; p->next =q; p = q;
        /*钩链，新创建得结点总是作为最后一个结点*/
        
    }
    return (head);
}

可以保证元素顺序与结点顺序

2.单链表查找

单链表查找
按序号查找，取单链表中的第i个元素。
设单链表的长度为n，要查找表中第i个结点，仅当1≤i≤n时，i的值是合法的。
算法描述

int Get_Elem(Lnode *L, int i){
    int j; Lnode *p;
    p = L->next; j = 1;  /* 使p指向第一个结点*/
    while (p!=NULL && j<i){/***保证工作指针没有走到末尾，很常用！！！！！可写成while（p！=NULL）或while（p）***/
        p = p->next; j++;  /*移动指针p，j计数*/
    }
    if(j!=i) return(-32768);
    else
        return(p->data);  /*p为NULL表示i太大；j>i表示i为0 */
}

3.按值查找

二、算法实例

1.请写一算法，在顺序表中查找指定的数据，查找成功则将该记录放到顺序表的最前面，而把其他记录后退到某个位置。

算法如下

void searchValue(Sqlist*head, int x)
{
    for(int i=0; i<head->length; i++)
    {
        if(i!=0 && head->data[i] == x)
        {
            for(int j=i-1; j>=0; j--)
            {
                head->data[j + 1] = head->data[j];
            }
            head->data[0] = x;            
        }
 
    }
}

2.设计一个高效算法，将顺序表L中的所有元素逆置，要求算法的空间复杂度为O(1)。

算法如下

void reverse(Sqlist &L)
{
    ElemType x;
    for(i=0;i<L.length/2;i++)
    {
        x = L.data[i];         //L.data[i]与L.data[L.length - i - 1]交换
        L.data[i]=L.data[L.length - i - 1];
        L.data[L.length - i - 1]=x;
        
    }
}

3.已知线性表(a1,a2,…,an)按顺序结构存储且每个元素为不相等的整数。设计把所有奇数移到所有偶数前边的算法(要求时间最少，辅助空间最少)

算法如下

void move(Sqlist &L)
{
    int i = 0, j = L.length - 1, k;
    ElemType temp;
    while( i <= j )
    {
        while( L.data[i]%2 == 1 ) i++;   //i指向一个偶数
        while( L.data[j]%2 == 0 ) j--;   //i指向一个奇数
        if( i < j )
        {
            temp = L.data[i];    //交换L.data[i]和L.data[j]
            L.data[i] = L.data[j];
            L.data[j] = temp;
        }
    }
}

4.在一个递增有序的线性表中，有数值相同的元素存在。若存贮方式为单链表，设计算法去掉数值相同的元素，使表中不再有重复的元素。例如：(7,10,21,30,42,42,42,51,70)变作(7,10,21,30,42,51,70)，分析算法的复杂度。

算法如下

void Delete_Node_value(LNode*L)
//删除以L为头结点的单链表中所有值相同的结点
{
    LNode*p = L->next, *p, *ptr;
    while( p! = NULL)  //检查链表中所有结点
    {
        *q = p, *ptr = p->next;
        //检查结点p的所有后继结点ptr*
        while( ptr! = NULL )
        {
            if( ptr->data == p->data )
            {
                q->next = ptr->next; free(ptr);
                ptr = q->next;
            }
            else
            {
                q = ptr; ptr = ptr->next;
            }
        }
        p = p->next;
    }
}

时间复杂度O(n²)，空间复杂度O(1)

5.设有一个表头指针为first的单链表（带表头结点），请设计算法通过一趟遍历将链表就地逆转（例如：a->b->c->d变为d->c->b->a），要求逆转后表头指针first指向原来的链表中的最后一个结点。（单链表逆置用头插法）

算法如下

//逆置单链表，*L指的是要逆置的单链表
void reverList(LNode*L)
{
    LNode*temp = L->next;  //开始结点(即第一个结点)
    LNode*q;  //用来记录后继结点
    L->next = NULL;
    while( temp != NULL)
    {
        q = temp->next  //q结点作为辅助结点来记录temp的直接后继结点的位置
        temp->next->L->next; //将temp所指的结点插入到新链表中
        L ->next = temp; //因为后继结点已经存入q中，所以temp仍然可以找到后继
        temp = q;  //此时的新开始结点
    }
}

总结

提示：这里对文章进行总结：

例如：以上就是今天要讲的内容，本文仅仅简单介绍了pandas的使用，而pandas提供了大量能使我们快速便捷地处理数据的函数和方法。