数据结构总复习（1）

  根据数据结构书上来复习（提醒一下自己，学会自己总结，而不是去看很多试题，如果掌握原理了，就不用担心任何出题形式了。一定要注重基础）

   一：线性表

   1，线性表的两种表示和实现

    1）顺序表示和实现

       顺序表示是用一组地址连续的存储单元依次存储线性表的数据元素。顺序存储结构一般用数组来描述，由于线性表的长度可变，所以用动态分配的一维数组

#include<stdio.h>
#include<stdlib.h>
#define LIST_INIT_SIZE 100
#define LISTAdd 10
typedef struct{
      char *elem;//暂且用char
      int length;//当期长度
      int listsize;//当前分配的存储容量
}SqList;
void InitList(SqList &L)
 {
     //初始化
     L.elem=(char *)malloc(LIST_INIT_SIZE*sizeof(char));
     if(!L.elem)
       exit(0);//正常退出，0表示正常退出，其他表示非正常退出
     L.length=0;
     L.listsize=LIST_INIT_SIZE;
}
    

//线性表的插入,在第i个元素之前插入
void ListInsert(SqList &L,int i, char e)
{
  //if((i<1)||(i>L.length+1))
          // return 0;
  if(L.length>=L.listsize)
  {
      char *newbase=(char *)realloc(L.elem,(L.listsize+LISTAdd)*sizeof(char));
      if(!newbase)
          exit(0);
        //return 0在一个函数中是正常的返回过程，它会使得程序返回到函数被调用处，回复之前的执行流程，
       //而exit 一般是在任意位置和使用的，执行到exit 0时，
      //整个进程就over了（这也是为什么在多线程程序中不要随意使用exit的原因），用来使程序退出运行，一般用来处理（不可挽回的）错误状态。
      //2. return是语言级别的，它表示了调用堆栈的返回；而exit是系统调用级别的，它表示了一个进程的结束。
      //3. return是函数的退出(返回)；exit是进程的退出。
      // 4. return是C语言提供的，exit是操作系统提供的（或者函数库中给出的）。
      //5. return用于结束一个函数的执行，将函数的执行信息传出个其他调用函数使用；
      //exit函数是退出应用程序，删除进程使用的内存空间，并将应用程序的一个状态返回给OS，这个状态标识了应用程序的一些运行信息，这个信息和机器和操作系统有关，一般是 0 为正常退出，非0 为非正常退出。
      L.elem=newbase;
      L.listsize+=LISTAdd;
  }
  char *q=&(L.elem[i-1]);
  char *p;
  for(p=&(L.elem[L.length-1]);p>=q;--p)
      *(p+1)=*p;//插入位置及之后的元素往后移
  *q=e;
  L.length++;
}
//从线性表中删除第i个元素,并用e返回其值
void ListDelete(SqList &L,int i,char &e)
{
    //if((i<1)||(i>L.length))
        //return 0;
    char *p=&(L.elem[i-1]);
    e=*p;
    char *q=&(L.elem[L.length-1]);//表尾元素的位置
    for(++p;p<=q;++p)
        *(p-1)=*p;//被删除元素之后的元素左移
    L.length--;
}
int main(void)
{
    SqList L;
    int k=0;
    char e;
    InitList(L);
    printf("请输入要插入线性表中的个数:");
    scanf("%d",&k);
    for(int j=1;j<=k;j++)
    {
       char c;
       printf("输入第%d个元素\n",j-1);
       scanf(" %c",&c);//scanf("%c",&c) 与 scanf(" %c",&c)，后者只是在%前多了个空格，似乎没有什么区别，但使用起来区别是很大的。
                       //scanf()作单字符输入时规定只接收一个字符，但它却把回车符也作为字符对待的。
                       //这就造成程序中只有一个输入字符的scanf()语句时，问题还不大，但如果后面还跟着第二个scanf()字符输入语句，这个scanf()就把前面输入的驾车符当作输入字符了。这就在输入逻辑上造成了混乱，达不到人们预期的愿望。有了这个空格，因为scanf()是跳过空格读字符的，就回避了这个问题。实践证明，这个空格放在%c后面也不能达到目的。应当说，这也是比较巧妙的应用！
       ListInsert(L,j,c);
    }
    //ListInsert(L,1,'a');
    //ListInsert(L,2,'v');
    //ListInsert(L,3,'q');
    //ListInsert(L,4,'t');
    printf("你想删除第几个元素呢？\n");
    scanf("%d",&k);
    ListDelete(L,k,e);//
    printf("线性表中的元素的值是:\n");
    for(int i=0;i<L.length;i++)
    printf("%c\n",L.elem[i]);
    printf("你删除的元素是：%c\n",e);
    return 0;
}

 

运行结果：

 2）链表表示和实现

  链式存储结构：用一组任意的存储单元存储线性表的数据元素（这组存储单元可以使连续的也可以是不连续的），n个结点链结成一个链表，即为线性表的链式存储结构。

