线性表2019-10-27

顺序表的特点：

1、表中各个元素存放在连续的存储空间中；

2、表中各个元素的存储顺序与线性表中逻辑顺序相同。

插入元素时间复杂度为O(N)，移动数据元素n-i次

删除元素时间复杂度为O(N)，移动数据元素n-i-1次

顺序表优点：存储结构和逻辑结构一致。结构简单。

缺点：需要足够的空间，插入和删除效率低。

栈：

后进先出

一个指针top指向栈顶，一个指针bottom指向栈底。

双栈：

0-1背包问题：利用栈回溯。

void knapsack(int w[],int C,int n)    //w数组存放数，C总体积，n数组个数

{

    stack<int> s;

     int i = 0;

     while( !s.empty() || i != n)

    {

             if(C - w[i] >= 0)

            {

                    s.push(i);

                     C -= w[i];

                    i++;

            }

           if(C == 0)

                      {输出栈中元素。}

           i = s.pop();

               C += w[i];

                 i++;

    }

}

//走迷宫问题  //栈回溯

struct ElemType

{

    int i,j,v;//ij为行列，v试探方向

}stk;

int Maze_path(int maze[][],int mark[][],int m,int n)

{

    //maze迷宫数组，mark走过位置标志数组，m,n迷宫的行、列数，迷宫走通返回1，走不通返回0

    //定义并初始化方位数组

    int move[8][2] = {{0,1},{1,1},{1,0},{1,-1},{0,-1},{-1,-1},{-1,0},{-1,-1}};

    int g, h;

    mark[1][1] = 1;

    InitStack(s);

    stk.i = 1;

    stk.j = 1;

    stk.v = 0;//开始试探的方向。

    while(!empty(s) || stk.v != 7)

    {

        g = s.stk.i + move[v][0];

        h = s.stk.j + move[v][1];

        //每到达一个新的位置，总是首先判断正东方位

        if(g == m && h == n && maze[m][n] == 0)

        {

            //若试探位置可走，且已到达出口，把当前位置和出口位置入栈，

            //输出栈中保存的走通的路径，返回1结束程序。

            push(s,stk);

            stk.i = m;

            stk.j = n;

            stk.v = 0;

            push(s,stk);

            while(!empty(s))

            output(s.stk);

            return 1;

        }

        else if(maze[g][h] == 0 && mark[g][h] == 0)

        {

            //若试探方位可走，但未到达出口，当前位置入栈，置新的位置为当前位置，继续进行试探

            mark[g][h] = 1;

            push(s,stk);

            stk.i = g;

            stk.j = h;

            stk.v = 0;

        }

        else

        {

            if(s.stk.v  < 7)

                stk.v = stk.v + 1;

            else

            {

                while(stk.v == 7 && !empty(s))

                    stk = pop(s);

                if(!empty(s))

                    stk = pop(s);

            }

        }

    }

    cout << "No path!" << endl;

    return 0;

}

//查找数组元素最大值 栈分治实现

ElemType Select_max(ElemType a[],int n)

{

    InitStack(s);

    ElemType tmp,cmax = a[0];

    push(s,0);

    push(s,n-1);

    while(!empty(s))

    {

        int m = pop(s);

        int k = pop(s);

        while(m-k > 1)

        {

            int j = (k + m)/2;

            push(s,j+1);

            push(s,m);

            m = j;

        }

        if(m-k == 1)

            tmp = (a[m] > a[k]) ? a[m] : a[k];

        else

        {

            tmp = a[k];

        }

        if(tmp > cmax)

            cmax = tmp;

    }

    return cmax;

}

//查找最大数 栈递归

int select(int a[],int l,int h)

{

    if(h - l == 1)

    {

        if(a[l] < a[h])

            return a[h];

        else

        {

            return a[l];

        }

    }

    else

    {

        int mid = (l + h)/2;

        int j = select(a,l,mid);

        int k = select(a,mid+1,h);

        if(j > k)

            return j;

        else

        {

            return k;

        }

    }

}

//汉诺塔问题

void Hanoi(int i,char x,char y,char z)

{

    if(n == 1)

        move(x,n,z);

    else

    {

        Hanoi(n-1,x,z,y);

        move(x,n,z);

        Hanoi(n-1,y,x,z);

    }

    return;

}

队列：

先进先出，队头队尾两个指针。

循环队列：

空间为[0:maxsize-1],初始队空时，f = r = 0;

当需要入队时，队尾指针操作：

r = (r + 1) % maxsize;

当队头出队时 ，队头指针操作：

f = (f + 1) % maxsize;

队空f = r;

第一种方法：队满：（r+1）%maxsize == f;

第二种方法：队满：（flag == 1）&& (r == f)

课本例题：缓冲区设计、中缀表达式转后缀表达式、排队。