数据结构-链表

//单链表的基本实现

#include<stdio.h>;
#include<stdlib.h>;
typedef struct Node {
	int data;
	struct Node* next;
}Node;

void initializelist(Node** head) {
	*head = (Node*)malloc(sizeof(Node));
	(*head)->next = NULL;
}

void insertAtHead(Node** head, int data) {
	Node* newNode = (Node*)malloc(sizeof(Node));
	newNode->data = data;
	newNode->next = (*head)->next;
	(*head)->next = newNode;
}
void printlist(Node* head) {
	Node* current = head->next;
	while (current != NULL) {
		printf("%d", current->data);
		current = current->next;
	}
	printf("\n");
}

void freelist(Node** head) {
	Node* current = (*head)->next;
	while (current != NULL) {
		Node* temp = current;
		current = current->next;
		free(temp);
	}
	free(*head);
	*head = NULL;
}

int main() {
	Node* head;
	initializelist(&head);
	insertAtHead(&head, 1);
	insertAtHead(&head, 2);
	insertAtHead(&head, 3);
	insertAtHead(&head, 4);
	printlist(head);
	freelist(&head);
	return 0;
}

//双链表基本实现
#include <stdio.h>
#include <stdlib.h>

// 双链表节点结构
typedef struct Node {
    int data;           // 数据
    struct Node* prev;  // 前一个节点指针
    struct Node* next;  // 后一个节点指针
} Node;

// 创建一个新节点
Node* createNode(int data) {
    Node* newNode = (Node*)malloc(sizeof(Node));
    newNode->data = data;
    newNode->prev = NULL;
    newNode->next = NULL;
    return newNode;
}

// 在链表末尾插入节点
void insertEnd(Node** head, int data) {
    Node* newNode = createNode(data);
    if (*head == NULL) {
        *head = newNode;
    }
    else {
        Node* temp = *head;
        while (temp->next != NULL) {
            temp = temp->next;
        }
        temp->next = newNode;
        newNode->prev = temp;
    }
}

// 在链表开头插入节点
void insertFront(Node** head, int data) {
    Node* newNode = createNode(data);
    if (*head == NULL) {
        *head = newNode;
    }
    else {
        newNode->next = *head;
        (*head)->prev = newNode;
        *head = newNode;
    }
}

// 删除链表中指定节点
void deleteNode(Node** head, Node* delNode) {
    if (*head == NULL || delNode == NULL) {
        return;
    }

    if (*head == delNode) {
        *head = delNode->next;
    }

    if (delNode->next != NULL) {
        delNode->next->prev = delNode->prev;
    }

    if (delNode->prev != NULL) {
        delNode->prev->next = delNode->next;
    }

    free(delNode);
}

// 打印链表元素
void printList(Node* head) {
    Node* temp = head;
    while (temp != NULL) {
        printf("%d ", temp->data);
        temp = temp->next;
    }
    printf("\n");
}

int main() {
    Node* head = NULL;

    insertEnd(&head, 1);
    insertEnd(&head, 2);
    insertFront(&head, 3);
    insertFront(&head, 4);

    printf("双链表元素：");
    printList(head);

    deleteNode(&head, head);  // 删除头节点
    deleteNode(&head, head->next);  // 删除第二个节点

    printf("删除节点后的双链表元素：");
    printList(head);

    return 0;
}



//顺序表基本实现
#include <stdio.h>
#include <stdlib.h>

#define MAX_SIZE 100

typedef struct {
    int data[MAX_SIZE];
    int length;
} SeqList;

// 初始化顺序表
void init(SeqList* list) {
    list->length = 0;
}

// 判断顺序表是否为空
int isEmpty(SeqList* list) {
    return list->length == 0;
}

// 判断顺序表是否已满
int isFull(SeqList* list) {
    return list->length == MAX_SIZE;
}

// 获取顺序表的长度
int getLength(SeqList* list) {
    return list->length;
}

// 在顺序表的指定位置插入元素
int insert(SeqList* list, int position, int value) {
    if (position < 0 || position > list->length || isFull(list)) {
        printf("Invalid position or list is full\n");
        return 0;
    }

    // 向后移动元素腾出位置
    for (int i = list->length - 1; i >= position; i--) {
        list->data[i + 1] = list->data[i];
    }

    list->data[position] = value;
    list->length++;

    return 1;
}

// 删除顺序表指定位置的元素
int removeAt(SeqList* list, int position) {
    if (position < 0 || position >= list->length || isEmpty(list)) {
        printf("Invalid position or list is empty\n");
        return 0;
    }

    // 向前移动元素覆盖被删除的位置
    for (int i = position; i < list->length - 1; i++) {
        list->data[i] = list->data[i + 1];
    }

    list->length--;

    return 1;
}

// 获取顺序表指定位置的元素值
int get(SeqList* list, int position) {
    if (position < 0 || position >= list->length || isEmpty(list)) {
        printf("Invalid position or list is empty\n");
        return -1;
    }

    return list->data[position];
}

// 打印顺序表中的元素
void printList(SeqList* list) {
    if (isEmpty(list)) {
        printf("List is empty\n");
        return;
    }

    printf("List elements: ");
    for (int i = 0; i < list->length; i++) {
        printf("%d ", list->data[i]);
    }
    printf("\n");
}

int main() {
    SeqList list;
    init(&list);

    insert(&list, 0, 10);
    insert(&list, 1, 20);
    insert(&list, 2, 30);

    printList(&list);

    printf("Element at position 1: %d\n", get(&list, 1));

    removeAt(&list, 1);

    printList(&list);

    return 0;
}

单双链表基本实现有无头节点对于链表头插法有些区别。头节点就是节点只有指针的节点没有数据，头指针通过指向头节点利用->next来增加或者删除修改值。所以必须为头节点申请内存空间没有头节点就意味着头指针直接指向带有数据的节点，有头节点不需要进行头插或者修改头部时进行头指针的重定向，没有头节点相对来说写代码稍微复杂一点。具体来讲：

1. 有头节点的链表：

   • 在链表的头部添加了一个额外的节点，称为头节点或哨兵节点。头节点不存储实际的数据，仅作为链表的起始位置。
   • 头节点可以简化链表的操作，因为它使得链表的第一个节点始终有一个前驱节点。
   • 头节点可以帮助处理边界情况，例如空链表或只有一个节点的链表。
   • 头节点的存在使得链表的插入和删除操作具有一致的逻辑，无需特殊处理头部节点的情况。

2. 没有头节点的链表：

   • 没有额外的头节点，链表的第一个节点就是存储实际数据的节点。
   • 没有头节点会导致一些特殊情况需要单独处理，例如在链表的头部插入节点时，需要更新链表的头指针。
   • 没有头节点可能需要更多的代码来处理特殊情况，例如处理空链表的情况。

选择使用有头节点还是没有头节点的链表实现方式取决于具体的需求和使用场景。有头节点的链表通常在编写和理解代码时更加方便，而没有头节点的链表可能更加节省内存空间。

顺序表节点中存放数组和数组长度，通过节点指针指向该节点对数组做修改，顺序表是静态申请内存空间的而链表是动态的，静态就代表搜索简单但是删改难，动态很明显就是增删改简单，查找需要从头节点依次进行（对于单向链表而言），双链表可以从任意节点搜索。静态内存分配比动态内存分配更容易产生内部碎片，频繁的修改会产生外部碎片和额外空间。