1. 線形テーブルの概要
1. 線状構造
空ではない有限のデータ要素セットの場合:
- 「first」と呼ばれるデータ要素は 1 つだけです
- 「last」というデータ要素は 1 つだけです
- 最初のデータ要素を除く、セット内の各データ要素には、先行するものが 1 つだけあります。
- セット内の各データ要素は、最後の要素を除き、後続要素を 1 つだけ持ちます。
2. リニアテーブル
線形テーブルは n 個のデータ要素の有限シーケンスです。同じ線形テーブル内の要素は同じ特性を持つ必要があり、同じデータ要素間には順序偶数の関係があります。
線形テーブルの要素の数 n (n>=0) が線形テーブルの長さとして定義されます。0==n の場合、それは空のテーブルと呼ばれます。空ではないテーブルでは、各データ要素は明確な位置 (添え字 )。
線形テーブルは、必要に応じて長さを拡大または縮小できる、非常に柔軟なデータ構造です。
2. 線形テーブルの逐次表現と実現:
線形テーブルの逐次表現とは、線形テーブルのデータ要素を連続したアドレスを持つ記憶装置のグループに順次格納することを指します。
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#define TYPE int
// 设计数据结构
typedef struct Array
{
TYPE* base; // 存储元素的基址
size_t cnt; // 元素的数量
size_t cap; // 表的容量
}Array;
// 创建线性表,调用者需要提供容量参数，成功返回线性表指针
Array* creat_array(size_t cap)
{
// 为线性表创建内存空间
Array* array = malloc(sizeof(Array));
// 创建存储元素的内存空间
array->base = malloc(sizeof(TYPE)*cap);
// 初始化数量成员
array->cnt = 0;
// 备份线性表的容量
array->cap = cap;
// 返回线性表指针
return array;
}
// 销毁线性表,调用者只需要提供线性表指针即可
void destory_array(Array* array)
{
// 释放存储元素的内存空间
free(array->base);
// 释放线性表内存空间
free(array);
}
// 清理所有元素
void clear_array(Array* array)
{
array->cnt = 0;
}
// 判断线性表是否是空表
bool empty_array(Array* array)
{
return 0 == array->cnt;
}
// 求线性表的长度
size_t length_array(Array* array)
{
return array->cnt;
}
// 访问指定位置的元素
bool get_array(Array* array,int index,TYPE* elemp)
{
if(index >= array->cnt)
return false;
*elemp = array->base[index];
return true;
}
// 在末尾添加元素
void add_back_array(Array* array,TYPE elem)
{
// 容量如果不够用
if(array->cnt >= array->cap)
{
// 容量扩展两倍
array->cap *= 2;
// 元素存储空间扩展两倍
array->base = realloc(array->base,sizeof(TYPE)*array->cap);
}
// 末尾添加元素
array->base[array->cnt++] = elem;
}
// 插入元素
bool insert_array(Array* array,int index,TYPE elem)
{
// 如果下标不合法则插入失败
if(index >= array->cnt)
return false;
// 把最后一个元素添加到末尾
add_back_array(array,array->base[array->cnt-1]);
// 线性表的顺序存储才可以使用
memmove(array->base+index+1,array->base+index,sizeof(TYPE)*(array->cnt-index-1));
array->base[index] = elem;
return true;
}
// 删除元素，按位置删除
bool delete_index_array(Array* array,int index)
{
if(index >= array->cnt)
return false;
memmove(array->base+index,array->base+index+1,sizeof(TYPE)*(array->cnt-index));
array->cnt--;
return true;
}
// 查询元素
int query_array(Array* array,TYPE elem,int (*compare)(const void*,const void*))
{
for(int i=array->cnt-1; i>=0; i--)
{
if(!compare(&elem,array->base+i))
return i;
}
return -1;
}
// 删除元素，按值删除
bool delete_value_array(Array* array,TYPE elem,int (*compare)(const void*,const void*))
{
return delete_index_array(array,query_array(array,elem,compare));
}
// 对线性表进行排序
void sort_array(Array* array,int (*compare)(const void*,const void*))
{
bool flag = true;
for(int i=array->cnt-1; flag && i>0; i--)
{
flag = false;
for(int j=0; j<i; j++)
{
if(1 == compare(array->base+j,array->base+j+1))
{
TYPE tmp = array->base[j];
array->base[j] = array->base[j+1];
array->base[j+1] = tmp;
flag = true;
}
}
}
}
// 遍历线性表,只是为了测试
void show_array(Array* array)
{
for(int i=0; i<array->cnt; i++)
{
printf("%d ",array->base[i]);
}
printf("\n");
}
int main(int argc,const char* argv[])
{
Array* array = creat_array(10);
for(int i=0; i<10; i++)
{
add_back_array(array,rand()%100);
}
show_array(array);
int intcmp(const void* p1,const void* p2)
{
if(*(int*)p1 > *(int*)p2)
return 1;
if(*(int*)p1 < *(int*)p2)
return -1;
return 0;
}
delete_value_array(array,77,intcmp);
sort_array(array,intcmp);
show_array(array);
destory_array(array);
return 0;
}
**代入:** 逐次線形テーブルのメンバポインタの実装方法をフレキシブル配列に変更します。
3. チェーン表現と線形テーブルの実現
線形テーブルのシーケンシャル格納構造の特徴は、論理関係で隣接する 2 つの要素が物理的位置でも隣接しているため、テーブル内の任意の要素にランダムにアクセスでき、その格納場所を任意の方法で使用できることです。シンプルかつ直感的に数式で表現できます。
この機能は、このストレージ構造の欠点も生み出します。挿入および削除操作中に、多数の要素を移動する必要があるということです。線形テーブルのもう 1 つの表現方法であるチェーン ストレージ構造は、その欠点を補うだけです。
チェーンストレージ構造は、論理的に隣接する要素が物理的に隣接している必要がないため、シーケンシャルストレージ構造の欠点はありませんが、シーケンシャルストレージ構造のランダムアクセスの利点も失われます。
チェーンストレージ構造の特徴は、要素がストレージメモリ内の任意の位置を使用でき(連続でも不連続でも)、要素 a[i] と a[i+1] 間の論理関係が依存しないことです。要素には、その後継要素を示すデータ（要素ポインタ）が付加され、要素そのもののデータ＋後継情報が格納イメージ、通称ノード（ノード）を構成する。
typedef struct Node
{
TYPE data; // 数据域
struct Node* next; // 指针域
}Node;
いくつかの要素ノードはポインタ フィールドを介して接続され、リンク リストと呼ばれる線形リスト構造を形成します。ノード内の後続の要素を指すポインタ フィールドは 1 つだけです。このリンク リストは一方向とも呼ばれます。リンクされたリスト。
一方向リンク リストには、ヘッド ポインタと呼ばれる最初のノードへのポインタが必要です。ヘッド ポインタが指すノードもヘッド ノードと呼ばれます。ヘッド ノードにはデータが保存されない場合があります。単なるプレースホルダです。ノードと最後のノードは、終了記号として NULL を指します。
1. ヘッドノードのない単一リンクリスト
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#define TYPE int
typedef struct Node
{
TYPE data;
struct Node* next;
}Node;
// 创建节点
Node* create_node(TYPE data)
{
// 创建节点内存
Node* node = malloc(sizeof(Node));
// 赋值数据域
node->data = data;
// 初始化指针域
node->next = NULL;
return node;
}
// 头添加元素
void front_list(Node** head,TYPE data)
{
// 创建节点
Node* node = create_node(data);
node->next = *head;
*head = node;
}
// 删除元素
bool delete_index_list(Node** head,int index)
{
// 删除第一个节点，因为第一个节点没有前驱
if(0 == index)
{
Node* node = *head;
*head = (*head)->next;
free(node);
return true;
}
// 找到要删除的节点的前驱
Node* prev = *head;
while(NULL!=prev->next && index-->1)
prev = prev->next;
if(NULL != prev->next)
{
// 备份要删除的节点
Node* node = prev->next;
// 前驱节点的指针域指向后继节点
prev->next = prev->next->next;
free(node);
return true;
}
return false;
}
// 插入元素
bool insert_list(Node** head,int index,TYPE data)
{
Node* node = create_node(data);
if(0 == index)
{
node->next = *head;
*head = node;
return true;
}
Node* prev = *head;
while(NULL!=prev->next && index-->1)
prev = prev->next;
if(NULL != prev->next)
{
node->next = prev->next;
prev->next = node;
return true;
}
return false;
}
// 遍历链表
void show_list(Node* head)
{
for(Node* n=head; NULL!=n; n=n->next)
{
printf("%d ",n->data);
}
printf("\n");
}
int main(int argc,const char* argv[])
{
// 创建头指针
Node* head = NULL;
for(int i=0; i<10; i++)
{
front_list(&head,i);
}
show_list(head);
delete_index_list(&head,9);
insert_list(&head,9,100);
show_list(head);
return 0;
}
2. 主要ノードの単一リンクリスト
連結リストの挿入・削除操作を行う場合、被操作ノードの先行ノードと後続ノードが必要となりますが、被操作ノードが先頭ノードの場合には先行ノードが存在せず、追加の特別な処理が必要となるため、挿入および削除操作を容易にするために、単一リンクされたリストには空のヘッド ノードが追加されます。
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#define TYPE int
typedef struct Node
{
TYPE data;
struct Node* next;
}Node;
Node* create_node(TYPE data)
{
Node* node = malloc(sizeof(Node));
node->data = data;
node->next = NULL;
return node;
}
Node* create_list(void)
{
Node* node = malloc(sizeof(Node));
node->next = NULL;
return node;
}
void destory_list(Node* head)
{
while(head)
{
Node* node = head;
head = head->next;
free(node);
}
}
void front_list(Node* head,TYPE data)
{
Node* node = create_node(data);
node->next = head->next;
head->next = node;
}
bool delete_index_list(Node* head,int index)
{
// 找到要删除的节点的前驱
Node* prev = head;
while(NULL != prev->next && index-- >= 1)
prev = prev->next;
// index 非法，超出了节点的数量
if(NULL == prev->next)
return false;
// 备份要删除的节点
Node* node = prev->next;
// 前驱节点接后继节点
prev->next = prev->next->next;
// 删除节点
free(node);
return true;
}
void show_list(Node* head)
{
// 要跳过头节点
for(Node* n=head->next; NULL!=n; n=n->next)
{
printf("%d ",n->data);
}
printf("\n");
}
int main(int argc,const char* argv[])
{
Node* list = create_list();
for(int i=0; i<10; i++)
{
front_list(list,i);
}
show_list(list);
delete_index_list(list,3);
show_list(list);
return 0;
}