4....静态链表

静态链表

在这里想先讲解一下自己对于静态链表的理解
静态链表自然一开始就固定的大小 你可以形象的理解为有头指针的结构体数组 这一点很关键
对于它的地址 则是一开始就分配好的固定大小
当然 下面代码：

//定义静态链表节点

typedef struct StaticLinkedNode {
	char data;

	int next;
} *NodePtr;


typedef struct StaticLinkedList {
	NodePtr nodes;
	int *used;
} *ListPtr;

//定义表头 我认为同理上面说的结构体数组头

ListPtr initLinkedList() {
	
	//申请头
	
	
	ListPtr tempPtr = (ListPtr)malloc(sizeof(StaticLinkedList));


	//规定大小空间 
	
	tempPtr->nodes = (NodePtr)malloc(sizeof(struct StaticLinkedNode) * DEFAULT_SIZE);
	tempPtr->used = (int *)malloc(sizeof(int) * DEFAULT_SIZE);

	
	
	
	//初始化数据
	
	tempPtr->nodes[0].data = '\0';
	tempPtr->nodes[0].next = -1;


	//用量为1
	//nodes[0] 永远存储头节点.
	tempPtr->used[0] = 1;

	for (int i = 1; i < DEFAULT_SIZE; i ++) {

		tempPtr->used[i] = 0;
	}
	// used 存储空间使用情况, 0 表示空闲, 1 表示被占用.

	return tempPtr;
}

打印链表

void printList(ListPtr paraListPtr) {
	int p = 0;
    //循环往复  直至静态链表尾巴
    
	while (p != -1) {
		printf("%c", paraListPtr->nodes[p].data);
		p = paraListPtr->nodes[p].next;
	}

	printf("\r\n");
}

元素插入

void insertElement(ListPtr paraListPtr, char paraChar, int paraPosition) {
	int p, q, i;

	
	p = 0;
    //循环找位置
    
    
    
	for (i = 0; i < paraPosition; i ++) {

		p = paraListPtr->nodes[p].next;

		if (p == -1) {
			printf("The position %d is beyond the scope of the list.\r\n", paraPosition);
			return;
		}
	} 

	//查找最大位置
	
	
	for (i = 1; i < DEFAULT_SIZE; i ++) {

		if (paraListPtr->used[i] == 0) {
			// This is identical to malloc.
			printf("Space at %d allocated.\r\n", i);
			paraListPtr->used[i] = 1;
			q = i;
			break;
			
			//如果找到空位  q记录其位置 
		}
	}
	
	
	
    //判断位置==maxsize
    
	if (i == DEFAULT_SIZE) {
		printf("No space.\r\n");
		return;
	}
    
    
    //建立新节点
	paraListPtr->nodes[q].data = paraChar;

	// 连接  这个连接
	printf("linking\r\n");
	paraListPtr->nodes[q].next = paraListPtr->nodes[p].next;
	//q复制前一个节点p的下指向元素
	
	paraListPtr->nodes[p].next = q;
	//当然 p 该指向 q 了
	
	
}

元素删除

void deleteElement(ListPtr paraListPtr, char paraChar) {
	int p, q;
	p = 0;
     //定义临时变量
     
     
	while ((paraListPtr->nodes[p].next != -1) && (paraListPtr->nodes[paraListPtr->nodes[p].next].data != paraChar)) {
		
		p = paraListPtr->nodes[p].next;
		//nodes[0] 永远存储头节点.
		//所以要从最开始的Nodes【p】.next的结构体开始查询
		
	}// Of while
    //判断是否查找合法
    
	if (paraListPtr->nodes[p].next == -1) {
		printf("Cannot delete %c\r\n", paraChar);
		return;
	}// Of if
    
    
    //q记录删除的位置
    
	q = paraListPtr->nodes[p].next;
	
	//删除操作 即跳过该元素
	
	paraListPtr->nodes[p].next = paraListPtr->nodes[paraListPtr->nodes[p].next].next;

	// 删除位置
	
	paraListPtr->used[q] = 0;
}

增添删除测试

void appendInsertDeleteTest() {
	
	ListPtr tempList = initLinkedList();
	
	printList(tempList);

	
	insertElement(tempList, 'H', 0);
	
	insertElement(tempList, 'e', 1);
	
	
	insertElement(tempList, 'l', 2);
	
	insertElement(tempList, 'l', 3);
	
	insertElement(tempList, 'o', 4);
	
	
	printList(tempList);

	
	printf("Deleting 'e'.\r\n");
	deleteElement(tempList, 'e');
	
	printf("Deleting 'a'.\r\n");
	
	deleteElement(tempList, 'a');
	
	printf("Deleting 'o'.\r\n");
	
	deleteElement(tempList, 'o');
	printList(tempList);

	insertElement(tempList, 'x', 1);
	printList(tempList);
}


int main() {
	appendInsertDeleteTest();
}

运行截图