Las estructuras de datos, algoritmos, y resume la tabla lineales

Una estructura de datos

1, el concepto de una estructura de datos

　　Estructura de datos es la presencia de uno o más elementos de datos de la relación particular entre cada serie. Por los elementos de datos, elementos de datos de los elementos de datos, el elemento de datos es una unidad básica de datos, el elemento de datos es la unidad más pequeña de datos.

2, la estructura lógica

　　datos Estructura lógica se divide en configuración estructural lineal y no lineal, en el que la estructura lineal incluye una mesa lineal, pilas, colas, y similares cuerdas, y la estructura no lineal comprende un gráfico de unión estructura de árbol estructura y similares.

3, la estructura de almacenamiento

　　Almacenamiento de datos de configuración en la estructura de almacenamiento secuencial y estructura de almacenamiento de cadena. estructura de almacenamiento secuencial es lógicamente lugares de almacenamiento adyacentes en la unidad de almacenamiento físico, tal como matriz adyacente; estructura de memoria cadena no se requiere para ser nodos conectadas lógicamente ubicaciones físicas adyacentes, que pueden ser representados por un puntero de datos lógicos de préstamo entre las relaciones.

4, el algoritmo

　　Cinco características (1) comprende un algoritmo finito, la seguridad, la viabilidad, y una salida.

　　El método descrito en (2) el algoritmo puede partir de un lenguaje natural, pseudocódigo y lenguajes de programación. Cuando la descripción del lenguaje natural más fuerte, pero escribirlo complicado; la programación de lenguaje, sino una lectura fácil de los peores escrito; ventaja antes de la combinación de pseudo-código de los dos, haciendo que el proceso de escritura de código más a menudo.

　　(3) algoritmo para analizar la eficiencia del algoritmo de complejidad de tiempo y complejidad espacio grado: métodos para medir la eficiencia del algoritmo también incluir ex post y análisis ante método ex estimación estadística.

　　　　① tiempo complejidad: el número de veces que realiza el algoritmo de operaciones básica T (n) es una función del tamaño problema denotado como n T (n) = O (f (n)). A menudo aparecerá orden O constante (1), el orden O lineal (n), el cuadrado de la orden O (n ^ 2), del orden O (log2N); cálculo de complejidad de tiempo se obtiene solamente T (n) de orden más alto, ignorado constantes de orden y de orden inferior, que puede ser visto como el tamaño del problema n es grande la eficiencia del tiempo del algoritmo.

　　　　② complejidad espacial: algoritmos de medición durante el funcionamiento ocupación temporal de espacio de almacenamiento.

　　　　En general, el cálculo es más abundante espacio, a menudo como una complejidad espacial del algoritmo algoritmo de medida de los méritos.

5, la estructura del tipo de datos y de datos :

　　tipo de datos abstracto (ADT) del marco:

　　{Nombre Tipo de datos

　　　　Los objetos de datos;

　　　　las relaciones de datos;

　　　　Operaciones básicas;

　　}

 En segundo lugar, la forma lineal

1, la tabla de secuencia

#define MAXSIZE 50 
typedef int Elemtype; 
typedef struct { 
    datos Elemtype [MAXSIZE]; 
    int longitud; 
SqList};

Características: ① lógicamente adyacentes <-> dirección física adyacente; ② memoria de acceso aleatorio (acceso rápido).

Ventajas: ① utilización relativamente alta con un espacio (pero también no me gusta la lista como un puntero a la memoria asignada) completa; ② velocidad de lectura rápida, excelente al azar en el almacenamiento.

Desventajas: ① no saben de antemano si desea asignar espacio de memoria será cómo perder mucho una gran cantidad de espacio de memoria o falta de espacio dio lugar a un desbordamiento; ② operaciones de borrado de inserción y es lento.

(1) elementos de inserto

 

bool InsertList (SqList * & L, int i, Elemtype e) 
{ 
    si (i < 1 || L-> + longitud 1 )
         de retorno  falsa ; 
    i - ;
    para ( int j = L-> longitud; j> i ; j-- ) 
        L -> datos [j] = L-> datos [j - 1 ]; 
    L -> datos [i] = e; 
    L -> longitud ++ ;
    volver  verdadera; 
}

complejidad Tiempo: O (L-> longitud).

(2) elementos quitan

bool DeleteList (SqList * & L, int i, Elemtype y e) 
{ 
    si (i < 1 || i-> + longitud 1 )
         de retorno  falsa ; 
    i - ; 
    e = L-> datos [i];
    para ( int j = i; j <L-> longitud- 1 ; j ++ ) 
        L -> datos [j] = L-> datos [j + 1 ]; 
    L -> longitud-- ;
    volver  verdadera ; 
}

complejidad Tiempo: O (L-> longitud).

2, la lista

typedef struct LNode { 
    datos Elemtype; 
    struct LNode * siguiente; 
LinkList};