两者的区别：线性表的顺序存储结构中，逻辑上相邻的两个元素在物理位置上紧邻，每个元素的存储位置都可从线性表的起始位置计算可得。在单链表中，任何两个元素之间没有固定的关系，但是每个元素的存储位置都包含在其直接前驱结点的信息中。前者是随机存取，后者是非随机存取。

#include<stdio.h>
#include<stdlib.h>
typedef struct LNode{
      char data;//暂且用char
      struct LNode *next;
}LNode,*LinkList;

//带头结点的单链表线性表L中第i个位置之后插入元素e
void ListInsert_L(LinkList &L,int i, char e)
{
   LNode *p,*s;
   p=L;
   int j=0;
   while(p&&j<i-1)
   {
       p=p->next;
       ++j;//找到第i-1个结点
   }
   s=(LinkList)malloc(sizeof(LNode));//生成新结点
   s->data=e;
   s->next=p->next;//插入L中
   p->next=s;
}
//带头结点的单链表线性表L中删除第i个位置的元素，并由e返回其值
void ListDelete(LinkList &L,int i,char &e)
{
    LNode *p,*q;
    p=L;
    int j=0;
    while(p->next&&j<i-1)
    {
      p=p->next;
      j++;
    }
    q=p->next;//删除p后面的元素
    p->next=q->next;
    e=q->data;
    free(q);
}
int main(void)
{
    LinkList L,PrintL;
    int k;
    char e;
    L=(LinkList)malloc(sizeof(LNode));//生成头结点
    L->next=NULL;
    printf("要输入链表中的数据的个数为:\n");
    scanf("%d",&k);
    for(int i=1;i<=k;i++)
    {
        printf("输入第%d个元素\n",i);
        char c;
        scanf(" %c",&c);
        ListInsert_L(L,i,c);
    }
    printf("你要删除的元素的位置是:\n");
    scanf("%d",&k);
    ListDelete(L,k,e);
    printf("链表中的数据是:\n");
    PrintL=L->next;
    while(PrintL)
    {
      printf("%c\n",PrintL->data);
      PrintL=PrintL->next;
    }
    printf("你删除的元素是:%c\n",e);
    return 0;
}

 二：栈和队列

栈和队列也是线性表，其特殊性在于栈和队列的基本操作时线性表操作的子集，它们是操作受限的线性表，可称为限定性的数据结构。

 1）栈的基本操作：

#include<stdio.h>
#include<stdlib.h>
#define stack_init_size 100//预编译
#define stackAdd 10
/*
http://blog.sina.com.cn/s/blog_861912cd0101hzrb.html 预编译详解
*/
typedef struct {
      char *base;//暂且用char,在栈构造之前和销毁之后，base的值为NULL
      char *top;//栈顶指针
      int stacksize;//当前已分配的存储空间
}SqStack;

void InitStack(SqStack &s)
{
    s.base=(char *)malloc(stack_init_size * sizeof(char));
    if(!s.base)
        exit(0);
    s.top=s.base;
    s.stacksize=stack_init_size;
}
void Push(SqStack &s,char e)
{
    if(s.top-s.base>=s.stacksize)
    {
        s.base=(char *)realloc(s.base,(s.stacksize+stackAdd)*sizeof(char));
        if(!s.base)
            exit(0);
        s.top=s.base+s.stacksize;
        s.stacksize+=stackAdd;
    }
    *s.top++ =e;
}

void Pop(SqStack &s,char &e)
{
    if(s.top==s.base)
        printf("栈中无元素!");
    e=* --s.top;
}


int main(void)
{
    SqStack s;
    char e;
    InitStack(s);
    Push(s,'a');
    Pop(s,e);
    printf("%c\n",e);
    return 0;
}

 2）队列的基本操作：

 

#include<stdio.h>
#include<stdlib.h>
typedef struct QNode{
  char data;
  struct QNode *next;
}QNode,*QueuePtr;
typedef struct{
      QueuePtr front;//队头指针
      QueuePtr rear;//队尾指针
}LinkQueue;

void InitQueue(LinkQueue &Q)
{
    Q.front=Q.rear=(QueuePtr)malloc(sizeof(QNode));
    Q.front->next=NULL;
    //Q.rear->next=NULL;
}
void EnQueue(LinkQueue &Q,char e)
{
    QueuePtr p;
    p=(QueuePtr)malloc(sizeof(QNode));
    if(!p)
        exit(0);
    p->data=e;
    p->next=NULL;
    Q.rear->next=p;
    Q.rear=p;//队尾指向新进来的元素
}
void DeQueue(LinkQueue &Q,char &e)
{
  //若队列不空，则删除Q的队头元素，用e返回其值
    if(Q.rear==Q.front)
        printf("队列为空!");
      QueuePtr p;
      p=Q.front->next;
      e=p->data;
      Q.front->next=p->next;
      if(Q.rear==p)
          Q.front=Q.rear;//删除队列中最后一个元素
      free(p);
}
int main(void)
{
    LinkQueue q;
    char e;
    InitQueue(q);
    EnQueue(q,'a');
    DeQueue(q,e);
    printf("%c\n",e);
    return 0;
}