顺序表的基本操作（建立，插入，删除等）

最新推荐文章于 2024-06-22 19:02:56 发布

qq_73931224

最新推荐文章于 2024-06-22 19:02:56 发布

阅读量237

点赞数 1

文章标签：数据结构

本文链接：https://blog.csdn.net/qq_73931224/article/details/129770305

版权

代码段

# include<stdio.h>
# include <malloc.h>
#define LIST_MAX_LENGTH 10

// Linear list of integers. The key is data.

typedef struct SequentialList {
	int actualLength;
	int data[LIST_MAX_LENGTH]; // the maximum length is fixed.
}*SequentialListPtr;

//  Output the list.

void outputlist(SequentialListPtr paraList)
{
	for (int i = 0; i < paraList->actualLength; i++)
	{
		printf("%d ", paraList->data[i]);
	}//of for i
	printf("\r\n");
}// of outputList

// Output the memory for the list.

void outputmemory(SequentialListPtr paraListPtr)
{
	printf("The address of the structure: %p\r\n", paraListPtr);
	printf("The address of the actualLength: %p\r\n", &paraListPtr->actualLength);
	printf("The address of the data: %p\r\n", &paraListPtr->data);
	printf("The address of the actual data: %p\r\n", &paraListPtr->data[0]);
	printf("The address of the actual data: %p\r\n", &paraListPtr->data[1]);
}// of outputmemory

/*
Initialize a sequential list. No error checking for this funtion.
@param paraListPtr  The pointer to the list.It must be a pointer to change the list.
@param paraValues An int array storing all elements.
*/

SequentialListPtr sequentialListInit(int paraData[], int paraLength) {
	SequentialListPtr resultPtr = (SequentialListPtr)malloc(sizeof(struct SequentialList));
	for (int i = 0; i < paraLength; i++) {
		if (resultPtr != NULL)
			resultPtr->data[i] = paraData[i];
	}
	if (resultPtr != NULL)
		resultPtr->actualLength = paraLength;
	return resultPtr;
}//of sequentialListInit

/*
Insert an element into a sequential linear list.
@param paraListPtr The pointer to the list. It must be a pointer to change the list.
@param paraPosition The position,0 stands for inserting at the first position.
@param paraValue The value to be inserted.
*/

void sequentialListInsert(SequentialListPtr paraListPtr, int paraPosition, int paraValue) {
	// step 1 Space check.
	if (paraListPtr->actualLength >= LIST_MAX_LENGTH) {
		printf("Cannot insert element: list full.\r\n");
		return;
	}
	//step 2 Position check.
	if (paraPosition < 0) {
		printf("Cannot insert element: negative position unsupported.");
		return;
	}

	if (paraPosition > paraListPtr->actualLength) {
		printf("Cannot insert element: the position %d is bigger than the list length %d.\r\n", paraPosition, paraListPtr->actualLength);
		return;
	}
	//step 3 Move the remaining part.
	for (int i = paraListPtr->actualLength; i > paraPosition; i--)
	{
		paraListPtr->data[i] = paraListPtr->data[i - 1];
	}
	//step 4.insert
	paraListPtr->data[paraPosition] = paraValue;
	//step 5 Updata the length.
	paraListPtr->actualLength++;
}// of sequentialListInsert

// Tset the insert function.

void sequentialInsertTest() {
	int i;
	int tempArray[5] = { 3,5,2,7,4 };
	printf("----sequentialInsertTest begins.----\r\n");
	// Initialize
	SequentialListPtr tempList = sequentialListInit(tempArray, 5);
	printf("After initalization, the list is: ");
	outputlist(tempList);

	//Insert to the first.
	printf("Now insert to the first, the list is: ");
	sequentialListInsert(tempList, 0, 8);
	outputlist(tempList);
	// Insert to the last
	printf("Now insert to the last, the list is: ");
	sequentialListInsert(tempList, 6, 9);
	outputlist(tempList);

	//Insert beyond the tail.
	printf("Now insert beyond the tail.");
	sequentialListInsert(tempList, 8, 9);
	outputlist(tempList);
	printf("The list is: ");
	outputlist(tempList);

	// Insert to position 3.
	for (i = 0; i < 5; i++) {
		printf("Inserting %d.\r\n", (i + 10));
		sequentialListInsert(tempList, 0, (i + 10));
		outputlist(tempList);
	}
	printf("----sequentialInsertTest ends.----\r\n");
}// of sequentialInsertTest