Características: elemento de datos de tabla lineal almacenada en una dirección de grupo de cualquier conexión de nodo de almacenamiento entre la siguiente memoria.

Ventajas: ① de asignación de memoria dinámica; ② borrar e insertar la operación sin mover la posición de los elementos en la tabla.

Desventajas: ① estructuras de elementos de almacenamiento de acceso secuencial en comparación con el relativamente lento; ② la necesidad de asignar espacio para un puntero al siguiente nodo.

configuración de nodo: elementos de datos puntero +, en el que los valores de los elementos de datos del nodo de almacenamiento de datos, la siguiente dirección de almacenamiento puntero de nodo del nodo.

Los elementos de datos (1) Encontrar la ubicación especificada en la tabla

 

bool GetElem(LinkList* L, int i, Elemtype& e)
{
    int j = 0;
    LinkList* p = L;
    while (j < i && p != NULL) {
        j++;
        p = p->next;
    }
    if (p == NULL)
        return false;
    else {
        e = p->data;
        return true;
    }
}

时间复杂度：O(L->length)

(2)插入元素

bool InsertList(LinkList*& L, int i, Elemtype e)
{
    int j = 0;
    LinkList* p = L;
    while (j < i - 1 && p != NULL) {
        j++;
        p = p->next;
    }
    if (p == NULL)
        return false;
    else {
        s = new LNode;
        s->data = e;
        s->next = p->next;
        p->next = s;
    }
}

时间复杂度：O(L->length)。

(3)删除元素

bool DeleteList(LinkList*& L, int i, Elemtype e)
{
    int j = 0;
    LinkList* p = L, * q;
    while (j < i - 1 && p != NULL) {
        j++;
        p = p->next;
    }
    if (p == NULL)
        return false;
    else {
        q = p->next;
        if (q == NULL)
            return false;
        e = q->data;
        p->next = q->next;
        delete p;
        return true;
    }
}

时间复杂度：O(L->length)。

(4)建单链表-头插法

void CreateListF(LinkList*& L, Elemtype a[], int n)
{
    LinkList* s;
    L = new LNode;
    L->next = NULL;
    for (int i = 0; i < n; i++) {
        s = new LNode;
        s->data = a[i];
        s->next = L->next;
        L->next = s;
    }
}

输出的结果与输入相反。

(5)建单链表-尾插法

void CreateListR(LinkList*& L, Elemtype a[], int n)
{
    LinkList* s, * r;
    L = new LNode;
    r = L;
    for (int i = 0; i < n; i++) {
        s = new LNode;
        s->data = a[i];
        r->next = s;
        r = s;
    }
    r->next = NULL;
}

输出的结果与输入相同。

3、双链表

 

typedef struct DNode {
    Elemtype data;
    struct DNode* prior;
    struct DNode* next;
}DLinkList;

 

(1)节点插入

s->next = p->next;
p->next = s;
s->next->prior = s;
s->prior = p;

(2)节点删除

q = p->next;
p->next = q->next;
q->next->prior = p;
delete q

 4、有序表：其中所有元素以递增或递减的方式有序排列

(1)插入

//顺序表
void ListInsert(SqList*& L, Elemtype e)
{
    int i = 0, j;
    while (i < L->length && L->data[i] < e)
        i++;
    for (j = L->length; j > i; j--)
        L->data[j] = L->data[j - 1];
    L->data[i] = e;
    L->length++;
}

//链式表
void ListInsert(LinkList*& L, Elemtype e)
{
    LinkList* pre = L, * p;
    while (pre->next != NULL && pre->next->data < e)
        pre = pre->next;
    p = new LNode;
    p->data = e;
    p->next = pre->next;
    pre->next = p;
}

三、栈

1、栈

　　概念：栈是限制仅在线性表的一端进行插入与删除操作的线性表

　　特点：后进先出(LIFO)

2、顺序栈

#define Maxsize 100
typedef struct {
    Elemtype data[Maxsize];
    int top;
}SqStack;

(1)进栈

bool Push(SqStack*& s, ELemtype e)
{
    if (s->top == Maxsize - 1)
        return false;
    s->top++;
    s->data[s->top] = e;
    return true;
}

(2)出栈

bool Pop(SqStack*& s, Elemtype& e)
{
    if (s->top == -1)
        return false;
    e = s->data[s->top];
    s->top--;
    return true;
}

(3)取栈顶元素

bool GetTop(SqStack* s, Elemtype& e)
{
    if (s->top == -1)
        return false;
    e = s->data[s->top];
    return true;
}

3、链式栈

typedef struct linknode {
    Elemtype data;
    struct linknode* next;    
}LiStack;

(1)进栈

void Push(LiStack*& s, Elemtype e)
{
    LiStack* p;
    p = new LiStack;
    p->data = e;
    p->next = s->next;
    s->next = p;
}

(2)出栈

