A complex number can be represented by two parts, real and image. A series complex data can be organized as a group of elements by linked list, which is shown as below: struct Complex

{

float real; float image;

struct Complex *next;

};

1. Complete the following functions.

struct Complex* Generate (float a, float b)

{

// return one new Complex node

}

void Push (struct Complex **source, struct Complex *newNode)

{

// create linked list data by "stack" creation,

// insert the newNode into the head of source.

// (backward linked list creation)

}

void Print (struct Complex *source)

{

// print out all linked list data as the form, A+Bi,

// and the related distance, |A+Bi|

}

1. Complete the following functions.

void FrontBackSplit (struct Complex* source, struct Complex** front, struct Complex** back)

{

// Split the nodes of the given list into front and back halves,

// and return the two lists using the reference parameters.

// If the length is odd, the extra node should go in the front list.

// You will probably need special case code to deal with the

// (length <2) cases.

}

void Sort (struct Complex **source)

{

// sort the data of linked list source in increasing order of

// complex number distance

}

1. Complete the following functions.

struct Complex* AppendMergeReal (struct Complex* source1,

struct Complex* source2)

{

// Merge two complex linked lists (source1 and source2) into

// union of real part of source1 and source2.

// For example, real part of source1 are {1 2 3 3 5}, and real part

// of source2 are {2 3 5 8 8 9}, the merged result are {1 2 3 3 5 8 8 9}.

}

1. (Bonus) Complete the following functions.

void RecursiveReverse (struct Complex** source)

{

// Recursively reverses the given linked list by changing its .next

// pointers and its head pointer in one pass of the list.

}

Please verify your program by following test code

int main()

{

float data1_real[11]   = {3, 2, -5, -9,   7, 9, 4, -2,   4, -7, -7};

float data1_image[11] = {7, -8, -7, 5, -2, 4, 4, 3, -6, 7, 9};

struct Complex *newNode;

struct Complex *source1 = NULL, *dest = NULL;

struct Complex *front, *back; char c;

// Generate Complex data linked list with data1 for (int i=0; i<11; i++) {

newNode = Generate(data1_real[i], data1_image[i]); Push(&source1, newNode);

}

// print out complex data of source1 printf("Original data of source1:\n"); Print(source1);

// use FrontBackSplit() to divide source1 data into front part

// and back part, and print out these two split data FrontBackSplit(source1, &front, &back); printf("\nFront part:\n");

print(front); pritf("\nBack part:\n"); print(back);

// sort input complex data according to the distance

// and print out sorted data of front and back individually printf("\nSorted front part:\n");

Sort(&front); Print(front);

printf("\nSorted back part:\n"); Sort(&back);

Print(back);

printf("\n=====================================================\n");

// sorted data according to real part

struct Complex *source2 = NULL, *source3 = NULL; struct Complex *result;

// Generate Complex data linked list with data2 and data3 for (int i=5; i>=0; i--) {

newNode = Generate(data2_real[i], data2_image[i]); Push(&source2, newNode);

}

for (int i=7; i>=0; i--) {

newNode = Generate(data3_real[i], data3_image[i]); Push(&source3, newNode);

}

// Verify AppendMergeReal() function and print out the result printf("\nOriginal data of source2:\n");

Print(source2);

printf("\nOriginal data of source3:\n"); Print(source3);

printf("\nMerged data of source2 and source3:\n"); result = AppendMergeReal(source2, source3); Print(result);

// Reverse merged data of source2 and source3 and print out the result printf("\nReverse test (merged data):\n"); RecursiveReverse(&result);

Print(result);

getch(); return 1;

}