/*
Delete an element from a sequential linear list.
  @param paraListPtr The pointer to the list. It must be a pointer to change the list.
  @param paraPosition The position, e.g., 0 stands for inserting at the first position.
  @return The deleted value.
*/

int sequentialListDelete(SequentialListPtr paraListPtr, int paraPosition) {
	// step 1 Position check
	if (paraPosition < 0) {
		printf("Invalid position: %d.\r\n", paraPosition);
		return -1;
	}
	if (paraPosition >= paraListPtr->actualLength) {
		printf("Cannot delete element: the position %d is beyond the list length %d.\r\n", paraPosition, paraListPtr->actualLength);
		return -1;
	}
	// step 2 Move the remaining part
	int resultValue = paraListPtr->data[paraPosition];
	for (int i = paraPosition; i < paraListPtr->actualLength; i++) {
		paraListPtr->data[i] = paraListPtr->data[i + 1];
	}
	// step 3 Updata the length
	paraListPtr->actualLength--;
	// step 4 Return the value.
	return resultValue;
}//of sequentialListDelete


// Test the delete function

void sequentialDeleteTest() {
	int tempArray[5] = { 3,5,2,7,4 };
	printf("----sequentialDeleteTest begins.---\r\n");

	//Initialize.
	SequentialListPtr templist = sequentialListInit(tempArray, 5);
	printf("After initialization, the list is: ");
	outputlist(templist);

	//Delete the first
	printf("Now delete the first, the list is: ");
	sequentialListDelete(templist, 0);
	outputlist(templist);

	//Delete the last
	printf("Now delete the last, the list is: ");
	sequentialListDelete(templist, 3);
	outputlist(templist);

	//Delete the second.
	printf("Now delete the second, the list is: ");
	sequentialListDelete(templist, 1);
	outputlist(templist);

	//Delete the 6th
	printf("Now delete the 6th, the list is: ");
	sequentialListDelete(templist, 5);
	outputlist(templist);

	//Delete the -6
	printf("Now delete the -6th, the list is: ");
	sequentialListDelete(templist, -6);
	outputlist(templist);

	printf("----sequentialDeleteTest ends.----\r\n");
	outputmemory(templist);
}//of sequentialDeleteTest

/*
Locate an element in the list.
@param paraListPtr The pointer to the list.
@param paravalue the indicated value.
@ return The position fo the value, or -1 indicating not exists
*/

int locateElement(SequentialListPtr paraListPtr, int paraValue) {
	for (int i = 0; i < paraListPtr->actualLength; i++) {
		if (paraListPtr->data[i] == paraValue) {
			return i;
		}
	}
	return -1;
}// of locateElement

/*
Get an element in the list
@param paraListPtr The pointer to the list
@param paraPosition The given position.
@return The position of value,or return -1 indicating not exists
*/
int getElement(SequentialListPtr paraListPtr, int paraPosition) {
	// step1 Position check
	if (paraPosition < 0) {
		printf("Invalid position: %d.\r\n", paraPosition);
		return -1;
	}
	if (paraPosition >= paraListPtr->actualLength) {
		printf("Cannot get element: the position %d is beyond the list length %d.\r\n", paraPosition, paraListPtr->actualLength);
		return -1;
	}
	return paraListPtr->data[paraPosition];
}//of locateElement


// Clear elements in the list

void clearList(SequentialListPtr paraListPtr) {
	paraListPtr->actualLength = 0;
}// of clearList

int  main() {
	sequentialInsertTest();
	sequentialDeleteTest();
	return 0;
}