void Pop(LiStack*& s, Elemtype& e)
{
    LiStack* p;
    if (s->next == NULL)
        return false;
    p = s->next;
    e = p->data;
    s->next = p->next;
    delete p;
    return true;
}

(3)取栈顶元素

void GetTop(LiStack* s, Elemtype& e)
{
    if (s->next == NULL)
        return false;
    e = s->next->data;
    return true;
}

4、#include<stack>

stack

stack模板类的定义在<stack>头文件中。

stack模板类需要两个模板参数，一个是元素类型，一个容器类型，但只有元素类型是必要的，在不指定容器类型时，默认的容器类型为deque。

定义stack对象的示例代码如下：

stack<int> s1;
stack<string> s2;

stack的基本操作有：

入栈，如例：s1.push(x);

出栈，如例：s1.pop();注意，出栈操作只是删除栈顶元素，并不返回该元素。

访问栈顶，如例：s1.top()

判断栈空，如例：s1.empty()，当栈空时，返回true。

访问栈中的元素个数，如例：s1.size()

四、队列

1、队列

　　概念：只允许在表的一端(队尾)进行插入，而在表的另一端(队头)进行删除。

　　特点：先进先出(FIFO)。

2、顺序队列

#define MaxSize 100
typedef struct {
    Elemtype data[Maxsize];
    int front;
    int rear;
}SqQu

(1)入队

bool enQueue(SeCiQueue*& q, Elemtype e)
{
    if ((q->rear+1)%Maxsize==q->front)
        return false;
    q->rear = (q->rear + 1) % Maxsize;
    q->data[q->rear] = e;
    return true;
}

(2)出队

bool deQueue(SeciQueue*& q, Elemtype& e)
{
    if (QueueEmpty(q))
        return false;
    q->front = (q->front + 1) % Maxsize;
    e = q->data[q->front];
    return true;
}

3、链式队伍

typedef struct QNode {
    Elemtype data;
    struct QNode* next;
}QNode;

 

(1)入队

void enQueue(LiQueue*& q, Elemtype e)
{
    QNode* newNode = new QNode;
    newNode->data = e;
    newNode->next = NULL;
    if (QueueEmpty(q)) {
        q->rear = newNode;
        q->front = newNode;
    }
    else {
        q->rear->next = newNode;
        q->rear = newNode;
    }
}

(2)出队

bool deQueue(LiQueue*& q, Elemtype& e)
{
    QNode* del;
    if (QueueEmpty(q))
        return false;
    del = q->front;
    if (q->front = q->rear)
        q = front = q->rear = NULL;
    else
        q->front = q->front->next;
    e = del->data;
    delete del;
    return true;
}

4、#include<queue>

queue

queue模板类的定义在<queue>头文件中。

与stack模板类很相似，queue模板类也需要两个模板参数，一个是元素类型，一个容器类型，元素类型是必要的，容器类型是可选的，默认为deque类型。

定义queue对象的示例代码如下：

queue<int> q1;
queue<double> q2;

queue的基本操作有：

入队，如例：q1.push(x); 将x接到队列的末端。
出队，如例：q1.pop(); 弹出队列的第一个元素，注意，并不会返回被弹出元素的值。
访问队首元素，如例：q1.front()，即最早被压入队列的元素。
访问队尾元素，如例：q1.back()，即最后被压入队列的元素。
判断队列空，如例：q1.empty()，当队列空时，返回true。
访问队列中的元素个数，如例：q1.size()

五、串

1、串

　　概念：由零个或多个字符组成的有限序列。

2、#include<string>

　　详情访帖：http://blog.sina.com.cn/s/blog_453a02280100r8tv.html

3、BF算法

 

1.在串S和串T中设置比较的起始下标i=0，j=0
2.重复下述操作，直到S或T的所有字符比较完毕
    ①如果S[i]=T[j]，则继续比较S和T的下一对字符
    ②否则，回溯下标i=i-j+1，j=0
3.如果T中所有字符比较完毕，则返回匹配的开始位置
    i-t.length(t为T字串)；否则返回-1
时间复杂度：O(n*m)

4、KMP算法

1.在串S和串T中，分别设置比较的起始下标，i=0，j=0
2.重复下述操作，直到S或T的所有字符均比较完毕
    ①如果S[i]等于T[j]，则继续比较S和T的下一对字符
    ②否则，将下标j回溯到next[j]位置，即j=next[j]
    ③如果j=-1，则将下标i和j分别加1，准备下一趟比较
3.如果T中所有字符均比较完毕，则返回本趟匹配的开始位置，否则返回-1

六、总结

1、在这次总结中，巩固了几种线性表的基本操作，对数据结构中结构部分有了更深的了解。

2、因为总结的时间没有把握好，写的仍不是很具体，有些操作还没有彻底理解。

3、在实际操作中仍不熟练，之后会加深代码的应用，增加熟练度。